МФЦ — Обзор

Библиотека Microsoft Foundation Class (MFC) предоставляет набор функций, констант, типов данных и классов для упрощения создания приложений для операционных систем Microsoft Windows. В этом руководстве вы узнаете все о том, как запускать и создавать приложения на базе Windows с помощью MFC.

Предпосылки

Мы предположили, что вы знаете следующее —

• Немного о программировании для Windows.
• Основы программирования на C ++.
• Понимать основы объектно-ориентированного программирования.

Что такое МФЦ?

Microsoft Foundation Class Library (MFC) — это «среда приложения» для программирования в Microsoft Windows. MFC предоставляет большую часть кода, который требуется для следующего —

• Управление Windows.
• Меню и диалоговые окна.
• Выполнение основного ввода / вывода.
• Хранение коллекций объектов данных и т. Д.

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

MFC Framework

• Инфраструктура MFC предоставляет набор повторно используемых классов, предназначенных для упрощения программирования Windows.

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

• Он также предоставляет классы для общих API-интерфейсов Windows и структур данных, таких как окна, элементы управления и контексты устройства.

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

• Кроме того, MFC предоставляет среду приложения, включая классы, составляющие иерархию архитектуры приложения.

Инфраструктура MFC предоставляет набор повторно используемых классов, предназначенных для упрощения программирования Windows.

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

Он также предоставляет классы для общих API-интерфейсов Windows и структур данных, таких как окна, элементы управления и контексты устройства.

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

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

Почему МФЦ?

Платформа MFC — это мощный подход, который позволяет вам опираться на работу опытных программистов для Windows. Структура MFC имеет следующие преимущества.

• Это сокращает время разработки.

• Это делает код более переносимым.

• Он также обеспечивает огромную поддержку, не уменьшая свободу и гибкость программирования.

• Он обеспечивает легкий доступ к «сложным для программирования» элементам и технологиям пользовательского интерфейса.

• MFC упрощает программирование базы данных с помощью объектов доступа к данным (DAO) и Open Database Connectivity (ODBC), а также сетевое программирование с помощью сокетов Windows.

Это сокращает время разработки.

Это делает код более переносимым.

Он также обеспечивает огромную поддержку, не уменьшая свободу и гибкость программирования.

Он обеспечивает легкий доступ к «сложным для программирования» элементам и технологиям пользовательского интерфейса.

MFC упрощает программирование базы данных с помощью объектов доступа к данным (DAO) и Open Database Connectivity (ODBC), а также сетевое программирование с помощью сокетов Windows.

MFC — Настройка среды

Microsoft Visual C ++ — это среда программирования, используемая для создания приложений для операционных систем Microsoft Windows. Для использования инфраструктуры MFC в вашем приложении C ++ вы должны установить Microsoft Visual C ++ или Microsoft Visual Studio. Microsoft Visual Studio также содержит среду Microsoft Visual C ++.

Microsoft предоставляет бесплатную версию Visual Studio, которая также содержит SQL Server, и ее можно скачать с https://www.visualstudio.com/en-us/downloads/downloadvisual- studio-vs.aspx .

Ниже приведены шаги установки.

Шаг 1. После загрузки Visual Studio запустите установщик. Появится следующее диалоговое окно.

Шаг 2 — Нажмите «Установить», чтобы начать процесс установки.

Шаг 3. После успешной установки Visual Studio вы увидите следующее диалоговое окно.

Шаг 4 — Закройте это диалоговое окно и перезагрузите компьютер, если это необходимо.

Шаг 5 — Откройте Visual Studio из меню «Пуск», которое откроет следующее диалоговое окно. Это займет некоторое время для подготовки, начиная с первого раза.

Шаг 6 — Далее вы увидите главное окно Visual Studio.

Шаг 7 — Теперь вы готовы запустить приложение.

MFC — VC ++ Projects

В этой главе мы рассмотрим различные типы проектов VC ++. Visual Studio включает несколько видов шаблонов проектов Visual C ++. Эти шаблоны помогают создавать базовую структуру программы, меню, панели инструментов, значки, ссылки и включают в себя операторы, соответствующие типу проекта, который вы хотите создать. Ниже приведены некоторые характерные особенности шаблонов.

• Он предоставляет мастера для многих из этих шаблонов проектов и помогает настраивать проекты по мере их создания.

• Как только проект создан, вы можете создать и запустить приложение.

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

• Легче изменить предоставленные файлы проекта и структуру, чем создать их с нуля.

Он предоставляет мастера для многих из этих шаблонов проектов и помогает настраивать проекты по мере их создания.

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

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

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

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

Приложение MFC

Приложение MFC — это исполняемое приложение для Windows, основанное на библиотеке Microsoft Foundation Class (MFC). Самый простой способ создать приложение MFC — использовать мастер приложений MFC.

MFC ActiveX Control

Управляющие программы ActiveX — это модульные программы, разработанные для предоставления определенного типа функциональности родительскому приложению. Например, вы можете создать элемент управления, например кнопку для использования в диалоговом окне, на панели инструментов или на веб-странице.

MFC DLL

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

Ниже приведены некоторые общие шаблоны, которые также можно использовать для создания приложения MFC.

Пустой проект

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

Custom Wizard

Visual C ++ Custom Wizard — это инструмент, который нужно использовать, когда вам нужно создать новый настраиваемый мастер. Самый простой способ создать настраиваемый мастер — использовать настраиваемый мастер.

MFC — Начало работы

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

Создать проект с использованием шаблонов проектов

Ниже приведены шаги по созданию проекта с использованием шаблонов проектов, доступных в Visual Studio.

Шаг 1 — Откройте Visual Studio и выберите пункт меню Файл → Создать → Проект.

Шаг 2 — Теперь вы можете видеть, что диалоговое окно New Project открыто.

Шаг 3 — На левой панели выберите Шаблоны → Visual C ++ → MFC

Шаг 4 — В средней панели выберите Приложение MFC.

Шаг 5 — Введите имя проекта «MFCDemo» в поле «Имя» и нажмите «ОК» для продолжения. Вы увидите следующий диалог.

Шаг 6 — Нажмите Далее.

Шаг 7 — Выберите параметры, которые отображаются в диалоговом окне, указанном выше, и нажмите «Далее».

Шаг 8 — Снимите все флажки и нажмите кнопку Готово.

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

Шаг 9 — Запустите это приложение, вы увидите следующий вывод.

Создать проект с нуля

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

Шаг 1 — Откройте Visual Studio и выберите пункт меню Файл → Создать → Проект.

Шаг 2 — Теперь вы можете увидеть диалоговое окно New Project.

Шаг 3 — На левой панели выберите Шаблоны → Visual C ++ → Общие.

Шаг 4 — В средней панели выберите Пусто

Шаг 5 — Введите имя проекта «MFCDemoFromScratch» в поле «Имя» и нажмите «ОК» для продолжения. Вы увидите, что создан пустой проект.

Шаг 6 — Чтобы сделать его проектом MFC, щелкните правой кнопкой мыши проект и выберите «Свойства».

Шаг 7 — В левой части выберите Свойства конфигурации → Общие.

Шаг 8. Выберите параметр «Использовать MFC в общей библиотеке DLL» в разделе «Параметры проекта по умолчанию» и нажмите «ОК».

Шаг 9 — Так как сейчас это пустой проект; нам нужно добавить файл C ++. Итак, щелкните правой кнопкой мыши на проекте и выберите Добавить → Новый элемент …

Шаг 10 — Выберите C ++ File (.cpp) в средней панели, введите имя файла в поле Name и нажмите кнопку Add.

Шаг 11 — Теперь вы можете увидеть файл main.cpp, добавленный в папку «Исходные файлы».

Шаг 12 — Давайте добавим следующий код в этот файл.

#include <iostream> 
using namespace std;  

void main() { 
   cout << "***************************************\n"; 
   cout << "MFC Application Tutorial"; 
   cout << "\n***************************************"; 
   getchar(); 
}

Шаг 13 — Когда вы запустите это приложение, вы увидите следующий вывод на консоли.

*************************************** 
MFC Application Tutorial 
***************************************

MFC — Основы Windows

В этой главе мы расскажем об основах Windows. Чтобы создать программу, также называемую приложением, вы извлекаете класс из CFC-приложения MFC. CWinApp расшифровывается как Class для приложения Windows.

Давайте рассмотрим простой пример, создав новый проект Win32.

Шаг 1 — Откройте Visual Studio и выберите пункт меню Файл → Создать → Проект.

Шаг 2 — Теперь вы можете увидеть диалоговое окно New Project.

Шаг 3 — На левой панели выберите Шаблоны → Visual C ++ → Win32.

Шаг 4 — В средней панели выберите Win32 Project.

Шаг 5 — Введите имя проекта «MFCWindowDemo» в поле «Имя» и нажмите «ОК» для продолжения. Вы увидите следующее диалоговое окно.

Шаг 6 — Нажмите Далее.

Шаг 7 — Выберите параметры, как показано в приведенном выше диалоговом окне, и нажмите «Готово».

Шаг 8 — Пустой проект создан.

Шаг 9 — Чтобы сделать его проектом MFC, щелкните проект правой кнопкой мыши и выберите «Свойства».

Шаг 10 — В левом разделе нажмите Свойства конфигурации → Общие.

Шаг 11 — Выберите параметр «Использовать MFC в общей библиотеке DLL» в разделе «Параметры проекта по умолчанию» и нажмите «ОК».

Шаг 12 — Добавьте новый исходный файл.

Шаг 13 — Щелкните правой кнопкой мыши свой проект и выберите Добавить → Новый элемент …

Шаг 14 — В разделе Шаблоны выберите Файл C ++ (.cpp).

Шаг 15 — Установите имя в качестве примера и нажмите «Добавить».

Создание окна

Любое приложение имеет два основных раздела —

• Учебный класс
• Рамка или Окно

Давайте создадим окно, используя следующие шаги —

Шаг 1 — Чтобы создать приложение, нам нужно извлечь класс из CWinApp MFC.

#include
class CExample : public CWinApp {
   BOOL InitInstance() {
      return TRUE;
   }
};

Шаг 2 — Нам также нужен фрейм / окно для отображения содержимого нашего приложения.

Шаг 3 — Для этого нам нужно добавить еще один класс и извлечь его из класса CFrameWnd MFC, реализовать его конструктор и вызвать метод Create (), который создаст кадр / окно, как показано в следующем коде.

class CMyFrame : public CFrameWnd {
   public:
      CMyFrame() {
         Create(NULL, _T("MFC Application Tutorial"));
      }
};

Шаг 4. Как видите, для метода Create () нужны два параметра: имя класса, которое должно быть передано как NULL, и имя окна, которое является строкой, которая будет отображаться в строке заголовка.

Главное окно

После создания окна, чтобы позволить приложению использовать его, вы можете использовать указатель, чтобы показать класс, используемый для создания окна. В этом случае указатель будет CFrameWnd. Чтобы использовать окно фрейма, присвойте его указатель переменной-члену CWinThread :: m_pMainWnd. Это делается в реализации InitInstance () вашего приложения.

Шаг 1 — Вот реализация InitInstance () в классе CExample.

class CExample : public CWinApp {
   BOOL InitInstance() {
      CMyFrame *Frame = new CMyFrame();  m_pMainWnd = Frame;
      
      Frame->ShowWindow(SW_NORMAL);
      Frame->UpdateWindow();
      
      return TRUE;
   }
};

Шаг 2 — Ниже приведена полная реализация файла Example.cpp.

#include <afxwin.h>

class CMyFrame : public CFrameWnd {
   public:
      CMyFrame() {
         Create(NULL, _T("MFC Application Tutorial"));
      }
};

class CExample : public CWinApp {
   BOOL InitInstance() {
      CMyFrame *Frame = new CMyFrame();
      m_pMainWnd = Frame;
      
      Frame->ShowWindow(SW_NORMAL);
      Frame->UpdateWindow();
      
      return TRUE;
   }
};

CExample theApp;

Шаг 3 — Когда мы запускаем вышеуказанное приложение, создается следующее окно.

Стили Windows

Стили Windows — это характеристики, которые управляют такими функциями, как внешний вид окна, границы, свернутое или развернутое состояние или другие состояния изменения размера и т. Д.

WS_BORDER

Создает окно с рамкой.

WS_CAPTION

Создает окно с заголовком (подразумевает стиль WS_BORDER). Не может использоваться со стилем WS_DLGFRAME.

WS_CHILD

Создает дочернее окно. Не может использоваться со стилем WS_POPUP.

WS_CHILDWINDOW

То же, что и стиль WS_CHILD.

WS_CLIPCHILDREN

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

стиль WS_CLIPSIBLINGS

Обрезает дочерние окна относительно друг друга; то есть, когда конкретное дочернее окно получает сообщение рисования, стиль WS_CLIPSIBLINGS обрезает все другие перекрывающиеся дочерние окна из области дочернего окна, подлежащей обновлению. (Если WS_CLIPSIBLINGS не задан и дочерние окна перекрываются, когда вы рисуете в клиентской области дочернего окна, можно рисовать в клиентской области соседнего дочернего окна.) Только для использования со стилем WS_CHILD.

WS_DISABLED

Создает окно, которое изначально отключено.

WS_DLGFRAME

Создает окно с двойной рамкой, но без заголовка.

WS_GROUP

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

WS_HSCROLL

Создает окно с горизонтальной полосой прокрутки.

WS_ICONIC

Создает окно, которое изначально свернуто. То же, что и стиль WS_MINIMIZE.

WS_MAXIMIZE

Создает окно максимального размера.

WS_MAXIMIZEBOX

Создает окно с кнопкой «Развернуть».

WS_MINIMIZE

Создает окно, которое изначально свернуто. Только для использования со стилем WS_OVERLAPPED.

WS_MINIMIZEBOX

Создает окно с кнопкой «Свернуть».

WS_OVERLAPPED

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

WS_OVERLAPPED WINDOW

Создает перекрывающееся окно со стилями WS_OVERLAPPED, WS_CAPTION, WS_SYSMENU, WS_THICKFRAME, WS_MINIMIZEBOX и WS_MAXIMIZEBOX.

WS_POPUP

Создает всплывающее окно. Не может использоваться со стилем WS_CHILD.

WS_POPUPWINDOW

Создает всплывающее окно со стилями WS_BORDER, WS_POPUP и WS_SYSMENU. Стиль WS_CAPTION должен сочетаться со стилем WS_POPUPWINDOW, чтобы сделать меню управления видимым.

WS_SIZEBOX

Создает окно с границей размеров. То же, что и стиль WS_THICKFRAME.

WS_SYSMENU

Создает окно, которое имеет строку меню Control в строке заголовка. Используется только для окон с заголовками.

WS_TABSTOP

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

WS_THICKFRAME

Создает окно с толстой рамкой, которое можно использовать для определения размера окна.

WS_TILED

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

WS_TILEDWINDOW

Создает перекрывающееся окно со стилями WS_OVERLAPPED, WS_CAPTION, WS_SYSMENU, WS_THICKFRAME, WS_MINIMIZEBOX и WS_MAXIMIZEBOX. То же, что и стиль WS_OVERLAPPEDWINDOW.

WS_VISIBLE

Создает окно, которое изначально видно.

WS_VSCROLL

Создает окно с вертикальной полосой прокрутки.

Шаг 1 — Давайте посмотрим на простой пример, в котором мы добавим некоторые стили. После создания окна, чтобы отобразить его пользователю, мы можем применить к нему стиль WS_VISIBLE и дополнительно добавим стиль WS_OVERLAPPED. Вот реализация —

class CMyFrame : public CFrameWnd {
   public:
      CMyFrame() {
         Create(NULL, _T("MFC Application Tutorial"), WS_VISIBLE | WS_OVERLAPPED);
      }
};

Шаг 2 — Когда вы запускаете это приложение, создается следующее окно.

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

Расположение Windows

Для определения местоположения объектов, отображаемых на мониторе, компьютер использует систему координат, аналогичную декартовой, но начало координат находится в верхнем левом углу экрана. Используя эту систему координат, любая точка может быть расположена на расстоянии от верхнего левого угла экрана по горизонтальной и вертикальной осям.

Библиотека Win32 предоставляет структуру POINT, определенную следующим образом:

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

• Переменная-член ‘x’ — это расстояние от левой границы экрана до точки.

• Переменная ‘y’ представляет расстояние от верхней границы экрана до точки.

• Помимо структуры POINT в Win32, библиотека Microsoft Foundation Class (MFC) предоставляет класс CPoint.

• Это обеспечивает ту же функциональность, что и структура POINT. Как класс C ++, он добавляет больше функциональности, необходимой для определения местоположения точки. Он предоставляет два конструктора.

Переменная-член ‘x’ — это расстояние от левой границы экрана до точки.

Переменная ‘y’ представляет расстояние от верхней границы экрана до точки.

Помимо структуры POINT в Win32, библиотека Microsoft Foundation Class (MFC) предоставляет класс CPoint.

Это обеспечивает ту же функциональность, что и структура POINT. Как класс C ++, он добавляет больше функциональности, необходимой для определения местоположения точки. Он предоставляет два конструктора.

CPoint();
CPoint(int X, int Y);

Размер Windows

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

• Ширина объекта.
• Высота объекта.

Библиотека Win32 использует структуру SIZE, определенную следующим образом:

typedef struct tagSIZE {
   int cx;
   int cy;
} SIZE;

Помимо структуры SIZE в Win32, MFC предоставляет класс CSize. Этот класс имеет те же функциональные возможности, что и SIZE, но добавляет функции класса C ++. Он предоставляет пять конструкторов, которые позволяют вам создавать переменные размера любым способом по вашему выбору.

CSize();
CSize(int initCX, int initCY);
CSize(SIZE initSize);
CSize(POINT initPt);
CSize(DWORD dwSize);

Размеры Windows

Когда отображается окно, его можно определить на экране по его расположению относительно границ монитора. Окно также можно определить по ширине и высоте. Эти характеристики указываются или управляются прямым аргументом метода Create () . Этот аргумент представляет собой прямоугольник, который можно создать с помощью структуры Win32 RECT.

typedef struct _RECT {
   LONG left;
   LONG top;
   LONG right;
   LONG bottom;
} RECT, *PRECT;

Помимо структуры RECT Win32, MFC предоставляет класс CRect, который имеет следующие конструкторы:

CRect();
CRect(int l, int t, int r, int b);
CRect(const RECT& srcRect);
CRect(LPCRECT lpSrcRect);
CRect(POINT point, SIZE size);
CRect(POINT topLeft, POINT bottomRight);

Давайте посмотрим на простой пример, в котором мы будем указывать расположение и размер окна

class CMyFrame : public CFrameWnd {
   public:
      CMyFrame() {
         Create(NULL, _T("MFC Application Tutorial"), WS_SYSMENU, CRect(90, 120, 
            550, 480));
      }
};

При запуске этого приложения в верхнем левом углу экрана создается следующее окно, как указано в конструкторе CRect в первых двух параметрах. Последние два параметра — это размер окна.

Windows Parents

В реальном мире многие приложения сделаны из разных окон. Когда приложение использует различные Windows, большинство объектов зависят от конкретного. Это может быть первое окно, которое было создано, или другое окно, которое вы определили. Такое окно называется родительским окном . Все остальные окна зависят от этого прямо или косвенно.

• Если создаваемое вами окно зависит от другого, вы можете указать, что у него есть родительский элемент.

• Это делается с помощью аргумента pParentWnd метода CFrameWnd :: Create ().

• Если у окна нет родителя, передайте аргумент со значением NULL.

Если создаваемое вами окно зависит от другого, вы можете указать, что у него есть родительский элемент.

Это делается с помощью аргумента pParentWnd метода CFrameWnd :: Create ().

Если у окна нет родителя, передайте аргумент со значением NULL.

Давайте рассмотрим пример, в котором есть только одно окно, а родительское окно недоступно, поэтому мы передадим аргумент со значением NULL, как показано в следующем коде:

class CMyFrame : public CFrameWnd {
   public:
      CMyFrame() {
         Create(NULL, _T("MFC Application Tutorial"), WS_SYSMENU, 
            CRect(90, 120, 550, 480), NULL);
      }
};

Когда вы запускаете вышеуказанное приложение, вы видите тот же вывод.

MFC — Диалоговые окна

В этой главе мы рассмотрим диалоговые окна. Приложения для Windows часто общаются с пользователем через диалоговые окна. Класс CDialog предоставляет интерфейс для управления диалоговыми окнами. Диалоговый редактор Visual C ++ позволяет легко проектировать диалоговые окна и создавать их ресурсы шаблона диалога.

• Создание объекта диалога является двухфазной операцией —

  • Построить объект диалога.

  • Создайте диалоговое окно.

Создание объекта диалога является двухфазной операцией —

Построить объект диалога.

Создайте диалоговое окно.

Давайте рассмотрим простой пример, создав новый проект Win32.

Шаг 1 — Откройте Visual Studio и выберите пункт меню Файл → Создать → Проект.

Шаг 2 — Теперь вы можете увидеть диалоговое окно New Project.

Шаг 3 — На левой панели выберите Шаблоны → Visual C ++ → Win32.

Шаг 4 — В средней панели выберите Win32 Project.

Шаг 5 — Введите имя проекта «MFCDialogDemo» в поле «Имя» и нажмите «ОК» для продолжения. Вы увидите следующий диалог.

Шаг 6 — Нажмите Далее.

Шаг 7 — Выберите параметры, показанные в диалоговом окне, указанном выше, и нажмите Готово.

Шаг 8 — Пустой проект создан.

Шаг 9 — Чтобы сделать его проектом MFC, щелкните проект правой кнопкой мыши и выберите «Свойства».

Шаг 10 — В левом разделе нажмите Свойства конфигурации → Общие.

Шаг 11 — Выберите параметр «Использовать MFC в общей библиотеке DLL» в разделе «Параметры проекта по умолчанию» и нажмите «ОК».

Шаг 12 — Добавьте новый исходный файл.

Шаг 13 — Щелкните правой кнопкой мыши по вашему проекту и выберите Добавить → Новый элемент.

Шаг 14 — В разделе «Шаблоны» нажмите «Файл C ++» (.cpp)

Шаг 15 — Установите имя в качестве примера и нажмите «Добавить».

Шаг 16. Чтобы создать приложение, нам нужно добавить класс и извлечь его из CWinApp MFC.

#include <afxwin.h>

class CExample : public CWinApp {
   public:
      BOOL InitInstance();
};

Создание диалогового окна

Шаг 1. Чтобы создать диалоговое окно, щелкните правой кнопкой мыши папку Resource Files в обозревателе решений и выберите Add → Resource.

Шаг 2 — В диалоговом окне «Добавить ресурс» выберите «Диалог» и нажмите «Создать».

Шаг 3 — Диалоговое окно требует некоторой подготовки, прежде чем фактически его создавать программно.

Шаг 4 — Сначала можно вручную создать диалоговое окно в виде текстового файла (в файле ресурсов).

Шаг 5 — Теперь вы можете увидеть файл MFCDialogDemo.rc, созданный в разделе Resource Files.

Шаг 6 — Файл ресурсов открыт в конструкторе. То же самое можно открыть как текстовый файл. Щелкните правой кнопкой мыши файл ресурса и выберите «Открыть с помощью».

Шаг 7 — Выберите редактор исходного кода (текст) и нажмите кнопку Добавить.

Шаг 8 — Вернитесь к конструктору, щелкните правой кнопкой мыши диалоговое окно и выберите «Свойства».

Шаг 9 — Вам нужно выбрать из множества вариантов.

Шаг 10 — Как и большинство других элементов управления, диалоговое окно должно быть идентифицировано. Идентификатор (ID) диалогового окна обычно начинается с IDD_. Давайте изменим ID на IDD_EXAMPLE_DLG.

Расположение диалога

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

Если вы посмотрите и окно свойств, вы увидите два поля, X Pos и ​​Y Pos.

• X — расстояние от левой границы монитора до левой границы диалогового окна.

• Y — расстояние от верхней границы монитора до верхней границы диалогового окна.

X — расстояние от левой границы монитора до левой границы диалогового окна.

Y — расстояние от верхней границы монитора до верхней границы диалогового окна.

По умолчанию эти поля установлены на ноль. Вы также можете изменить, как показано выше.

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

Диалоговое окно Размеры

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

Вы можете увидеть изменения ширины и высоты в строке состояния.

Методы диалоговых окон

Базовый класс, используемый для отображения диалоговых окон на экране, — это класс CDialog. Чтобы создать диалоговое окно, нам нужно извлечь класс из CDialog. Сам класс CDialog предоставляет три конструктора:

CDialog();
CDialog(UINT nIDTemplate, CWnd* pParentWnd = NULL);
CDialog(LPCTSTR lpszTemplateName, CWnd* pParentWnd = NULL);

Давайте создадим еще один класс CExampleDlg и выведем его из CDialog. Мы реализуем его конструктор по умолчанию, как показано в следующем коде.

class CExampleDlg : public CDialog {
   public:
      enum { IDD = IDD_EXAMPLE_DLG };
   
      CExampleDlg();
      ~CExampleDlg();
};

CExampleDlg::CExampleDlg():CDialog(CExampleDlg::IDD) {

}

CExampleDlg::~CExampleDlg() {

}

Нам нужно создать этот диалог в методе CExample :: InitInstance (), как показано в следующем коде.

BOOL CExample::InitInstance() {
   CExampleDlg myDlg;
   m_pMainWnd = &myDlg;
   
   return TRUE;
}

Модальные диалоговые окна

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

Немодальное диалоговое окно

• Для немодального диалогового окна вы должны предоставить свой собственный общедоступный конструктор в вашем диалоговом классе.

• Чтобы создать немодальное диалоговое окно, вызовите ваш общедоступный конструктор, а затем вызовите функцию Create member объекта диалога, чтобы загрузить ресурс диалога.

• Вы можете вызвать Create во время или после вызова конструктора. Если ресурс диалога имеет свойство WS_VISIBLE, диалоговое окно появляется немедленно.

• Если нет, вы должны вызвать его функцию-член ShowWindow.

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

Чтобы создать немодальное диалоговое окно, вызовите ваш общедоступный конструктор, а затем вызовите функцию Create member объекта диалога, чтобы загрузить ресурс диалога.

Вы можете вызвать Create во время или после вызова конструктора. Если ресурс диалога имеет свойство WS_VISIBLE, диалоговое окно появляется немедленно.

Если нет, вы должны вызвать его функцию-член ShowWindow.

Модальный диалог

• Чтобы создать модальное диалоговое окно, вызовите любой из двух открытых конструкторов, объявленных в CDialog.

• Затем вызовите функцию- член DoModal объекта диалога, чтобы отобразить диалоговое окно и управлять взаимодействием с ним, пока пользователь не выберет OK или Отмена.

• Это управление DoModal делает модальное диалоговое окно. Для модальных диалоговых окон DoModal загружает ресурс диалога.

Чтобы создать модальное диалоговое окно, вызовите любой из двух открытых конструкторов, объявленных в CDialog.

Затем вызовите функцию- член DoModal объекта диалога, чтобы отобразить диалоговое окно и управлять взаимодействием с ним, пока пользователь не выберет OK или Отмена.

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

Шаг 1 — Чтобы отобразить диалоговое окно как модальное, в событии CExample :: InitInstance () вызовите метод DoModal () с помощью вашей диалоговой переменной —

BOOL CExample::InitInstance() {
   CExampleDlg myDlg;
   m_pMainWnd = &myDlg;
   myDlg.DoModal();
   return TRUE;
}

Шаг 2 — Вот полная реализация файла Example.cpp.

#include <afxwin.h>
#include "resource.h"

class CExample : public CWinApp {
   public:
      BOOL InitInstance();
};
   
class CExampleDlg : public CDialog {
   public:
      enum { IDD = IDD_EXAMPLE_DLG };
   
      CExampleDlg();
     ~CExampleDlg();
};

CExampleDlg::CExampleDlg():CDialog(CExampleDlg::IDD) {

}

CExampleDlg::~CExampleDlg() {

}

BOOL CExample::InitInstance() {
   CExampleDlg myDlg;
   m_pMainWnd = &myDlg;
   myDlg.DoModal();
   return TRUE;
}
CExample MyApp;

Шаг 3 — Когда приведенный выше код скомпилирован и выполнен, вы увидите следующее диалоговое окно.

Приложения на основе диалогов

Microsoft Visual Studio предоставляет более простой способ создания приложения, основанного главным образом на диалоговом окне. Вот шаги для создания базового проекта диалога, используя шаблоны проектов, доступные в Visual Studio —

Шаг 1 — Откройте Visual Studio и выберите пункт меню Файл → Создать → Проект. Вы можете увидеть диалоговое окно New Project.

Шаг 2 — На левой панели выберите Шаблоны → Visual C ++ → MFC.

Шаг 3 — В средней панели выберите Приложение MFC.

Шаг 4 — Введите имя проекта «MFCModalDemo» в поле «Имя» и нажмите «ОК» для продолжения. Вы увидите следующее диалоговое окно.

Шаг 5 — Нажмите Далее.

Шаг 6 — Выберите параметры, показанные в диалоговом окне выше, и нажмите Далее.

Шаг 7 — Отметьте все параметры, которые вы выбрали в диалоговом окне, такие как «Развернуть и свернуть поля», и нажмите «Далее».

Шаг 8 — Нажмите Далее.

Шаг 9 — Он сгенерирует эти два класса. Вы можете изменить название классов и нажать «Готово».

Шаг 10. Теперь вы видите, что мастер MFC создает это диалоговое окно и файлы проекта по умолчанию.

Шаг 11 — Когда вы запустите это приложение, вы увидите следующий вывод.

MFC — ресурсы Windows

Ресурс — это текстовый файл, который позволяет компилятору управлять такими объектами, как изображения, звуки, курсоры мыши, диалоговые окна и т. Д. Microsoft Visual Studio особенно упрощает создание файла ресурсов, предоставляя необходимые инструменты в той же среде, которая используется для программирования. Это означает, что вам обычно не нужно использовать внешнее приложение для создания или настройки файла ресурсов. Ниже приведены некоторые важные функции, связанные с ресурсами.

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

• Растровые изображения, значки, панели инструментов и курсоры — все это ресурсы.

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

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

• Большинство ресурсов создаются путем выбора нужного из диалогового окна «Добавить ресурс».

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

Растровые изображения, значки, панели инструментов и курсоры — все это ресурсы.

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

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

Большинство ресурсов создаются путем выбора нужного из диалогового окна «Добавить ресурс».

• Диалоговое окно Add Resource предоставляет обширный список ресурсов, которые можно использовать в соответствии с требованиями, но если вам нужно что-то, что недоступно, вы можете добавить его вручную в файл * .rc перед выполнением программы.

Диалоговое окно Add Resource предоставляет обширный список ресурсов, которые можно использовать в соответствии с требованиями, но если вам нужно что-то, что недоступно, вы можете добавить его вручную в файл * .rc перед выполнением программы.

Идентификаторы

Идентификатор — это символ, который является постоянным целым числом, имя которого обычно начинается с идентификатора. Он состоит из двух частей — текстовой строки (имени символа), сопоставленной с целочисленным значением (значением символа).

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

• Когда вы создаете новый ресурс или объект ресурса, редакторы ресурсов предоставляют имя ресурса по умолчанию, например, IDC_DIALOG1, и присваивают ему значение.

• Определение «имя-плюс-значение» хранится в файле Resource.h.

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

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

Определение «имя-плюс-значение» хранится в файле Resource.h.

Шаг 1 — Давайте посмотрим на наш пример CMFCDialogDemo из последней главы, в которой мы создали диалоговое окно и его ID — IDD_EXAMPLE_DLG .

Шаг 2 — Перейдите в Solution Explorer, вы увидите файл resource.h в разделе Header Files. Продолжите, открыв этот файл в редакторе, и вы увидите идентификатор диалогового окна и его целочисленное значение.

Иконки

Значок — это маленькая картинка, используемая в окне, представляющая приложение. Он используется в двух основных сценариях.

• На рамке окна оно отображается слева от названия окна в строке заголовка.

• В проводнике Windows, на рабочем столе, в моем компьютере или в окне панели управления.

На рамке окна оно отображается слева от названия окна в строке заголовка.

В проводнике Windows, на рабочем столе, в моем компьютере или в окне панели управления.

Если вы посмотрите на наш пример MFCModalDemo, вы увидите, что Visual Studio использовала значок по умолчанию для строки заголовка, как показано на следующем снимке.

Вы можете создать свой собственный значок, следуя инструкциям ниже:

Шаг 1 — Щелкните правой кнопкой мыши по своему проекту и выберите «Добавить» → «Ресурсы», откроется диалоговое окно «Добавить ресурсы».

Шаг 2 — Выберите Icon и нажмите кнопку New, и вы увидите следующий значок.

Шаг 3 — В Solution Explorer перейдите в Resource View и разверните MFCModalDemo> Icon. Вы увидите две иконки. IDR_MAINFRAME является значением по умолчанию, а IDI_ICON1 является вновь созданным значком.

Шаг 4 — Щелкните правой кнопкой мыши по вновь созданному значку и выберите Свойства.

Шаг 5 — IDI_ICON1 является идентификатором этого значка, теперь давайте изменим этот идентификатор на IDR_MYICON.

Шаг 6 — Теперь вы можете изменить этот значок в конструкторе в соответствии с вашими требованиями. Мы будем использовать тот же значок.

Шаг 7 — Сохраните этот значок.

Шаг 8 — Перейдите к конструктору CMFCModalDemoDlg в файле CMFCModalDemoDlg.cpp, который будет выглядеть как следующий код.

CMFCModalDemoDlg::CMFCModalDemoDlg(CWnd* pParent /* = NULL*/)
   : CDialogEx(IDD_MFCMODALDEMO_DIALOG, pParent) {
   m_hIcon = AfxGetApp() -> LoadIcon(IDR_MAINFRAME);
}

Шаг 9 — Теперь вы можете видеть, что значок по умолчанию загружен в конструктор. Давайте изменим его на IDR_ MYICON, как показано в следующем коде.

CMFCModalDemoDlg::CMFCModalDemoDlg(CWnd* pParent /* = NULL*/)
   : CDialogEx(IDD_MFCMODALDEMO_DIALOG, pParent) {
   m_hIcon = AfxGetApp() -> LoadIcon(IDR_ MYICON);
}

Шаг 10 — Когда приведенный выше код скомпилирован и выполнен, вы увидите, что новый значок отображается в диалоговом окне.

меню

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

Шаг 1 — Щелкните правой кнопкой мыши по вашему проекту и выберите «Добавить» → «Ресурсы». Вы увидите диалоговое окно Add Resources.

Шаг 2 — Выберите Меню и нажмите Новый. Вы увидите прямоугольник с надписью «Введите здесь» в строке меню.

Шаг 3 — Напишите некоторые пункты меню, такие как «Файл», «Редактировать» и т. Д., Как показано на следующем снимке.

Шаг 4 — Если вы развернете папку «Меню» в представлении ресурсов, вы увидите идентификатор меню IDR_MENU1. Щелкните правой кнопкой мыши по этому идентификатору и измените его на IDM_MAINMENU.

Шаг 5 — Сохраните все изменения.

Шаг 6 — Нам нужно прикрепить это меню к нашему диалоговому окну. Разверните папку Dialog в обозревателе решений и дважды щелкните идентификатор диалогового окна.

Шаг 7 — Вы увидите поле меню в Свойствах. Выберите идентификатор меню из выпадающего списка, как показано выше.

Шаг 8 — Запустите это приложение, и вы увидите следующее диалоговое окно, которое также содержит пункты меню.

Панели инструментов

Панель инструментов — это элемент управления Windows, который позволяет пользователю выполнять некоторые действия с формой, нажимая кнопку вместо использования меню.

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

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

• Панели инструментов обычно отображаются под главным меню.

• Они могут быть оснащены кнопками, но иногда их кнопки или некоторые кнопки имеют подпись.

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

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

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

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

Они могут быть оснащены кнопками, но иногда их кнопки или некоторые кнопки имеют подпись.

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

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

Шаг 1 — Щелкните правой кнопкой мыши по вашему проекту и выберите «Добавить» → «Ресурсы». Вы увидите диалоговое окно Add Resources.

Шаг 2 — Выберите Панель инструментов и нажмите Новый. Вы увидите следующий экран.

Шаг 3. Создайте панель инструментов в конструкторе, как показано на следующем снимке экрана, а также укажите идентификаторы.

Шаг 4 — Добавьте эти две переменные в класс CMFCModalDemoDlg.

   CToolBar m_wndToolBar;
   BOOL butD;

Шаг 5 — Ниже приведена полная реализация CMFCModalDemoDlg в файле CMFCModalDemoDlg.h —

class CMFCModalDemoDlg : public CDialogEx {
   // Construction
   public:
      CMFCModalDemoDlg(CWnd* pParent = NULL); // standard constructor
   // Dialog Data
   #ifdef AFX_DESIGN_TIME
      enum { IDD = IDD_MFCMODALDEMO_DIALOG };
   #endif

   protected:
      virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support
   
   // Implementation
   protected:
      HICON m_hIcon;
      CToolBar m_wndToolBar;
      BOOL butD;
   
      // Generated message map functions
      virtual BOOL OnInitDialog();
      afx_msg void OnPaint();
      afx_msg HCURSOR OnQueryDragIcon();
      DECLARE_MESSAGE_MAP()
	
   public:
      afx_msg void OnBnClickedOk();
};

Шаг 6 — Обновите CMFCModalDemoDlg :: OnInitDialog (), как показано в следующем коде.

BOOL CMFCModalDemoDlg::OnInitDialog() {
   CDialogEx::OnInitDialog();
   
   // Set the icon for this dialog. The framework does this automatically
   // when the application's main window is not a dialog
   SetIcon(m_hIcon, TRUE);       // Set big icon
   SetIcon(m_hIcon, FALSE);      // Set small icon
   
   if (!m_wndToolBar.Create(this)
      || !m_wndToolBar.LoadToolBar(IDR_TOOLBAR1))
      //if (!m_wndToolBar.CreateEx(this, TBSTYLE_FLAT, WS_CHILD |
      // WS_VISIBLE | CBRS_TOP | CBRS_GRIPPER | CBRS_TOOLTIPS |
      // CBRS_FLYBY | CBRS_SIZE_DYNAMIC) ||
      // !m_wndToolBar.LoadToolBar(IDR_TOOLBAR1)) {
         TRACE0("Failed to Create Dialog Toolbar\n");
         EndDialog(IDCANCEL);
      }
      butD = TRUE;
      CRect rcClientOld; // Old Client Rect
      CRect rcClientNew; // New Client Rect with Tollbar Added
		
      // Retrive the Old Client WindowSize
      // Called to reposition and resize control bars in the client area of a window
      // The reposQuery FLAG does not really traw the Toolbar. It only does the calculations.
      // And puts the new ClientRect values in rcClientNew so we can do the rest of the Math.
      
      GetClientRect(rcClientOld);
      RepositionBars(AFX_IDW_CONTROLBAR_FIRST, AFX_IDW_CONTROLBAR_LAST, 0, reposQuery, rcClientNew);
      // All of the Child Windows (Controls) now need to be moved so the Tollbar does not cover them up.
      // Offest to move all child controls after adding Tollbar 
      CPoint ptOffset(rcClientNew.left - rcClientOld.left, rcClientNew.top - rcClientOld.top); 
		 
      CRect rcChild;
      CWnd* pwndChild = GetWindow(GW_CHILD); //Handle to the Dialog Controls
      
      while (pwndChild) // Cycle through all child controls {
         pwndChild -> GetWindowRect(rcChild); // Get the child control RECT
         ScreenToClient(rcChild);
          
         // Changes the Child Rect by the values of the claculated offset
         rcChild.OffsetRect(ptOffset);
         pwndChild -> MoveWindow(rcChild, FALSE); // Move the Child Control
         pwndChild = pwndChild -> GetNextWindow();
      }
       
      CRect rcWindow;
      // Get the RECT of the Dialog
      GetWindowRect(rcWindow);
       
      // Increase width to new Client Width
      rcWindow.right += rcClientOld.Width() - rcClientNew.Width();
       
      // Increase height to new Client Height
       rcWindow.bottom += rcClientOld.Height() - rcClientNew.Height();
      // Redraw Window
      MoveWindow(rcWindow, FALSE);
       
      // Now we REALLY Redraw the Toolbar
      RepositionBars(AFX_IDW_CONTROLBAR_FIRST, AFX_IDW_CONTROLBAR_LAST, 0);
       
   // TODO: Add extra initialization here

   return TRUE; // return TRUE unless you set the focus to a control
}

Шаг 7 — Запустите это приложение. Вы увидите следующее диалоговое окно, которое также содержит панель инструментов.

Ускорители

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

Шаг 1 — Чтобы создать ключ доступа, введите амперсанд «&» слева от пункта меню.

Шаг 2 — Повторите этот шаг для всех пунктов меню. Запустите это приложение и нажмите Alt. Вы увидите, что первая буква всех пунктов меню подчеркнута.

Быстрая клавиша

Сочетание клавиш — это клавиша или комбинация клавиш, используемая опытными пользователями для выполнения действия, которое в противном случае было бы выполнено для элемента меню. Большинство сочетаний клавиш представляют собой комбинацию клавиши Ctrl, одновременно нажатой с помощью буквенной клавиши. Например, Ctrl + N, Ctrl + O или Ctrl + D.

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

В поле «Заголовок» введите \ t, а затем нужную комбинацию, как показано ниже для параметра «Новое меню». Повторите этот шаг для всех пунктов меню.

Ускоритель

Таблица ускорителей — это список элементов, в котором каждый элемент таблицы объединяет идентификатор, сочетание клавиш и постоянное число, которое определяет тип клавиши ускорения. Как и другие ресурсы, таблицу ускорений можно создать вручную в файле .rc. Ниже приведены шаги для создания таблицы акселератора.

Шаг 1 — Чтобы создать таблицу ускорений, щелкните правой кнопкой мыши файл * .rc в обозревателе решений.

Шаг 2 — Выберите ускоритель и нажмите «Создать».

Шаг 3 — Нажмите на стрелку поля со списком ID и выберите пункт меню.

Шаг 4 — Выберите Ctrl из выпадающего списка Модификатор.

Шаг 5 — Щелкните поле «Ключ» и введите соответствующие ключи для обоих пунктов меню.

Мы также добавим новый обработчик события пункта меню в тестирование. Щелкните правой кнопкой мыши пункт «Новое меню».

Шаг 6 — Вы можете указать класс, тип сообщения и имя обработчика. А пока оставим все как есть и нажмите кнопку «Добавить и изменить».

Шаг 7 — Выберите Добавить обработчик событий.

Шаг 8 — Теперь вы увидите событие, добавленное в конец файла CMFCModalDemoDlg.cpp.

void CMFCModalDemoDlg::OnFileNew() {
   // TODO: Add your command handler code here
   MessageBox(L"File > New menu option");
}

Шаг 9 — Теперь давайте добавим окно сообщения, которое будет отображать простую опцию меню сообщения.

Для запуска таблицы акселератора в рабочем режиме добавьте переменную HACCEL и ProcessMessageFilter, как показано в следующем CMFCModalDemoApp.

class CMFCModalDemoApp : public CWinApp {
   public:
      CMFCModalDemoApp();
   
   // Overrides
   public:
      virtual BOOL InitInstance();
      HACCEL m_hAccelTable;
      
      // Implementation

      DECLARE_MESSAGE_MAP()
      virtual BOOL ProcessMessageFilter(int code, LPMSG lpMsg);
};

Шаг 10 — Загрузите ускоритель и следующий вызов в CMFCModalDemoApp :: InitInstance ().

m_hAccelTable = LoadAccelerators(AfxGetInstanceHandle(),
   MAKEINTRESOURCE(IDR_ACCELERATOR1));

Шаг 11 — Вот реализация ProcessMessageFilter.

BOOL CMFCModalDemoApp::ProcessMessageFilter(int code, LPMSG lpMsg) {
   if (code >= 0 && m_pMainWnd && m_hAccelTable) {
      if (::TranslateAccelerator(m_pMainWnd -> m_hWnd, m_hAccelTable, lpMsg))
      return TRUE;
   }
   return CWinApp::ProcessMessageFilter(code, lpMsg);
}

Шаг 12 — Когда приведенный выше код скомпилирован и выполнен, вы увидите следующий вывод.

Шаг 13 — Нажмите кнопку Alt, затем клавишу F, а затем клавишу N или Ctrl + N. Вы увидите следующее сообщение.

MFC — листы недвижимости

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

Чтобы создать страницы свойств, давайте рассмотрим простой пример создания диалогового проекта MFC.

Как только проект создан, нам нужно добавить несколько страниц свойств.

Visual Studio позволяет легко создавать ресурсы для страниц свойств, отображая диалоговое окно «Добавить ресурс», раскрывая узел «Диалог» и выбирая один из элементов IDD_PROPPAGE_X.

Шаг 1 — Щелкните правой кнопкой мыши свой проект в обозревателе решений и выберите «Добавить» → «Ресурсы».

Шаг 2 — Выберите IDD_PROPPAGE_LARGE и нажмите NEW.

Шаг 3 — Давайте изменим ID и заголовок этой страницы свойств на IDD_PROPPAGE_1 и Страница свойств соответственно, как показано выше.

Шаг 4 — Щелкните правой кнопкой мыши на странице свойств в окне дизайнера.

Шаг 5 — Выберите опцию Добавить класс.

Шаг 6 — Введите имя класса и выберите CPropertyPage из выпадающего списка базового класса.

Шаг 7 — Нажмите Готово, чтобы продолжить.

Шаг 8 — Добавьте еще одну страницу свойств с идентификатором IDD_PROPPAGE_2 и Caption Property Page 2, выполнив вышеупомянутые шаги.

Шаг 9 — Теперь вы можете увидеть две страницы свойств. Для реализации его функциональности нам нужен лист свойств.

Лист свойств группирует страницы свойств и сохраняет их как сущность.

Чтобы создать лист свойств, выполните следующие действия:

Шаг 1 — Щелкните правой кнопкой мыши по вашему проекту и выберите «Добавить»> «Параметры меню класса».

Шаг 2. Выберите Visual C ++ → MFC на левой панели и класс MFC на панели шаблонов и нажмите кнопку Добавить.

Шаг 3 — Введите имя класса и выберите CPropertySheet из выпадающего списка базового класса.

Шаг 4 — Нажмите «Готово», чтобы продолжить.

Шаг 5 — Чтобы запустить этот лист свойств, нам нужны следующие изменения в нашем основном классе проекта.

Шаг 6 — Добавьте следующие ссылки в файл CMFCPropSheetDemo.cpp.

#include "MySheet.h"
#include "PropPage1.h"
#include "PropPage2.h"

Шаг 7. Измените метод CMFCPropSheetDemoApp :: InitInstance (), как показано в следующем коде.

CMySheet mySheet(L"Property Sheet Demo");
CPropPage1 page1;
CPropPage2 page2;

mySheet.AddPage(&page1);
mySheet.AddPage(&page2);

m_pMainWnd = &mySheet;
INT_PTR nResponse = mySheet.DoModal();

Шаг 8 — Вот полная реализация файла CMFCPropSheetDemo.cpp.

// MFCPropSheetDemo.cpp : Defines the class behaviors for the application.
//
#include "stdafx.h"
#include "MFCPropSheetDemo.h"
#include "MFCPropSheetDemoDlg.h"
#include "MySheet.h"
#include "PropPage1.h"
#include "PropPage2.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif


// CMFCPropSheetDemoApp
BEGIN_MESSAGE_MAP(CMFCPropSheetDemoApp, CWinApp)
   ON_COMMAND(ID_HELP, &CWinApp::OnHelp)
END_MESSAGE_MAP()


// CMFCPropSheetDemoApp construction

CMFCPropSheetDemoApp::CMFCPropSheetDemoApp() {

   // support Restart Manager
   m_dwRestartManagerSupportFlags = AFX_RESTART_MANAGER_SUPPORT_RESTART;
   // TODO: add construction code here,
   // Place all significant initialization in InitInstance
}


// The one and only CMFCPropSheetDemoApp object

CMFCPropSheetDemoApp theApp;


// CMFCPropSheetDemoApp initialization

BOOL CMFCPropSheetDemoApp::InitInstance() {
   
   // InitCommonControlsEx() is required on Windows XP if an application
   // manifest specifies use of ComCtl32.dll version 6 or later to enable
   // visual styles. Otherwise, any window creation will fail.
   INITCOMMONCONTROLSEX InitCtrls;
   InitCtrls.dwSize = sizeof(InitCtrls);
   // Set this to include all the common control classes you want to use
   // in your application.
   InitCtrls.dwICC = ICC_WIN95_CLASSES;
   InitCommonControlsEx(&InitCtrls);
   
   CWinApp::InitInstance();
   
   
   AfxEnableControlContainer();
   
   // Create the shell manager, in case the dialog contains
   // any shell tree view or shell list view controls.
   CShellManager *pShellManager = new CShellManager;

   // Activate "Windows Native" visual manager for enabling themes in MFC controls
   CMFCVisualManager::SetDefaultManager(RUNTIME_CLASS(CMFCVisualManagerWindows));
   // Standard initialization
   // If you are not using these features and wish to reduce the size
   // of your final executable, you should remove from the following
   // the specific initialization routines you do not need
   // Change the registry key under which our settings are stored
   // TODO: You should modify this string to be something appropriate
   // such as the name of your company or organization
   SetRegistryKey(_T("Local AppWizard-Generated Applications"));
   
   CMySheet mySheet(L"Property Sheet Demo");
   CPropPage1 page1;
   CPropPage2 page2;
   
   mySheet.AddPage(&page1);
   mySheet.AddPage(&page2);
   
   m_pMainWnd = &mySheet;
   INT_PTR nResponse = mySheet.DoModal();
   if (nResponse == IDOK) {
      // TODO: Place code here to handle when the dialog is
      // dismissed with OK
   }else if (nResponse == IDCANCEL) {
      // TODO: Place code here to handle when the dialog is
      // dismissed with Cancel
   }else if (nResponse == -1) {    
      TRACE(traceAppMsg, 0, "Warning: dialog creation failed, 
        so application is terminating unexpectedly.\n");
      TRACE(traceAppMsg, 0, "Warning: if you are using MFC controls on the dialog, 
        you cannot #define _AFX_NO_MFC_CONTROLS_IN_DIALOGS.\n");
   }

   // Delete the shell manager created above.
   if (pShellManager != NULL) {
      delete pShellManager;
   }

   // Since the dialog has been closed, return FALSE so that we exit the
   // application, rather than start the application's message pump.
   return FALSE;
}

Шаг 9 — Когда приведенный выше код скомпилирован и выполнен, вы увидите следующее диалоговое окно. Это диалоговое окно содержит две страницы свойств.

MFC — Windows Layout

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

• Позиции дочерних элементов.
• Размеры дочерних элементов.

Добавление элементов управления

Давайте создадим новый основанный на диалоге проект MFC MFCLayoutDemo.

Шаг 1 — После того, как проект создан, вы увидите следующий экран.

Шаг 2 — Удалить TODO из диалогового окна.

Шаг 3 — Перетащите некоторые элементы управления из панели инструментов, которые вы видите на левой стороне.

(Мы перетащим один статический текст и один элемент управления редактированием, как показано на следующем снимке).

Шаг 4 — Измените заголовок статического текста на имя.

Контрольная Сетка

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

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

Управление изменением размера

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

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

Теперь вы можете изменить размеры элементов управления с помощью этой пунктирной сетки.

Позиции управления

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

Давайте добавим еще несколько элементов управления —

Шаг 1 — Чтобы переместить элемент управления, щелкните и перетащите его в нужном направлении, пока он не достигнет предполагаемого положения.

Шаг 2 — Чтобы переместить группу элементов управления, сначала выберите их. Затем перетащите выделенную область в нужное место. Давайте выберем статические тексты и элементы управления редактирования.

Шаг 3 — Переместите эти выбранные элементы управления в левую сторону.

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

Шаг 1 — Давайте выровняем элементы управления Check box и Static Text по левому краю, выбрав все эти элементы управления.

Шаг 2 — Выберите Формат → Выровнять → Левые.

Шаг 3 — Теперь вы можете видеть, что все эти элементы управления выровнены влево.

Tab Tabing

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

Чтобы изменить вкладку, вы можете использовать опцию меню «Формат → Порядок вкладок» или комбинацию клавиш Ctrl + D. Давайте нажмем Ctrl + D.

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

В этом примере мы сначала установим флажок, а затем элементы управления Редактирование имени и адреса. Затем нажмите OK и Отмена, как показано на следующем снимке.

Давайте запустим это приложение, и вы увидите следующий вывод.

МФЦ — Управление Контролями

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

• Одна переменная используется для информации, хранящейся в элементе управления, который также известен как переменная / экземпляр элемента управления .

• Другая переменная известна как переменная контрольного значения . Пользователь может выполнять какие-либо действия над этим элементом управления с этой переменной.

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

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

Переменная управления / Экземпляр

Управляющая переменная — это переменная, основанная на классе, который управляет элементом управления. Например, управление кнопками основано на классе CButton.

Чтобы увидеть эти концепции в реальном программировании, давайте создадим проект MFCControlManagement на основе диалога MFC.

После создания проекта вы увидите следующее диалоговое окно в окне дизайнера.

Шаг 1 — Удалите строку TODO и перетащите один флажок и один элемент управления Edit, как показано на следующем снимке. Измените заголовок флажка на Включить контроль.

Шаг 2 — Щелкните правой кнопкой мыши по флажку.

Шаг 3 — Выберите Добавить переменную.

Шаг 4 — Теперь вы можете увидеть мастер добавления переменных участников.

Вы можете выбрать различные параметры в этом диалоговом окне. Для флажка тип переменной — CButton. Он выбран по умолчанию в этом диалоговом окне.

Аналогично, идентификатор элемента управления также выбран по умолчанию, теперь нам нужно выбрать элемент управления в поле со списком «Категория» и ввести m_enableDisableCheck в поле редактирования «Имя переменной» и нажать «Готово».

Шаг 5. Аналогичным образом добавьте переменную элемента управления «Изменить» с настройками, как показано на следующем снимке.

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

CButton m_enableDisableCheck;
CEdit m_myEditControl;

Переменная контрольного значения

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

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

• Например, поскольку для обработки текста используется текстовый элемент управления, вы можете объявить для него текстовый тип данных. Обычно это переменная CString.

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

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

Давайте посмотрим на этот тип переменной для флажка и редактирования управления.

Шаг 1 — Щелкните правой кнопкой мыши по флажку и выберите Добавить переменную.

Шаг 2 — тип переменной BOOL. Выберите Value из выпадающего списка Category.

Шаг 3 — Нажмите Готово, чтобы продолжить.

Шаг 4. Аналогичным образом добавьте значение Variable для элемента управления Edit с настройками, как показано на следующем снимке.

Шаг 5 — Введите CString в типе переменной и m_editControlVal в поле имени переменной.

Шаг 6 — Теперь вы можете увидеть эти переменные, добавленные в заголовочный файл.

bool m_enableDisableVal;
CString m_editControlVal;

Управляет обработчиками событий

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

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

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

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

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

Давайте посмотрим на тот же пример, в котором мы добавили обработчик событий для флажка.

Шаг 1 — Щелкните правой кнопкой мыши элемент управления, для которого вы хотите обработать событие уведомления.

Шаг 2 — В контекстном меню выберите Добавить обработчик событий, чтобы открыть мастер обработки событий.

Шаг 3 — Выберите событие в поле Тип сообщения, чтобы добавить его к классу, выбранному в поле Список классов.

Шаг 4 — Примите имя по умолчанию в поле Имя обработчика функций или укажите имя по вашему выбору.

Шаг 5 — Нажмите Добавить и изменить, чтобы добавить обработчик событий.

Шаг 6 — Теперь вы можете увидеть следующее событие, добавленное в конец файла CMFCControlManagementDlg.cpp.

void CMFCControlManagementDlg::OnBnClickedCheck1() {
   // TODO: Add your control notification handler code here
}

Управление управления

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

Шаг 1 — Давайте посмотрим на следующий пример. Здесь мы включим / отключим контроль редактирования, когда флажок установлен / снят.

Шаг 2 — Мы добавили обработчик события щелчка флажка. Вот реализация —

void CMFCControlManagementDlg::OnBnClickedCheck1() {
   // TODO: Add your control notification handler code here
   UpdateData(TRUE);
   if (m_enableDisableVal)
      m_myEditControl.EnableWindow(TRUE);
   else
      m_myEditControl.EnableWindow(FALSE);
}

Шаг 3 — Когда диалоговое окно создано, нам нужно добавить следующий код в CMFCControlManagementDlg :: OnInitDialog (). Это будет управлять этими элементами управления.

UpdateData(TRUE);
if (m_enableDisableVal)
   m_myEditControl.EnableWindow(TRUE);
else
   m_myEditControl.EnableWindow(FALSE);

Шаг 4 — Вот полная реализация файла CMFCControlManagementDlg.cpp.

// MFCControlManagementDlg.cpp : implementation file
//

#include "stdafx.h"
#include "MFCControlManagement.h"
#include "MFCControlManagementDlg.h"
#include "afxdialogex.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif


// CAboutDlg dialog used for App About

class CAboutDlg : public CDialogEx {
   public:
      CAboutDlg();
	
   // Dialog Data
   #ifdef AFX_DESIGN_TIME
      enum { IDD = IDD_ABOUTBOX };
   #endif

   protected:
      virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support
      
   // Implementation
   protected:
      DECLARE_MESSAGE_MAP()
};

CAboutDlg::CAboutDlg() : CDialogEx(IDD_ABOUTBOX) {

}
void CAboutDlg::DoDataExchange(CDataExchange* pDX) {
   CDialogEx::DoDataExchange(pDX);
}

BEGIN_MESSAGE_MAP(CAboutDlg, CDialogEx)
END_MESSAGE_MAP()

// CMFCControlManagementDlg dialog


CMFCControlManagementDlg::CMFCControlManagementDlg(CWnd* pParent /* = NULL*/)
   :CDialogEx(IDD_MFCCONTROLMANAGEMENT_DIALOG, pParent) , 
   m_enableDisableVal(FALSE) , m_editControlVal(_T("")) {
   m_hIcon = AfxGetApp()&rarr LoadIcon(IDR_MAINFRAME);
}

void CMFCControlManagementDlg::DoDataExchange(CDataExchange* pDX) {
   CDialogEx::DoDataExchange(pDX);
   DDX_Control(pDX, IDC_CHECK1, m_enableDisableCheck);
   DDX_Control(pDX, IDC_EDIT1, m_myEditControl);
   DDX_Check(pDX, IDC_CHECK1, m_enableDisableVal);
   DDX_Text(pDX, IDC_EDIT1, m_editControlVal);
}
BEGIN_MESSAGE_MAP(CMFCControlManagementDlg, CDialogEx)
   ON_WM_SYSCOMMAND()
   ON_WM_PAINT()
   ON_WM_QUERYDRAGICON()
   ON_BN_CLICKED(IDC_CHECK1, &CMFCControlManagementDlg::OnBnClickedCheck1)
END_MESSAGE_MAP()

// CMFCControlManagementDlg message handlers

BOOL CMFCControlManagementDlg::OnInitDialog() {
   CDialogEx::OnInitDialog();
      
   // Add "About..." menu item to system menu.
   // IDM_ABOUTBOX must be in the system command range.
   ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
   ASSERT(IDM_ABOUTBOX < 0xF000);
      
   CMenu* pSysMenu = GetSystemMenu(FALSE);
   if (pSysMenu != NULL) {
      BOOL bNameValid;
      CString strAboutMenu;
      bNameValid = strAboutMenu.LoadString(IDS_ABOUTBOX);
      ASSERT(bNameValid);
      if (!strAboutMenu.IsEmpty()) {
         pSysMenu → AppendMenu(MF_SEPARATOR);
         pSysMenu → AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
      }
   }
	
   // Set the icon for this dialog. The framework does this automatically
   // when the application's main window is not a dialog
   SetIcon(m_hIcon, TRUE);        // Set big icon
   SetIcon(m_hIcon, FALSE);       // Set small icon

   // TODO: Add extra initialization here
   UpdateData(TRUE);
   if (m_enableDisableVal)
      m_myEditControl.EnableWindow(TRUE);
   else
      m_myEditControl.EnableWindow(FALSE);
   return TRUE; // return TRUE unless you set the focus to a control
}
void CMFCControlManagementDlg::OnSysCommand(UINT nID, LPARAM lParam) {
   if ((nID & 0xFFF0) == IDM_ABOUTBOX) {
      CAboutDlg dlgAbout;
      dlgAbout.DoModal();
   }else {
      CDialogEx::OnSysCommand(nID, lParam);
   }
}

// If you add a minimize button to your dialog, you will need the code below
// to draw the icon. For MFC applications using the document/view model,
// this is automatically done for you by the framework.

void CMFCControlManagementDlg::OnPaint() {
   if (IsIconic()) {
      CPaintDC dc(this); // device context for painting
      
      SendMessage(WM_ICONERASEBKGND,
         reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0);
			
      // Center icon in client rectangle
      int cxIcon = GetSystemMetrics(SM_CXICON);
      int cyIcon = GetSystemMetrics(SM_CYICON);
      CRect rect;
      GetClientRect(&rect);
      int x = (rect.Width() - cxIcon + 1) / 2;
      int y = (rect.Height() - cyIcon + 1) / 2;
		
      // Draw the icon
      dc.DrawIcon(x, y, m_hIcon);
   }else {
      CDialogEx::OnPaint();
   }
}

// The system calls this function to obtain the cursor to display while the user drags
// the minimized window.
HCURSOR CMFCControlManagementDlg::OnQueryDragIcon() {
   return static_cast<HCURSOR>(m_hIcon);
}

void CMFCControlManagementDlg::OnBnClickedCheck1() {
   // TODO: Add your control notification handler code here
   UpdateData(TRUE);
   if (m_enableDisableVal)
      m_myEditControl.EnableWindow(TRUE);
   else
      m_myEditControl.EnableWindow(FALSE);
}

Шаг 5 — Когда приведенный выше код скомпилирован и выполнен, вы увидите следующий вывод. По умолчанию флажок снят. Это также отключает контроль редактирования.

Шаг 6 — Установите флажок Включить контроль. Это автоматически активирует контроль редактирования.

MFC — Windows Control

Элементы управления Windows — это объекты, с которыми пользователи могут взаимодействовать для ввода или манипулирования данными. Они обычно появляются в диалоговых окнах или на панелях инструментов. Существуют различные типы элементов управления —

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

• Элемент управления на основе списка отображает список элементов.

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

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

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

Элемент управления на основе списка отображает список элементов.

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

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

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

Элемент управления анимацией — это окно, в котором отображается аудиоклип в формате AVI. AVI-клип — это серия растровых кадров, как в фильме. Элементы управления анимацией могут воспроизводить только простые AVI-клипы, и они не поддерживают звук. Он представлен классом CAnimateCtrl .

Кнопка — это объект, который пользователь щелкает, чтобы инициировать действие. Кнопочное управление представлено классом CButton .

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

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

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

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

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

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

Флажок — это элемент управления Windows, который позволяет пользователю устанавливать или изменять значение элемента как true или false.

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

Поле редактирования — это прямоугольное дочернее окно, в которое пользователь может вводить текст. Он представлен классом CEdit .

Rich Edit Control — это окно, в которое пользователь может вводить и редактировать текст. Тексту может быть назначено форматирование символов и абзацев, и он может включать встроенные объекты OLE. Он представлен классом CRichEditCtrl .

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

Элемент управления Spin Button (также известный как элемент управления «вверх-вниз») представляет собой пару кнопок со стрелками, которые пользователь может нажимать для увеличения или уменьшения значения, например положения прокрутки или числа, отображаемого в сопутствующем элементе управления. он представлен классом CSpinButtonCtrl .

Он управляет средствами управления обновлением.

Элемент управления индикатора выполнения — это окно, которое приложение может использовать для индикации хода выполнения длительной операции. Он состоит из прямоугольника, который постепенно заполняется слева направо цветом системы при выполнении операции. Он представлен классом CProgressCtrl .

Индикаторы выполнения — это окно, которое приложение может использовать для индикации хода выполнения операции.

Таймер — это непространственный объект, который использует повторяющиеся промежутки времени с компьютера или из вашего приложения. Чтобы работать, каждый промежуток времени, элемент управления отправляет сообщение операционной системе. В отличие от большинства других элементов управления, таймер MFC не имеет ни кнопки для его представления, ни класса. Чтобы создать таймер, вы просто вызываете метод CWnd :: SetTimer (). Этот вызов функции создает таймер для вашего приложения. Как и другие элементы управления, таймер использует идентификатор.

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

Если вам нужно отобразить изображение для вашего приложения, Visual C ++ предоставляет специальный элемент управления для этой цели.

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

Ползунок управления (также известный как трекбар) представляет собой окно, содержащее ползунок и дополнительные отметки. Когда пользователь перемещает ползунок с помощью мыши или клавиш со стрелками, элемент управления отправляет уведомления с уведомлением об изменении. Есть два типа слайдеров — горизонтальные и вертикальные. Он представлен классом CSliderCtrl .

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

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

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

MFC — Сообщения и События

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

обзор

• Операционная система Microsoft Windows не может предсказать, о каких типах запросов нужно было бы позаботиться одному объекту, и о каком типе назначения понадобился бы другой объект.

• Чтобы управлять всеми этими назначениями и запросами, объекты отправляют сообщения.

• Каждый объект несет ответственность за решение, какое сообщение отправлять и когда.

• Чтобы отправить сообщение, элемент управления должен создать событие.

• Чтобы провести различие между ними, имя сообщения обычно начинается с WM_, что означает Window Message.

• Название события обычно начинается с Вкл., Что указывает на действие.

• Событие — это действие отправки сообщения.

Операционная система Microsoft Windows не может предсказать, о каких типах запросов нужно было бы позаботиться одному объекту, и о каком типе назначения понадобился бы другой объект.

Чтобы управлять всеми этими назначениями и запросами, объекты отправляют сообщения.

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

Чтобы отправить сообщение, элемент управления должен создать событие.

Чтобы провести различие между ними, имя сообщения обычно начинается с WM_, что означает Window Message.

Название события обычно начинается с Вкл., Что указывает на действие.

Событие — это действие отправки сообщения.

Карта сообщений

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

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

• Макрос DECLARE_MESSAGE_MAP должен предоставляться в конце определения класса, как показано в следующем коде.

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

Макрос DECLARE_MESSAGE_MAP должен предоставляться в конце определения класса, как показано в следующем коде.

class CMainFrame : public CFrameWnd {
   public:
      CMainFrame();
   protected:
      DECLARE_MESSAGE_MAP()
};

• Фактические сообщения должны быть перечислены чуть выше строки DECLARE_MESSAGE_MAP.

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

• В этой таблице используются два макроса-разделителя;

• Он начинается с BEGIN_MESSAGE_MAP и заканчивается макросами END_MESSAGE_MAP .

• Макрос BEGIN_MESSAGE_MAP принимает два аргумента: имя вашего класса и класс MFC, из которого вы вывели свой класс, как показано в следующем коде.

Фактические сообщения должны быть перечислены чуть выше строки DECLARE_MESSAGE_MAP.

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

В этой таблице используются два макроса-разделителя;

Он начинается с BEGIN_MESSAGE_MAP и заканчивается макросами END_MESSAGE_MAP .

Макрос BEGIN_MESSAGE_MAP принимает два аргумента: имя вашего класса и класс MFC, из которого вы вывели свой класс, как показано в следующем коде.

#include <afxwin.h>
class CMainFrame : public CFrameWnd {
   public:
      CMainFrame();
   protected:
      DECLARE_MESSAGE_MAP()
};
CMainFrame::CMainFrame() {

   // Create the window's frame
   Create(NULL, L"MFC Messages Demo", WS_OVERLAPPEDWINDOW,
                                      CRect(120, 100, 700, 480), NULL);
}
class CMessagesApp : public CWinApp {
   public:
      BOOL InitInstance();
};
BEGIN_MESSAGE_MAP(CMainFrame, CFrameWnd)
END_MESSAGE_MAP()
BOOL CMessagesApp::InitInstance(){
   m_pMainWnd = new CMainFrame;
   m_pMainWnd->ShowWindow(SW_SHOW);
   m_pMainWnd->UpdateWindow();
   return TRUE;
}
CMessagesApp theApp;

Давайте рассмотрим простой пример, создав новый проект Win32.

Шаг 1 — Чтобы создать проект MFC, щелкните проект правой кнопкой мыши и выберите «Свойства».

Шаг 2 — В левом разделе нажмите Свойства конфигурации → Общие.

Шаг 3 — Выберите «Использовать MFC в Shared DLL» в разделе «Настройки проекта по умолчанию» и нажмите «ОК».

Шаг 4 — Нам нужно добавить новый исходный файл.

Шаг 5 — Щелкните правой кнопкой мыши по вашему проекту и выберите «Добавить» → «Новый элемент».

Шаг 6 — В разделе Шаблоны выберите Файл C ++ (.cpp).

Шаг 7 — Нажмите Добавить, чтобы продолжить.

Шаг 8 — Теперь добавьте следующий код в файл * .cpp.

#include <afxwin.h>
class CMainFrame : public CFrameWnd {
   public:
      CMainFrame();
   protected:
      DECLARE_MESSAGE_MAP()
};

CMainFrame::CMainFrame() {
   // Create the window's frame
   Create(NULL, L"MFC Messages Demo", WS_OVERLAPPEDWINDOW,
      CRect(120, 100, 700, 480), NULL);
}

class CMessagesApp : public CWinApp {
   public:
      BOOL InitInstance();
};

BEGIN_MESSAGE_MAP(CMainFrame, CFrameWnd)
END_MESSAGE_MAP()
BOOL CMessagesApp::InitInstance() {
   m_pMainWnd = new CMainFrame;
   m_pMainWnd->ShowWindow(SW_SHOW);
   m_pMainWnd->UpdateWindow();
   return TRUE;
}
CMessagesApp theApp;

Сообщения Windows

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

class CMainFrame : public CFrameWnd {
   public:
      CMainFrame();
   protected:
      afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
      DECLARE_MESSAGE_MAP()
};

BEGIN_MESSAGE_MAP(CMainFrame, CFrameWnd)
   ON_WM_CREATE()
END_MESSAGE_MAP()

int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct) {
   // Call the base class to create the window
   if (CFrameWnd::OnCreate(lpCreateStruct) == 0) {

      // If the window was successfully created, let the user know
      MessageBox(L"The window has been created!!!");
      // Since the window was successfully created, return 0
      return 0;
   }
   // Otherwise, return -1
   return -1;
}

#include <afxwin.h>
class CMainFrame : public CFrameWnd {
   public:
      CMainFrame();
   protected:
      afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
      DECLARE_MESSAGE_MAP()
};
CMainFrame::CMainFrame() {

   // Create the window's frame
   Create(NULL, L"MFC Messages Demo", WS_OVERLAPPEDWINDOW,
      CRect(120, 100, 700, 480), NULL);
}
class CMessagesApp : public CWinApp {
   public:
      BOOL InitInstance();
};
BEGIN_MESSAGE_MAP(CMainFrame, CFrameWnd)
   ON_WM_CREATE()
END_MESSAGE_MAP()
int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct) {
   // Call the base class to create the window
   if (CFrameWnd::OnCreate(lpCreateStruct) == 0) {
      // If the window was successfully created, let the user know
      MessageBox(L"The window has been created!!!");
      // Since the window was successfully created, return 0
      return 0;
   }
   // Otherwise, return -1
   return -1;
}
BOOL CMessagesApp::InitInstance() { 
   m_pMainWnd = new CMainFrame;
   m_pMainWnd -> ShowWindow(SW_SHOW);
   m_pMainWnd -> UpdateWindow();
   return TRUE;
}
CMessagesApp theApp;

afx_msg void OnFileNew();

BEGIN_MESSAGE_MAP(CMainFrame, CFrameWnd)
   ON_COMMAND(ID_FILE_NEW, CMainFrame::OnFileNew)
END_MESSAGE_MAP()

void CMainFrame::OnFileNew() {
   // Create New file
}

afx_msg void OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags);

BEGIN_MESSAGE_MAP(CMainFrame, CFrameWnd)
   ON_WM_CREATE()
   ON_WM_KEYDOWN()
END_MESSAGE_MAP()

void CMainFrame::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) {
   switch (nChar) {

      case VK_RETURN:
         MessageBox(L"You pressed Enter");
         break;
      case VK_F1:
         MessageBox(L"Help is not available at the moment");
         break;
      case VK_DELETE:
         MessageBox(L"Can't Delete This");
         break;
      default:
         MessageBox(L"Whatever");
   }
}

class CMainFrame : public CFrameWnd {
   public:
      CMainFrame();
   protected:
      afx_msg void OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags);
      afx_msg void OnLButtonDown(UINT nFlags, CPoint point);
      afx_msg void OnRButtonUp(UINT nFlags, CPoint point);
      DECLARE_MESSAGE_MAP()
};

BEGIN_MESSAGE_MAP(CMainFrame, CFrameWnd)
   ON_WM_KEYDOWN()
   ON_WM_LBUTTONDOWN()
   ON_WM_RBUTTONUP()
END_MESSAGE_MAP()

void CMainFrame::OnLButtonDown(UINT nFlags, CPoint point) { 
   CString MsgCoord;
   MsgCoord.Format(L"Left Button at P(%d, %d)", point.x, point.y);
   MessageBox(MsgCoord);
}
void CMainFrame::OnRButtonUp(UINT nFlags, CPoint point) { 
   MessageBox(L"Right Mouse Button Up");
}

m_progBarCtrl.SetScrollRange(0,100,TRUE);
m_progBarCtrl.put_Value(53);

void CMFCDirectoriesDemoDlg::OnBnClickedButtonCreate() {
   // TODO: Add your control notification handler code here
   SECURITY_ATTRIBUTES saPermissions;

   saPermissions.nLength = sizeof(SECURITY_ATTRIBUTES);
   saPermissions.lpSecurityDescriptor = NULL;
   saPermissions.bInheritHandle = TRUE;

   if (CreateDirectory(L"D:\\MFCDirectoryDEMO", &saPermissions) == TRUE)
      AfxMessageBox(L"The directory was created.");
   CreateDirectory(L"D:\\MFCDirectoryDEMO\\Dir1", NULL);
   CreateDirectory(L"D:\\MFCDirectoryDEMO\\Dir2", NULL);
}

void CMFCDirectoriesDemoDlg::OnBnClickedButtonDelete() {
   // TODO: Add your control notification handler code here
   if (RemoveDirectory(L"D:\\MFCDirectoryDEMO\\Dir1") == TRUE)
      AfxMessageBox(L"The directory has been deleted");
}

void CMFCDirectoriesDemoDlg::OnBnClickedButtonMove() {
   // TODO: Add your control notification handler code here
   CreateDirectory(L"D:\\MFCDirectory", NULL);

   if (MoveFile(L"D:\\MFCDirectoryDEMO\\Dir1", L"D:\\MFCDirectory\\Dir1") == TRUE)
      AfxMessageBox(L"The directory has been moved");
}