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

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

Сеть Internet

   В состав версии 4.2 включены абсолютно новые классы для работы с сетью Internet, основанные на программном интерфейсе Wininet . С их помощью вы легко сможете создавать клиентские приложения для работы с серверами WWW, FTP и Goufer.
   Microsoft Visual C++ версии 4.2 позволяет реализовать новую технологию ActiveX , предложенную Microsoft для использования в сети Internet. В MFC AppWizard добавлены средства, ускоряющие разработку органов управления ActiveX.

Базы данных

   Расширены возможности работы с базами данных. Внесены изменения и дополнения в классы, взаимодействующие с базами данных через ODBC, в том числе модифицированы классы CRecordset и CDatabase. Добавлены новые компоненты к Component Gallery, которые можно использовать для связи с базами данных.

Стандартная библиотека языка Си++

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

Win32s посвящается

   Microsoft Visual C++ версии 2.0 и все старшие версии этого продукта не позволяют разрабатывать 16-разрядные приложения для операционных систем Windows 3.xx.
   Начиная с версии 4.2, приложения, подготовленные в Microsoft Visual C++ и MFC 4.2, также не будут работать в среде Windows 3.хх с установленной поддержкой 32-разрядных приложений Win32s .
   Если вам все же необходимо создать приложение, способное работать в среде Win32s, следует воспользоваться более ранними версиями MFC, например MFC 4.1. К сожалению, в этом случае, последние новшества, введенные в библиотеку MFC 4.2, уже не будут вам доступны.

Microsoft Visual C++ версия 4.2, Enterpise Edition

   По сравнению с обычной версией Microsoft Visual C++ 4.2, версия Enterpise Edition, значительно расширяет возможности программиста при работе с базами данных.
   Если вы используете в своих программах базы данных Microsoft SQL Server или Oracle, то в окне Project Workspace появится новая страница – DataView. В ней представлены различные объекты базы данных – таблицы, хранимые процедуры, триггеры и т. д.
   В состав Microsoft Visual C++ 4.2 Enterpise Edition включен отладчик, позволяющий отлаживать хранимые процедуры на языке SQL. Это значительно упрощает этап отладки программы и поиска возможных ошибок.
   Интересные новшества введены и в текстовый редактор Microsoft Visual C++. Теперь он имеет возможность более полно работать с текстами на языке SQL, выделяя цветом ключевые слова этого языка.

   Создайте новое приложение с многооконным интерфейсом и назовите его Multi. При определении свойств приложения оставьте все предложения по умолчанию. Приложение Multi не будет использовать технологию OLE и сетевые технологии, не будет работать с базами данных. Процедура создания приложений с использованием MFC AppWizard описана в разделе “Приложение с оконным интерфейсом” 24 тома серии “Библиотека системного программиста”, поэтому мы будем считать, что вы уже создали проект.
   Постройте проект и запустите полученное приложение. На экране появится главное окно. Внутри главного окна расположены меню, панель управления и панель состояния.
   Сразу после запуска приложения Multi, открывается дочернее окно, предназначенное для просмотра документа, которое получает название Multi1. Вы можете создать новые дочерние окна, выбрав из меню File строку New – открыть новый документ или строку Open – открыть файл (рис. 1.1). Для просмотра уже открытого документа можно открыть еще одно окно (рис. 1.11). В названии такого окна указывается дополнительный числовой индекс.
   Если одновременно открыто несколько окон, то можно упорядочить расположение этих окон и пиктограмм, представляющих минимизированные окна. Для этого специально предназначено меню Window.
   Рис. 1.1. Приложение Multi
 
   Теперь рассмотрим внимательно сам проект Multi, подготовленный для нас MFC AppWizard. Найдите окно Project Workspace и откройте страницу FileView. Вы увидите список всех исходных файлов, входящих в проект (рис. 1.2). В отдельную папку Dependencies будут помещены названия вспомогательных файлов проекта. Эти файлы не входят в проект непосредственно, но используются либо для хранения ресурсов, либо как включаемые файлы, указанные директивой #include в одном или нескольких основных файлах проекта.
   Рис. 1.2. Окно Project Workspace, файлы проекта
 
   В следующей таблице кратко описаны основные файлы проекта Multi. Ниже мы подробно рассмотрим ресурсы приложения Multi, а также опишем составляющие его классы и их методы.

Имя файла	Описание
ChildFrm.cpp	Файл содержит определение методов класса CChildFrame
ChildFrm.h	В файле находится определение класса дочернего окна MDI – CChildFrame
MainFrm.cpp	Файл содержит определения методов класса CMainFrame
MainFrm.h	Содержит описание класса главного окна приложения, который называется CMainFrame. Класс CMainFrame наследуется от базового класса CFrameWnd, определенного в библиотеке классов MFC
Multi.cpp	Основной файл приложения. В нем определены методы основного класса приложения CMultiApp
Multi.h	В этом файле перечислены другие включаемые файлы и описан главный класс приложения CMultiApp
Multi.pch	Файл создается во время первой трансляции программы, если вы используете предварительную компиляцию включаемых файлов
Multi.rc	Файл ресурсов. В этом файле описаны все ресурсы приложения. Сами ресурсы могут быть записаны в каталоге RES, расположенном в главном каталоге проекта
MultiDoc.cpp	Включает определение методов класса CMultiDoc
MultiDoc.h	Содержит определение класса документов приложения – CMultiDoc
MultiView.cpp	Включает определение методов класса CMultiView
MultiView.h	Содержит описание класса окна просмотра приложения – CMultiView
ReadMe.txt	Текстовый файл, содержащий описание проекта. В нем кратко рассмотрен каждый файл, входящий в проект, перечислены классы приложения, а также представлена некоторая другая дополнительная информация
res\Multi.ico	Пиктограмма приложения
res\Multi.rc2	В этом файле определены ресурсы, которые нельзя редактировать с помощью редактора ресурсов среды Visual C++
res\MultiDoc.ico	Пиктограмма для документов приложения
res\Toolbar.bmp	Файл содержит растровое изображение кнопок панели управления
Resource.h	Файл содержит определения идентификаторов ресурсов приложения, например, идентификаторы строк меню
StdAfx.h, StdAfx.cpp	Использование этих файлов позволяет ускорить процесс повторного построения проекта. Более подробное описание файлов представлено ниже

   Рассмотрим ресурсы, которые MFC AppWizard создал для нашего приложения. Откройте страницу RecourceView в окне проекта Project Workspace. В нем отображается полный список всех ресурсов приложения (рис. 1.3).
   Рис. 1.3. Окно Project Workspace, ресурсы приложения
 
   Сравните эти ресурсы с ресурсами приложения с однооконным интерфейсом (том 24 серии “Библиотека системного программиста”). Вы заметите, что в состав приложения с многооконным интерфейсом входит больше ресурсов. Так, например, для многооконного приложения определены два меню, две пиктограммы, больше размер таблицы текстовых строк.

Национальные ресурсы

   Обратите внимание, что все ресурсы, представленные на странице RecourceView в окне проекта Project Workspace, английские. К сожалению, MFC AppWizard из доступных нам версий Microsoft Visual C++ не позволяет выбрать для создаваемого приложения русские ресурсы (язык для ресурсов выбирается в первой панели MFC AppWizard – Step 1, во время определения свойств приложения). Поэтому для приложения Multi и всех других приложений, созданных с помощью MFC AppWizard, мы выбрали английский язык.
   Если вы в Control Panel с помощью приложения Regional Settings выбрали русский язык, то в некоторых случаях ClassWizard может работать неправильно. Например, если вы добавите к английской диалоговой панели новые органы управления, то ClassWizard не позволит автоматически привязать к ним переменные. Возникнут также сложности при использовании русского текста в строковых ресурсах, помеченных как английские. Чтобы избежать этих проблем, измените язык, используемый для ресурсов. Для этого достаточно в окне Project Workspace щелкнуть по идентификатору ресурса правой кнопкой мыши и выбрать из открывшегося контекстного меню строку Properties. На экране появится диалоговая панель со свойствами выбранного ресурса. Измените в ней язык ресурса, выбрав из списка Language строку Russian.

Шаблон меню

   Для многооконного приложения в ресурсах проекта определены два меню с идентификаторами IDR_MAINFRAME и IDR_MULTITYPE. Приложение использует одно из этих меню, в зависимости от того, открыт документ или нет.
   Меню с идентификатором IDR_MAINFRAME используется, если в приложении не открыт ни один документ. Как видите, идентификатор меню совпадает с идентификатором меню приложения с однооконным интерфейсом, однако строки этих меню различаются:
   //////////////////////////////////////////////////////////////// Меню IDR_MAINFRAME
   IDR_MAINFRAME MENU PRELOAD DISCARDABLE
   BEGIN
    POPUP "&File"
    BEGIN
     MENUITEM "&New\tCtrl+N",    ID_FILE_NEW
     MENUITEM "&Open...\tCtrl+O",ID_FILE_OPEN
     MENUITEM SEPARATOR
     MENUITEM "P&rint Setup...", ID_FILE_PRINT_SETUP
     MENUITEM SEPARATOR
     MENUITEM "Recent File",     ID_FILE_MRU_FILE1, GRAYED
     MENUITEM SEPARATOR
    MENUITEM "E&xit",            ID_APP_EXIT
    END
    POPUP "&View"
    BEGIN
     MENUITEM "&Toolbar",        ID_VIEW_TOOLBAR
     MENUITEM "&Status Bar",     ID_VIEW_STATUS_BAR
    END
    POPUP "&Help"
    BEGIN
     MENUITEM "&About Multi...", ID_APP_ABOUT
    END
   END
   Меню, имеющее идентификатор IDR_MULTITYPE, отображается, когда пользователь создает новый документ или открывает документ, уже записанный в файле на диске.
   Как видите, в этом меню определено временное меню Window, строки которого служат для управления MDI окнами приложения:
   //////////////////////////////////////////////////////////////// Меню IDR_MAINFRAME
   IDR_MAINFRAME MENU PRELOAD DISCARDABLE
   BEGIN
    POPUP "&File"
    BEGIN
     MENUITEM "&New\tCtrl+N",     ID_FILE_NEW
     MENUITEM "&Open...\tCtrl+O", ID_FILE_OPEN
     MENUITEM SEPARATOR
     MENUITEM "P&rint Setup...",  ID_FILE_PRINT_SETUP
     MENUITEM SEPARATOR
     MENUITEM "Recent File",      ID_FILE_MRU_FILE1, GRAYED
     MENUITEM SEPARATOR
     MENUITEM "E&xit",            ID_APP_EXIT
    END
    POPUP "&View"
    BEGIN
     MENUITEM "&Toolbar",         ID_VIEW_TOOLBAR
     MENUITEM "&Status Bar",      ID_VIEW_STATUS_BAR
    END
    POPUP "&Help"
    BEGIN
     MENUITEM "&About Multi...",  ID_APP_ABOUT
    END
   END
   Большинство строк меню приложения Multi имеет стандартные идентификаторы. Соответствующие им стандартные командные сообщения обрабатываются различными классами библиотеки MFC. Так, например, стандартное командное сообщение с идентификатором ID_FILENEW от строки New меню File, по умолчанию обрабатывается методом OnFileNew класса CWinApp. Мы уже рассказывали о стандартных командных сообщениях в 24 томе из серии “Библиотека системного программиста”. Более подробное описание стандартных командных сообщений вы можете найти в документации Microsoft Visual C++.
   В этой книге мы посвятили меню приложений отдельную главу, которая называется “Меню, панели управления и панели состояния”. Дополнительную информацию об использовании меню вы можете получить в 13 томе серии “Библиотека системного программиста”.

Пиктограмма

   В файле ресурсов приложения Multi определены две пиктограммы IDR_MULTITYPE и IDR_MAINFRAME. Каждая из этих пиктограмм содержит по два изображения размером 32×32 и 16×16 пикселов. Внешний вид пиктограмм соответствует пиктограммам, используемым приложением с однооконным интерфейсом. Для однооконного приложения пиктограмма, представляющая документ, называлась IDR_SINGLETYPE, а не IDR_MULTITYPE. Такая разница в названиях возникла исключительно из-за разницы в названиях проектов приложений:
   //////////////////////////////////////////////////////////////
   // Пиктограммы
   IDR_MAINFRAME ICON DISCARDABLE "res\\Multi.ico"
   IDR_MULTITYPE ICON DISCARDABLE "res\\MultiDoc.ico"
   Пиктограмма IDR_MAINFRAME представляет приложение, когда оно минимизировано (рис. 1.4). Эта же пиктограмма отображается в левом верхнем углу главного окна приложения.
   Рис. 1.4. Пиктограмма IDR_MAINFRAME
 
   Пиктограмма IDR_MULTITYPE используется для представления документа с которым работает приложение (рис. 1.5). В отличие от приложения с однооконным интерфейсом, которое не использует эту пиктограмму, приложение с многооконным интерфейсом отображает пиктограмму IDR_MULTITYPE в левом верхнем углу окна документа.
   Рис. 1.5. Пиктограмма IDR_MULTITYPE
 

Панель управления toolbar

   Несмотря на то, что приложение имеет два меню, для него определена только одна панель управления IDR_MAINFRAME. Идентификаторы первых трех и последних двух кнопок этой панели соответствуют идентификаторам строк и меню IDR_MAINFRAME и меню IDR_MULTITYPE. А вот вторые три идентификатора имеют соответствие только в меню IDR_MULTITYPE. Пока ни один документ не открыт и отображается меню IDR_MAINFRAME, эти кнопки недоступны и отображаются серым цветом:
   //////////////////////////////////////////////////////////////
   // Панель управления Toolbar
   IDR_MAINFRAME TOOLBAR DISCARDABLE  16, 15
   BEGIN
    BUTTON ID_FILE_NEW
    BUTTON ID_FILE_OPEN
    BUTTON ID_FILE_SAVE
    SEPARATOR
    BUTTON ID_EDIT_CUT
    BUTTON ID_EDIT_COPY
    BUTTON ID_EDIT_PASTE
    SEPARATOR
    BUTTON ID_FILE_PRINT
    BUTTON ID_APP_ABOUT
   END
   Образ кнопок панели управления расположен в файле Toolbar.bmp, записанном в подкаталоге res каталога проекта (рис. 1.6):
   //////////////////////////////////////////////////////////////
   // Изображение Bitmap, определяющее кнопки приложения
   IDR_MAINFRAME BITMAP MOVEABLE PURE "res\\Toolbar.bmp"
   Панелям управления мы уделили в этой книге отдельную главу, которая имеет название “Меню, панели управления и панели состояния”. В ней описаны принципы устройства и работы панелей управления, приведены простые примеры создания дополнительных панелей управления, в том числе панелей управления на основе шаблонов диалоговых панелей.
   Рис. 1.6. Панель управления
 

Таблица акселераторов

   Таблица акселераторов IDR_MAINFRAME приложения полностью соответствует таблице акселераторов, добавленной MFC AppWizard к ресурсам приложения с однооконным интерфейсом:
   //////////////////////////////////////////////////////////////
   // Таблица акселераторов
   IDR_MAINFRAME ACCELERATORS PRELOAD MOVEABLE PURE
   BEGIN
    "N",       ID_FILE_NEW,   VIRTKEY,CONTROL
    "O",       ID_FILE_OPEN,  VIRTKEY,CONTROL
    "S",       ID_FILE_SAVE,  VIRTKEY,CONTROL
    "P",       ID_FILE_PRINT, VIRTKEY,CONTROL
    "Z",       ID_EDIT_UNDO,  VIRTKEY,CONTROL
    "X",       ID_EDIT_CUT,   VIRTKEY,CONTROL
    "C",       ID_EDIT_COPY,  VIRTKEY,CONTROL
    "V",       ID_EDIT_PASTE, VIRTKEY,CONTROL
    VK_BACK,   ID_EDIT_UNDO,  VIRTKEY,ALT
    VK_DELETE, ID_EDIT_CUT,   VIRTKEY,SHIFT
    VK_INSERT, ID_EDIT_COPY,  VIRTKEY,CONTROL
    VK_INSERT, ID_EDIT_PASTE, VIRTKEY,SHIFT
    VK_F6,     ID_NEXT_PANE,  VIRTKEY
    VK_F6,     ID_PREV_PANE,  VIRTKEY,SHIFT
   END
   Мы расскажем вам подробнее о таблице акселераторов в разделе “Таблица акселераторов”. Дополнительную информацию вы сможете получить в 13 томе серии “Библиотека системного программиста”.

Диалоговая панель

   В ресурсах приложения определена диалоговая панель с идентификатором IDD_ABOUTBOX. Она содержит краткую информацию о приложении и отображается на экране, когда пользователь выбирает из меню Help строку About Multi:
   //////////////////////////////////////////////////////////////
   // Версия
   VS_VERSION_INFO     VERSIONINFO
    FILEVERSION    1,0,0,1
    PRODUCTVERSION 1,0,0,1
    ILEFLAGSMASK 0x3fL
   #ifdef _DEBUG
     FILEFLAGS 0x1L
   #else
     FILEFLAGS 0x0L
   #endif
    FILEOS 0x4L
    FILETYPE 0x1L
    FILESUBTYPE 0x0L
   BEGIN
    BLOCK "StringFileInfo"
    BEGIN
     BLOCK "040904B0"
      BEGIN
      VALUE "CompanyName", "Solaris\0"
      VALUE "FileDescription", "MULTI MFC Application\0"
      VALUE "FileVersion", "1, 0, 0, 1\0"
      VALUE "InternalName", "MULTI\0"
      VALUE "LegalCopyright", "Copyright © 1996 Frolov G.V.\0"
      VALUE "OriginalFilename", "MULTI.EXE\0"
      VALUE "ProductName", "MULTI Application\0"
      VALUE "ProductVersion", "1, 0, 0, 1\0"
     END
    END
    BLOCK "VarFileInfo"
    BEGIN
     VALUE "Translation", 0x409, 1200
    END
   END

Таблица текстовых строк

   Ресурсы приложения содержат несколько блоков, описывающих таблицы текстовых строк. Эти таблицы практически совпадают с таблицами текстовых строк, включенных MFC AppWizard в ресурсы приложения с однооконным интерфейсом.
   Блоки текстовых строк, описывающие тип документов приложения, и основные характеристики главного окна приложения совпадают с соответствующими блоками однооконного приложения, за исключением строки с названием проекта:
   //////////////////////////////////////////////////////////////
   // Таблица текстовых строк
   STRINGTABLE PRELOAD DISCARDABLE
   BEGIN
    IDR_MAINFRAME "Multi"
    IDR_MULTITYPE "\nMulti\nMulti\n\n\nMulti.Document\nMulti Document"
   END
   STRINGTABLE PRELOAD DISCARDABLE
   BEGIN
    AFX_IDS_APP_TITLE   "Multi"
    AFX_IDS_IDLEMESSAGE "Ready"
   END
   Блок текстовых строк, которые используются в панели состояния ststus bar, полностью совпадает с аналогичным блоком в ресурсах однооконного приложения:
   STRINGTABLE DISCARDABLE
   BEGIN
    ID_INDICATOR_EXT  "EXT"
    ID_INDICATOR_CAPS "CAP"
    ID_INDICATOR_NUM  "NUM"
    ID_INDICATOR_SCRL "SCRL"
    ID_INDICATOR_OVR  "OVR"
    ID_INDICATOR_REC  "REC"
   END
   В блоке текстовых строк, описывающих элементы меню, добавлен ряд текстовых строк, которые относятся к меню Window. Для однооконного приложения эти строки не определены, так как меню Window есть только у многооконных приложений:
   STRINGTABLE DISCARDABLE
   BEGIN
    ID_FILE_NEW         "Create a new document\nNew"
    ID_FILE_OPEN        "Open an existing document\nOpen"
    ...
    ID_PREV_PANE        "Switch back to the previous window pane\nPrevious Pane"
    ID_WINDOW_NEW       "Open another window for the active document\nNew Window"
    ID_WINDOW_ARRANGE   "Arrange icons at the bottom of the window\nArrange Icons"
    ID_WINDOW_CASCADE   "Arrange windows so they overlap\nCascade Windows"
    ID_WINDOW_TILE_HORZ "Arrange windows as non-overlapping tiles\nTile Windows"
    ID_WINDOW_TILE_VERT "Arrange windows as non-overlapping tiles\nTile Windows"
    ID_WINDOW_SPLIT     "Split the active window into panes\nSplit"
    ...
    ID_EDIT_CLEAR       "Erase the selection\nErase"
    ID_VIEW_TOOLBAR     "Show or hide the toolbar\nToggle ToolBar"
    ID_VIEW_STATUS_BAR  "Show or hide the status bar\nToggle StatusBar"
   END
   По сравнению с ресурсами однооконного приложения, для приложений с многооконным пользовательским интерфейсом, добавлен еще один блок текстовых строк. В нем содержатся строки, имеющие отношение к многооконному интерфейсу приложения:
   STRINGTABLE DISCARDABLE
   BEGIN
    AFX_IDS_SCSIZE        "Change the window size"
    AFX_IDS_SCMOVE        "Change the window position"
    AFX_IDS_SCMINIMIZE    "Reduce the window to an icon"
    AFX_IDS_SCMAXIMIZE    "Enlarge the window to full size"
    AFX_IDS_SCNEXTWINDOW  "Switch to the next document window"
    AFX_IDS_SCPREVWINDOW  "Switch to the previous document window"
    AFX_IDS_SCCLOSE       "Close the active window and prompts to save the documents"
    AFX_IDS_SCRESTORE     "Restore the window to normal size"
    AFX_IDS_SCTASKLIST    "Activate Task List"
    AFX_IDS_MDICHILD      "Activate this window"
    AFX_IDS_PREVIEW_CLOSE "Close print preview mode\nCancel Preview"
   END

   MFC AppWizard создает для приложения Multi, обладающего многооконным интерфейсом, шесть основных классов, что на один класс больше, чем для однооконного приложения. Пять классов из шести представляют основу любого многооконного приложения, созданного MFC AppWizard. Шестой класс управляет информационной диалоговой панелью About.
   Список названий классов, а также входящие в них методы и элементы данных можно просмотреть на странице ClassView окна Project Workspace (рис. 1.7). В отдельной папке Globals представлены глобальные объекты и переменные приложения. Приложение Multi имеет только один глобальный объект theApp. Это объект главного класса приложения.
   Рис. 1.7. Окно Project Workspace, классы приложения
 
   В следующей таблице кратко описано назначение отдельных классов приложения Multi. Более подробный рассказ об этих классах и их методах расположен ниже.

Класс приложения	Базовый класс	Описание
CMultiApp	CWinApp	Главный класс приложения
CMainFrame	CMDIFrameWnd	Класс главного окна приложения
CChildFrame	CMDIChildWnd	Класс дочернего окна MDI
CMultiDoc	CDocument	Класс документа приложения
CMultiView	CView	Класс окна просмотра документа

   Кроме пяти основных классов создается также класс CAboutDlg, наследованный от базового класса CDialog. Он отвечает за диалоговую панель About. Если во время определения характеристик приложения вы включите возможность работы с базами данных, работу с сетевыми протоколами или использование технологии OLE, список классов приложения может стать значительно шире.

Главный класс приложения

   Главный класс приложения CMultiApp управляет работой всего приложения. Методы этого класса выполняют инициализацию приложения, обработку цикла сообщений и вызываются при завершении приложения. Через окно Project Workspace можно просмотреть названия методов класса и загрузить их в текстовый редактор (рис. 1.8).
   Рис. 1.8. Окно Project Workspace, класс CMultiApp
 
   Класс CMultiApp определен в файле Multi.h следующим образом:
   //////////////////////////////////////////////////////////////// Класс CMultiApp
   class CMultiApp : public CWinApp {
   public:
    CMultiApp();
 
   // Overrides
    //{{AFX_VIRTUAL(CMultiApp)
   public:
    virtual BOOL InitInstance();
    //}}AFX_VIRTUAL
 
   // Implementation
    //{{AFX_MSG(CMultiApp)
    afx_msg void OnAppAbout();
    //}}AFX_MSG
 
    // Класс CMultiApp может получать сообщения
    DECLARE_MESSAGE_MAP()
   };
   В приложении определен только один объект базового класса приложения theApp. Этот объект должен быть один вне зависимости от того, какой интерфейс имеет приложение – однооконный, многооконный или основанный на диалоговой панели:
   CMultiApp theApp;

Конструктор класса CMultiApp

   Конструктор класса, созданный MFC AppWizard, не выполняет никаких действий. В нем вы можете разместить код для инициализации объекта CMultiApp:
   //////////////////////////////////////////////////////////////
   // Конструктор класса CMultiApp
   CMultiApp::CMultiApp() {
    // TODO:
   }

Метод InitInstance класса CMultiApp

   Основную работу по инициализации приложения выполняет метод InitInstance главного класса приложения, определенный в файле Multi.cpp. Как видите, он отличается от метода InitInstance, который используется для однооконных приложений:
   //////////////////////////////////////////////////////////////
   // Метод InitInstance
   BOOL CMultiApp::InitInstance() {
 
   #ifdef _AFXDLL
    Enable3dControls();  
   #else
    Enable3dControlsStatic();
   #endif
 
    // Загружаем файл конфигурации
    LoadStdProfileSettings();
 
    // Создаем шаблон документа
    CMultiDocTemplate* pDocTemplate;
    pDocTemplate = new CMultiDocTemplate(IDR_MULTITYPE, RUNTIME_CLASS(CMultiDoc), RUNTIME_CLASS(CChildFrame), RUNTIME_CLASS(CMultiView));
 
    // Регистрируем шаблон документа
    AddDocTemplate(pDocTemplate);
 
    // Создаем главное окно приложения (MDI Frame window)
    CMainFrame* pMainFrame = new CMainFrame;
    if (!pMainFrame->LoadFrame(IDR_MAINFRAME)) return FALSE;
    m_pMainWnd = pMainFrame;
 
    // Выполняем стандартную обработку командной строки
    // приложения
    CCommandLineInfo cmdInfo;
    ParseCommandLine(cmdInfo);
 
    // Обрабатываем командную строку приложения
    if (!ProcessShellCommand(cmdInfo)) return FALSE;
 
    // Отображаем окно
    pMainFrame->ShowWindow(m_nCmdShow);
    pMainFrame->UpdateWindow();
 
    return TRUE;
   }
   В начале InitInstance вызываются методы Enable3dControls и LoadStdProfileSettings. Они уже были описаны в предыдущем томе серии “Библиотека системного программиста”, посвященном MFC, поэтому мы не станем на них останавливаться и перейдем к рассмотрению шаблонов документа приложения.
   Затем создается указатель pDocTemplate на объекты класса шаблона документов. Для однооконных приложений это класс CSingleDocTemplate, а для многооконных – CMultiDocTemplate. Создается новый объект класса и указатель на него записывается в переменную pDocTemplate. Для создания шаблона документа используется оператор new.
   Конструктору класса CMultiDocTemplate передаются четыре параметра:
   CMultiDocTemplate(UINT nIDResource, CRuntimeClass* pDocClass, CRuntimeClass* pFrameClass, CRuntimeClass* pViewClass);
   Первый параметр nIDResource определяет идентификатор ресурсов, используемых совместно с типом документов, управляемых шаблоном. К таким ресурсам относятся меню, пиктограмма, строковый ресурс, таблица акселераторов. Для приложения Multi в этом параметре указан идентификатор IDR_MULTITYPE.
   Остальные три параметра pDocClass, pFrameClass и pViewClass содержат указатели на объекты класса CRuntimeClass, полученные с помощью макрокоманд RUNTIME_CLASS из классов документа CMultiDoc, дочернего окна MDI CChildFrame и окна просмотра CMultiView. Таким образом, шаблон документа объединяет всю информацию, относящуюся к данному типу документов.
   Созданный шаблон документов заносится в список шаблонов, с которыми работает приложение. Для этого указатель на созданный шаблон документа передается методу AddDocTemplate из класса CWinApp. Указатель на шаблон документов передается через параметр pTemplate:
   void AddDocTemplate(CDocTemplate* pTemplate);
   Указатель pTemplate должен указывать на объект класса CDocTemplate, однако мы передаем через него указатель на объект класса CMultiDocTemplate. Это допустимо, так как класс CDocTemplate является базовым классом для CMultiDocTemplate.
   Если вы разрабатываете приложение, основанное на однооконном или многооконном интерфейсе, объект главного класса приложения управляет одним или несколькими объектами класса шаблона документа. Они, в свою очередь, управляют созданием документов. Один шаблон используется для всех документов данного типа.
   После создания шаблона документа создается главное окно MDI (главное окно приложения).
   Для создания главного окна приложения мы формируем объект класса CMainFrame и записываем указатель на него в pMainFrame. Класс CMainFrame определен в нашем приложении. Мы расскажем о нем немного позже:
   // Создаем главное окно MDI (главное окно приложения)
   CMainFrame* pMainFrame = new CMainFrame;
   Затем для только что созданного объекта вызывается метод LoadFrame класса CFrameWnd. Он создает окно, загружает ресурсы, указанные первым параметром, и связывает их с объектом класса CMainFrame. Параметр метода LoadFrame определяет меню, пиктограмму, таблицу акселераторов и таблицу строк главного окна приложения:
   if (!pMainFrame->LoadFrame(IDR_MAINFRAME)) return FALSE;
   Указатель на главное окно приложения, которым является главное окно MDI, записывается в элемент данных m_pMainWnd главного класса приложения. Элемент данных m_pMainWnd, определенн в классе CWinThread. Когда окно, представленное указателем m_pMainWnd закрывается, приложение автоматически будет завершено (в случае если приложение включает в себя несколько задач, завершается только соответствующая задача):
   m_pMainWnd = pMainFrame;
   Метод LoadFrame не отображает главное окно приложения на экране. Для этого надо вызвать методы ShowWindow и UpdateWindow:
   // Отображаем главное окно приложения
   pMainFrame->ShowWindow(m_nCmdShow);
   // Обновляем содержимое окна
   pMainFrame->UpdateWindow();
   В заключение метода InitInstance обрабатывается командная строка приложения. Для этого создается объект cmdInfo класса CCommandLineInfo и для него вызываются методы ParseCommandLine и ProcessShellCommand:
   // Просматриваем командную строку приложения в поиске
   // стандартных команд и обрабатываем их
   CCommandLineInfo cmdInfo;
   ParseCommandLine(cmdInfo);
 
   // Распределяем команды, указанные в командной строке
   // приложения
   if (!ProcessShellCommand(cmdInfo)) return FALSE;

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

   Класс CMultiApp может получать сообщения и имеет таблицу сообщений. Таблицу сообщений класса CMultiApp расположена в файле Multi.cpp. Она содержит четыре макрокоманды для обработки командных сообщений от меню приложения:
   //////////////////////////////////////////////////////////////
   // Таблица сообщений класса CMultiApp
   BEGIN_MESSAGE_MAP(CMultiApp, CWinApp)
    //{{AFX_MSG_MAP(CMultiApp)
    ON_COMMAND(ID_APP_ABOUT, OnAppAbout)
    //}}AFX_MSG_MAP
    ON_COMMAND(ID_FILE_NEW, CWinApp::OnFileNew)
    ON_COMMAND(ID_FILE_OPEN, CWinApp::OnFileOpen)
    ON_COMMAND(ID_FILE_PRINT_SETUP, CWinApp::OnFilePrintSetup)
   END_MESSAGE_MAP()
   Только для одного командного сообщения, имеющего идентификатор ID_APP_ABOUT, вызывается метод обработчик OnAppAbout, определенный в классе CMultiApp. Остальные три командных сообщения ID_FILE_NEW, ID_FILE_OPEN и ID_FILE_PRINT_SETUP передаются для обработки методам класса CWinApp, который является базовым классом для CMultiApp.
   Метод-обработчик OnAppAbout вызывается объектом главного класса приложения, когда пользователь выбирает из меню Help строку About. OnAppAbout создает объект класса CAboutDlg, представляющий модальную диалоговую панель About и вызывает для него метод DoModal, отображающий панель на экране (рис. 1.9):
   void CMultiApp::OnAppAbout() {
    CAboutDlg aboutDlg;
    aboutDlg.DoModal();
   }
   Рис. 1.9. Окно Project Workspace, класс CMainFrame
 

Класс главного окна приложения

   Внутри главного окна приложения отображаются панели управления и состояния, дочерние MDI окна, используемые для просмотра документов. Для управления главным окном приложения используется класс CMainFrame, определенный в файле MainFrm.h.
   Вы можете изучить класс CMDIFrameWnd, просмотрев его структуру в окне Project Workspace, на странице ClassView (рис. 1.10). Выполните двойной щелчок левой кнопкой мыши по названию класса или по названию интересующего вас метода, и соответствующий программный код загрузится в окно редактора Microsoft Visual C++.
 
   Рис. 1.10. Окно Project Workspace, класс CMainFrame
 
   Ниже мы привели определение класса CMainFrame:
   class CMainFrame : public CMDIFrameWnd {
    DECLARE_DYNAMIC(CMainFrame)
   public:
    CMainFrame();
 
   // Attributes
   public:
 
   // Operations
   public:
 
   // Overrides
    //{{AFX_VIRTUAL(CMainFrame)
    virtual BOOL PreCreateWindow(CREATESTRUCT& cs);
    //}}AFX_VIRTUAL
 
   // Implementation
   public:
    virtual ~CMainFrame();
   #ifdef _DEBUG
    virtual void AssertValid() const;
    virtual void Dump(CDumpContext& dc) const;
   #endif
 
   protected:
    CStatusBar m_wndStatusBar;
    CToolBar   m_wndToolBar;
 
   protected:
    //{{AFX_MSG(CMainFrame)
    afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
    //}}AFX_MSG
    DECLARE_MESSAGE_MAP()
   };
   Класс главного окна многооконного приложения CMainFrame практически полностью соответствует классу главного окна однооконного приложения. Даже названия этих классов одинаковы. Однако обратите внимание, что класс CMainFrame наследуется от базового класса CMDIFrameWnd, а не от CFrameWnd, как это было для однооконного приложения.

Конструктор и деструктор класса CMainFrame

   Ниже представлены конструктор и деструктор класса CMainFrame. Изначально они не содержат программного кода и представляют собой простые заготовки. Вы можете использовать их для дополнительной инициализации объекта класса:
   // Конструктор класса CMainFrame
   CMainFrame::CMainFrame() {
    // TODO:
   }
   // Деструктор класса CMainFrame
   CMainFrame::~CMainFrame() {}

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

   Таблица сообщений класса CMainFrame содержит только одну макрокоманду ON_WM_CREATE, которая устанавливает для обработки сообщения WM_CREATE метод OnCreate. Сообщения WM_CREATE приходит во время создания главного окна приложения.
   Непосредственно перед таблицей сообщений класса CMainFrame располагается макрокоманда IMPLEMENT_DYNAMIC. Она указывает, что объекты класса CMainFrame могут создаваться динамически во время работы приложения:
   // Объекты класса CMainFrame могут создаваться автоматически
   IMPLEMENT_DYNAMIC(CMainFrame, CMDIFrameWnd)
 
   // Таблица сообщений
   BEGIN_MESSAGE_MAP(CMainFrame, CMDIFrameWnd)
    //{{AFX_MSG_MAP(CMainFrame)
    ON_WM_CREATE()
    //}}AFX_MSG_MAP
   END_MESSAGE_MAP()

Метод OnCreate класса CMainFrame

   Метод OnCreate класса CMainFrame создает и отображает на экране панели управления и состояния:
   int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct) {
    if (CMDIFrameWnd::OnCreate(lpCreateStruct) == -1) return -1;
 
    if (!m_wndToolBar.Create(this) || !m_wndToolBar.LoadToolBar(IDR_MAINFRAME)) {
     // Ошибка создания панели управления
     TRACE0("Failed to create toolbar\n");
     return -1;   
    }
 
    if (!m_wndStatusBar.Create(this) || !m_wndStatusBar.SetIndicators(indicators, sizeof(indicators)/sizeof(UINT)))    {
     // Ошибка создания панели состояния
     TRACE0("Failed to create status bar\n");
     return -1;     
    }
 
    m_wndToolBar.SetBarStyle(m_wndToolBar.GetBarStyle() | CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC);
 
    m_wndToolBar.EnableDocking(CBRS_ALIGN_ANY);
    EnableDocking(CBRS_ALIGN_ANY);
    DockControlBar(&m_wndToolBar);
 
    return 0;
   }
   Структура indicators, описывающая индикаторы панели состояния, определена в файле MainFrm.h следующим образом:
   static UINT indicators[] = {
    ID_SEPARATOR,
    ID_INDICATOR_CAPS,
    ID_INDICATOR_NUM,
    ID_INDICATOR_SCRL,
   };
   Сейчас мы не станем подробно останавливаться на процедуре создания панелей состояния и управления. Во первых, в 24 томе мы уже рассматривали метод OnCreate однооконного приложения Single. Он фактически полностью повторяет метод OnCreate приложения Multi. Во вторых мы посвятили проблеме использования меню, панелей состояния и панелей управления отдельный раздел “Меню, панели управления и панели состояния”. Прочитав его, вы полностью поймете как устроен метод OnCreate класса CMainFrame.

Метод PreCreateWindow класса CMainFrame

   Метод PreCreateWindow вызывается перед созданием окна и позволяет изменить его характеристики. В нашем приложении метод PreCreateWindow не используется и просто выполняет обрработку по умолчанию:
   BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs) {
   // TODO:
 
    return CMDIFrameWnd::PreCreateWindow(cs);
   }

Методы AssertValid и Dump класса CMainFrame

   В отладочной версии приложения класс CMainFrame содержит переопределения виртуальных методов AssertValid и Dump. Эти методы определены в базовом классе CObject и используются при отладке приложения:
   //////////////////////////////////////////////////////////////
   // Диагностические методы класса CMainFrame
   #ifdef DEBUG
   void CMainFrame::AssertValid() const {
    CMDIFrameWnd::AssertValid();
   }
 
   void CMainFrame::Dump(CDumpContext& dc) const {
    CMDIFrameWnd::Dump(dc);
   }

Класс дочернего окна MDI

   Многооконное приложение строится с использованием большего числа классов, чем однооконное приложение. Помимо классов главного окна приложения и классов окна просмотра документа, в нем определен еще один класс, непосредственно связанный с отображением дочерних окон MDI. Этот класс называется CChildFrame и он наследуется от базового класса CMDIChildWnd , определенного в библиотеке MFC:
   class CChildFrame : public CMDIChildWnd {
    DECLARE_DYNCREATE(CChildFrame)
   public:
    CChildFrame();
 
   // Attributes
   public:
 
   // Operations
   public:
 
   // Overrides
    //{{AFX_VIRTUAL(CChildFrame)
    virtual BOOL PreCreateWindow(CREATESTRUCT& cs);
    //}}AFX_VIRTUAL
 
   // Implementation
   public:
    virtual ~CChildFrame();
   #ifdef _DEBUG
    virtual void AssertValid() const;
    virtual void Dump(CDumpContext& dc) const;
   #endif
 
   protected:
    //{{AFX_MSG(CChildFrame)
    //}}AFX_MSG
    DECLARE_MESSAGE_MAP()
   };
   Элементы класса CChildFrame вы можете просмотреть в окне Project Workspace на странице ClassView (рис. 1.11).
   Рис. 1.11. Окно Project Workspace, класс CChildFrame
 
   Объекты класса CChildFrame представляют дочерние окна MDI главного окна приложения. Внутри этих окон отображаются окна просмотра документа.

Конструктор и деструктор класса CChildFrame

   MFC AppWizard определяет для класса CChildFrame конструктор и деструктор. По умолчанию они не выполняют никаких действий. Вы можете изменить их для выполнения инициализации объектов класса дочернего окна MDI:
   //////////////////////////////////////////////////////////////
   // Конструктор и деструктор класса CChildFrame
   CChildFrame::CChildFrame() {
    // TODO:
   }
 
   CChildFrame::~CChildFrame() {}

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

   Таблица сообщений класса CChildFrame не содержит обработчиков сообщений:
   // Объекты класса CChildFrame создаются динамически
   IMPLEMENT_DYNCREATE(CChildFrame, CMDIChildWnd)
   // Таблица сообщений
   BEGIN_MESSAGE_MAP(CChildFrame, CMDIChildWnd)
    //{{AFX_MSG_MAP(CChildFrame)
    //}}AFX_MSG_MAP
   END_MESSAGE_MAP()

Метод PreCreateWindow класса CChildFrame

   Метод PreCreateWindow вызывается перед созданием дочернего окна MDI. Вы можете использовать его, чтобы переопределить стили этого окна:
   BOOL CChildFrame::PreCreateWindow(CREATESTRUCT& cs) {
   // TODO:
 
    return CMDIChildWnd::PreCreateWindow(cs);
   }

Методы AssertValid и Dump класса CChildFrame

   Методы AssertValid и Dump переопределяются в классе CMainFrame только для отладочной версии приложения и используются при отладке приложения:
   //////////////////////////////////////////////////////////////
   // Диагностические методы класса CChildFrame
   #ifdef _DEBUG
   void CChildFrame::AssertValid() const {
    CMDIChildWnd::AssertValid();
   }
 
   void CChildFrame::Dump(CDumpContext& dc) const {
    CMDIChildWnd::Dump(dc);
   }

Класс документа приложения

   Класс документа приложения CMultiDoc наследуется от базового класса CDocument библиотеки MFC. Определение этого класса вы можете найти в файле MultiDoc.h. Мы привели структуру класса CMultiDoc на рисунке 1.12.
   Рис. 1.12. Окно Project Workspace, класс CMultiDoc
 
   MFC AppWizard определяет класс CMultiDoc одинаково для однооконных и для многооконных приложений. Единственное исключение составляет название класса документа, которое создается на основе имени проекта:
   class CMultiDoc : public CDocument {
   protected:
    CMultiDoc();
    DECLARE_DYNCREATE(CMultiDoc)
 
   // Attributes
   public:
 
   // Operations
   public:
 
   // Overrides
    //{{AFX_VIRTUAL(CMultiDoc)
   public:
    virtual BOOL OnNewDocument();
    virtual void Serialize(CArchive& ar);
    //}}AFX_VIRTUAL
 
   // Implementation
   public:
    virtual ~CMultiDoc();
   #ifdef _DEBUG
    virtual void AssertValid() const;
    virtual void Dump(CDumpContext& dc) const;
   #endif
 
   protected:
 
   protected:
    //{{AFX_MSG(CMultiDoc)
    //}}AFX_MSG
    DECLARE_MESSAGE_MAP()
   };

Конструктор и деструктор класса CMultiDoc

   Конструктор и деструктор класса CMultiDoc не содержит программного кода. Вы можете добавить его по мере необходимости:
   CMultiDoc::CMultiDoc() {
    // TODO:
   }
 
   CMultiDoc::~CMultiDoc() {}

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

   Таблица сообщений класса CMultiDoc не содержит ни одного обработчика сообщений:
   // Объекты класса CMultiDoc могут создаваться динамически
   IMPLEMENT_DYNCREATE(CMultiDoc, CDocument)
 
   // Таблица сообщений класса CMultiDoc
   BEGIN_MESSAGE_MAP(CMultiDoc, CDocument)
    //{{AFX_MSG_MAP(CMultiDoc)
    //}}AFX_MSG_MAP
   END_MESSAGE_MAP()

Методы OnNewDocument и Serialize класса CMultiDoc

   В классе CMultiDoc переопределены два виртуальных метода – OnNewDocument и Serialize. Виртуальный метод OnNewDocument определен в классе CDocument, от которого непосредственно наследуется класс CSingleDoc.
   Метод OnNewDocument вызывается, когда надо создать новый документ для приложения. Для одноконных приложений метод OnNewDocument вызывался только один раз при запуске приложения.
   Для многооконного приложения метод OnNewDocument вызывается каждый раз, когда пользователь создает новый документ. Более подробно об использовании метода OnNewDocument мы расскажем в следующих главах, когда к шаблону приложения, созданному MFC AppWizard, мы будем добавлять собственный код:
   BOOL CMultiDoc::OnNewDocument() {
    if (!CDocument::OnNewDocument()) return FALSE;
 
    // TODO: Здесь можно выполнить инициализацию документа
 
    return TRUE;
   }
   Метод Serialize вызывается в тех случаях, когда надо загрузить документ из файла на диске или наоборот, записать его в файл:
   //////////////////////////////////////////////////////////////
   // Метод Serialize класса CMultiDoc
   void CMultiDoc::Serialize(CArchive& ar) {
    if (ar.IsStoring()) {
     // TODO:
    } else {
     // TODO:
    }
   }

Методы AssertValid и Dump класса CMultiDoc

   Методы AssertValid и Dump переопределяются в классе CMainFrame только для отладочной версии приложения и используются при отладке приложения:
   //////////////////////////////////////////////////////////////
   // Диагностические методы класса CMultiDoc
   #ifdef _DEBUG
   void CMultiDoc::AssertValid() const {
    CDocument::AssertValid();
   }
 
   void CMultiDoc::Dump(CDumpContext& dc) const {
    CDocument::Dump(dc);
   }
   #endif //_DEBUG

Класс окна просмотра документа

   Класс окна просмотра документа, также как класс документа и главный класс приложения, имеют своего двойника в однооконном приложении. Так, в приложении Single определен класс окна просмотра CSingleView, совпадающий с классом CMultiView.
   Рис. 1.13. Окно Project Workspace, класс CMultiView
 
   Вы можете просмотреть список методов, входящих в класс CMultiView, если откроете в окне Project Workspace страницу ClassView (рис. 1.13). А сейчас приведем определение класса CMultiView :
   class CMultiView : public CView {
   protected:
    CMultiView();
    DECLARE_DYNCREATE(CMultiView)
 
   // Attributes
   public:
    CMultiDoc* GetDocument();
 
   // Operations
   public:
 
   // Overrides
    //{{AFX_VIRTUAL(CMultiView)
   public:
    virtual void OnDraw(CDC* pDC); 
    virtual BOOL PreCreateWindow(CREATESTRUCT& cs);
   protected:
    virtual BOOL OnPreparePrinting(CPrintInfo* pInfo);
    virtual void OnBeginPrinting(CDC* pDC, CPrintInfo* pInfo);
    virtual void OnEndPrinting(CDC* pDC, CPrintInfo* pInfo);
    //}}AFX_VIRTUAL
 
   // Implementation
   public:
    virtual ~CMultiView();
   #ifdef _DEBUG
    virtual void AssertValid() const;
    virtual void Dump(CDumpContext& dc) const;
   #endif
 
   protected:
    //{{AFX_MSG(CMultiView)
    //}}AFX_MSG
    DECLARE_MESSAGE_MAP()
   };
   Как видите, класс CMultiView наследуется от базового класса CView. Вы, однако, можете наследовать этот класс и от некоторых других классов библиотеки MFC.

Метод GetDocument класса CMultiView

   В секции атрибутов класса CMultiView после комментария Attributes объявлен метод GetDocument. Этот метод возвращает указатель на документ, связанный с данным окном просмотра. Если окно просмотра не связано ни с каким документом, метод возвращает значение NULL.
   Метод GetDocument имеет две реализации. Одна используется для отладочной версии приложения, а другая – для окончательной. Окончательная версия GetDocument определена непосредственно после самого класса окна просмотра CMultiView как встраиваемый (inline ) метод:
   #ifndef _DEBUG
   inline CMultiDoc* CMultiView::GetDocument() { return (CMultiDoc*) m_pDocument; }
   #endif
   Переменная m_pDocument является элементом класса CView, определенным как protected. В документации на класс CView описание элемента m_pDocument отсутствует. Однако, вам достаточно знать, что после инициализации документа и окна просмотра в нем записан указатель на соответствующий документ. Если вы желаете получить дополнительную информацию, обратитесь к исходным текстам библиотеки MFC. Вы найдете определение класса CView и элемента этого класса m_pDocument в файле Afxwin.h.
   Метод GetDocument совпадает с одноименным методом класса окна просмотра однооконного приложения за исключением того, что тип возвращаемого им указателя CMultiDoc.
   Отладочная версия GetDocument расположена в файле реализации класса окна просмотра MultiView.cpp:
   #ifdef _DEBUG
   CMultiDoc* CMultiView::GetDocument() {
    ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CMultiDoc)));
    return (CMultiDoc*) m_pDocument;
   }
   #endif //_DEBUG

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

   Таблица сообщений класса CMultiView располагается в файле MultiView.cpp. Непосредственно перед ней расположена макрокоманда IMPLEMENT_DYNCREATE:
   // Объекты класса CMultiView создаются динамически
   IMPLEMENT_DYNCREATE(CMultiView, CView)
 
   // Таблица сообщений класса CMultiView
   BEGIN_MESSAGE_MAP(CMultiView, CView)
    //{{AFX_MSG_MAP(CMultiView)
    //}}AFX_MSG_MAP
    ON_COMMAND(ID_FILE_PRINT, CView::OnFilePrint)
    ON_COMMAND(ID_FILE_PRINT_DIRECT, CView::OnFilePrint)
    ON_COMMAND(ID_FILE_PRINT_PREVIEW, CView::OnFilePrintPreview)
   END_MESSAGE_MAP()

Конструктор и деструктор класса CMultiView

   Конструктор и деструктор класса CMultiView не выполняют полезной работы. MFC AppWizard создает для них только пустые шаблоны, которые вы можете “наполнить” сами:
   CMultiView::CMultiView() {
    // TODO:
   }
 
   CMultiView::~CMultiView() {}

Метод PreCreateWindow класса CMultiView

   Виртуальный метод PreCreateWindow определен в классе CWnd. Он вызывается непосредственно перед созданием окна, связанного с объектом класса. MFC AppWizard переопределяет этот метод следующим образом:
   BOOL CMultiView::PreCreateWindow(CREATESTRUCT& cs) {
    // TODO:
    return CView::PreCreateWindow(cs);
   }

Метод OnDraw класса CMultiView

   Метод OnDraw первоначально определен в классе CView как виртуальный и вызывается, когда приложение должно перерисовать документ в окне просмотра. MFC AppWizard переопределяет для вас метод OnDraw класса CView следующим образом:
   void CMultiView::OnDraw(CDC* pDC) {
    CMultiDoc* pDoc = GetDocument();
    ASSERT_VALID(pDoc);
    // TODO:
   }
   Первые две строки метода OnDraw получают указатель pDoc на документ, связанный с данным окном просмотра.

Методы класса CMultiView, предназначенные для печати

   Виртуальные методы OnPreparePrinting, OnBeginPrinting и OnEndPrinting, определенные в классе CView, вызываются, если пользователь желает распечатать документ, отображенный в данном окне просмотра:
   //////////////////////////////////////////////////////////////
   // Методы класса CMultiView, управляющие печатью документов
   BOOL CMultiView::OnPreparePrinting(CPrintInfo* pInfo) {
    return DoPreparePrinting(pInfo);
   }
 
   void CMultiView::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/) {
    // TODO:
   }
 
   void CMultiView::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/) {
    // TODO:
   }
   Многооконное приложение, подготовленное MFC AppWizard, уже “умеет” выводить созданные в нем документы на печатающее устройство. Методы OnPreparePrinting, OnBeginPrinting и OnEndPrinting класса CView предназначены для расширения возможностей печати и в этой книге не рассматриваются.

Методы AssertValid и Dump класса CMainFrame

   Методы AssertValid и Dump переопределяются в классе CMainFrame только для отладочной версии приложения и используются при отладке приложения:
   #ifdef _DEBUG
   void CMultiView::AssertValid() const {
    CView::AssertValid();
   }
 
   void CMultiView::Dump(CDumpContext& dc) const {
    CView::Dump(dc);
   }
   #endif //_DEBUG

   Процесс обработки командных сообщений значительно отличается от обработки других сообщений. Обычные сообщения обрабатываются тем объектом, которому они поступили. Если таблица сообщений класса объекта не содержит обработчика сообщения, будут просмотрены таблицы сообщений его базовых классов. В том случае, если ни один из базовых классов также не содержит обработчик сообщения, выполняется обработка сообщения по умолчанию.
   Судьба командных сообщений гораздо сложнее. Командное сообщение, переданное для обработки объекту приложения, может последовательно передаваться другим объектам приложения. Один из объектов, класс (или базовый класс) которого содержит обработчик этого сообщения, выполняет его обработку. Так, например, командное сообщение, переданное главному окну приложения, в конечном счете может быть обработано активным окном просмотра.
   Существует стандартная последовательность объектов приложения, которым передаются командные сообщения. Каждый объект в этой последовательности может обработать командное сообщение, если в его таблице сообщений или таблице сообщений базовых классов есть соответствующая макрокоманда. Необработанные сообщения передаются дальше, другим объектам приложения.
   Объекты различных классов обрабатывают командные сообщения по-разному. Например, объекты, представляющие главное окно приложения, сначала предоставляют возможность обработать полученное сообщение другим объектам, в том числе активному окну просмотра и соответствующему ему документу. Только если сообщение остается необработанным, просматривается таблица сообщений класса главного окна приложения. Если и здесь сообщение не обрабатывается, оно направляется другим объектам приложения.
   Подавляющее большинство приложений, созданных на основе MFC, использует ряд стандартных командных сообщений, как правило соответствующих элементам меню или кнопкам панели управления. К ним относятся командные сообщения для завершения работы приложения, создания нового документа, открытия документа, записанного на диске, сохранения документа на диске, вызова справочной системы, управления текстовым редактором и т. д. За каждым таким командным сообщением зарезервирован отдельный идентификатор.
   MFC обеспечивает различный уровень обработки стандартных командных сообщений, начиная от простого резервирования идентификатора и кончая полной его обработкой. Информацию об использовании стандартных командных сообщений вы можете получить в документации Microsoft Visual C++. Мы также рекомендуем вам изучить реализацию обработчиков стандартных командных сообщений непосредственно в исходных текстах библиотеки MFC.
   В некоторых случаях вам может понадобиться изменить порядок, в котором сообщения передаются для обработки объектам приложения. В этом случае вы должны переопределить виртуальный методом OnCmdMsg. Этот метод первоначально определен в классе CCmdTarget и переопределен в классах CView и CDocument .
   Ниже описаны последовательности обработки командных сообщений объектами различных классов.

   Большинство командных сообщений передаются главному окну приложения. Если приложение имеет многооконный интерфейс, то главное окно приложения представляет объект класса CMDIFrameWnd или класса, наследованного от базового класса CMDIFrameWnd.
   Получив сообщение, главное окно приложения сначала предоставляет возможность обработать сообщение активному дочернему окну MDI. Окна MDI представляют собой объекты класса CMDIChildWnd или класса наследованного от него.
   Только если окно MDI не может обработать сообщение, будет просмотрена таблица сообщений класса главного окна приложения. Следует сразу заметить, что в свою очередь, окно MDI передает сообщения другим объектам (см. ниже).
   Если главное окно приложения не может обработать сообщение, оно передается объекту главного класса приложения. Напомним, что главный класс приложения наследуется от базового класса CWinApp и приложение имеет только один объект этого класса.

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

   В отличие от объектов, представляющих окна типа frame (объекты классов CMDIFrameWnd, CFrameWnd и CMDIChildWnd) окно просмотра в первую очередь проверяет собственную таблицу сообщений. И только в том случае, если командное сообщение не может быть обработано, оно передается документу, связанному с данным окном просмотра.

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

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

   Доработаем приложение Multi так, чтобы оно обладало возможностями приложения Single, описанного в томе 24 серии “Библиотека системного программиста”. Приложение Single представляет собой простейший графический редактор, в котором можно рисовать изображения, содержащие маленькие квадраты, а также сохранять эти рисунки в файлах на диске.
   Добавьте в определение класса CMultiDoc новый элемент pointFigCenter, который будет хранить графический документ. Как и в приложении Single, этот элемент сделан на основе шаблона CArray. Однако вместо разработанного нами класса CFigure, здесь мы используем стандартный класс CPoint , входящий в состав MFC. Тип фигуры запоминать не надо, так как приложение Multi будет рисовать фигуры только одного типа:
   class CMultiDoc : public CDocument {
 
   // Attributes
   public:
    CArray<CPoint, CPoint&> pointFigCenter;
   Шаблоны классов CArray , CMap и CList определены во включаемом файле afxtempl.h. Так как мы используем класс CArray, добавьте файл afxtempl.h в конце включаемого файла stdafx.h:
   #include <afxtempl.h>
   Добавьте обработчик сообщения от левой кнопки мыши. Для этого лучше всего воспользоваться средствами MFC ClassWizard :
   //////////////////////////////////////////////////////////////
   // CMultiView message handlers
   void CMultiView::OnLButtonDown(UINT nFlags, CPoint point) {
    // TODO:
    // Получаем указатель на документ (объект класса CSingleDoc)
    CMultiDoc* pDoc = GetDocument();
 
    // Проверяем указатель pDoc
    ASSERT_VALID(pDoc);
 
    // Отображаем на экране квадрат
   CClientDC dc(this);
    dc.Rectangle(point.x-10, point.y-10, point.x+10, point.y+10);
 
    // Добавляем к массиву, определяющему документ, новый
    // элемент
    pDoc->pointFigCenter.Add(point);
 
    // Устанавливаем флаг изменения документа
    pDoc->SetModifiedFlag();
 
    // Вызываем метод OnLButtonDown базового класса CView
    CView::OnLButtonDown(nFlags, point);
   }
   Обработчик этого сообщения рисует квадрат. Для отображения квадрата используется метод Rectangle. Первые два параметра этого метода определяют расположение левого верхнего угла параллелепипеда. Третий и четвертый параметры задают размеры по горизонтали и вертикали.
   Затем добавляем к документу новый элемент, определяющий координаты верхнего левого угла квадрата. В данном случае графический документ приложения представляется массивом pointFigCenter, содержащим объекты класса CPoint .
   Так как метод OnLButtonDown изменяет документ, устанавливаем флаг модификации документа, для чего вызываем метод SetModifiedFlag. Затем вызываем метод OnLButtonDown базового класса CView. На этом обработка сообщения завершается.
   Приложение должно отображать документ, когда в окно просмотра поступает сообщение WM_PAINT. Для этого следует изменить метод OnDraw окна просмотра документа. MFC AppWizard определяет шаблон этого метода, вам остается только “наполнить” готовый шаблон.
   Метод OnDraw должен уметь отображать документ в любой момент времени. Так как документ записан в массиве pointFigCenter класса документа, сначала надо определить указатель на документ, а потом последовательно отобразить на экране все его элементы:
   //////////////////////////////////////////////////////////////
   // CMultiView drawing
   void CMultiView::OnDraw(CDC* pDC) {
    CMultiDoc* pDoc = GetDocument();
    ASSERT_VALID(pDoc);
 
    int i;
    for (i=0; i<pDoc->pointFigCenter.GetSize(); i++)
     pDC->Rectangle(pDoc->pointFigCenter[i].x-10, pDoc->pointFigCenter[i].y-10, pDoc->pointFigCenter[i].x+10, pDoc->pointFigCenter[i].y+10);
   }
   Переопределите метод DeleteContents класса CMultiDoc так, чтобы он удалял содержимое документа. Для этого достаточно удалить все элементы массива pointFigCenter, воспользовавшись методом RemoveAll класса CArray. После очистки документа необходимо вызвать метод DeleteContents базового класса CDocument .
   Чтобы вставить в класс CMultiDoc метод DeleteContents используйте MFC ClassWizard, а затем модифицируйте его в соответствии со следующим фрагментом кода:
   //////////////////////////////////////////////////////////////
   // CMultiDoc commands
   void CMultiDoc::DeleteContents() {
    // Очищаем документ, удаляя все элементы массива arrayFig.
    pointFigCenter.RemoveAll( );
 
    // Вызываем метод DeleteContents базового класса CDocument
    CDocument::DeleteContents();
   }
   Теперь, когда документ создан и приложение умеет отображать его на экране, остается доработать приложение, чтобы оно могло сохранять документ в файле на диске и загружать уже существующие документы из файлов. Для этого переопределите метод Serialize класса документа. Шаблон для этого метода уже определен в приложении:
   //////////////////////////////////////////////////////////////
   // CMultiDoc serialization
   void CMultiDoc::Serialize(CArchive& ar) {
    pointFigCenter.Serialize(ar);
   }
   Постройте измененное приложение и запустите полученный выполнимый файл. У вас получился настоящий многооконный графический редактор. Вы можете одновременно открыть несколько окон с документами. Каждый документ можно сохранить в отдельном файле на диске и загрузить при следующем запуске приложения.

   Как правило, многооконные приложения позволяют открыть для одного документа несколько окон просмотра. Наше приложение тоже не составляет исключения. Чтобы открыть дополнительное окно для просмотра уже открытого документа, выберите из меню Window строку New.
   Откроется новое окно. Заголовки окон просмотра одного документа будут одинаковыми за исключением того, что каждое такое окно имеет дополнительный числовой идентификатор, означающий номер окна. На рисунке 1.14 мы показали как будет выглядеть приложение Multi, если в нем создать два новых документа Multi1 и Multi2, а затем открыть два дополнительных окна для просмотра документа Multi2.
   Рис. 1.14. Окно Project Workspace, класс CMultiView
 
   К сожалению, окна просмотра документа несогласованны. Если вы внесете в документ изменения через одно окно, они не появятся во втором до тех пор, пока содержимое окна не будет перерисовано. Чтобы избежать рассогласования между окнами просмотра одного и того же документа, необходимо сразу после изменения документа в одном окне вызвать метод UpdateAllViews, определенный в классе CDocument:
   void UpdateAllViews(CView* pSender, LPARAM lHint = 0L, CObject* pHint = NULL);
   Метод UpdateAllViews вызывает метод CView::OnUpdate для всех окон просмотра данного документа, за исключением окна просмотра, указанного параметром pSender. Как правило, в качестве pSender используют указатель того окна просмотра через который был изменен документ. Его состояние изменять не надо, так как оно отображает последние изменения в документе.
   Если изменение документа вызвано другими причинами, не связанными с окнами просмотра, в качестве параметра pSender можно указать значение NULL. В этом случае будут вызваны методы OnUpdate всех окон просмотра без исключения.
   Параметры lHint и pHint могут содержать дополнительную информацию об изменении документа. Методы OnUpdate получают значения lHint и pHint и могут использовать их, чтобы сократить перерисовку документа.
   Мы изменяем документ только в методе OnLButtonDown. Поэтому добавьте вызов UpdateAllViews в нем. Разместите его после добавления нового элемента в массив pointFigCenter и установки флага модификации документа (метод UpdateAllViews следует вызывать после метода SetModifiedFlag):
   void CMultiView::OnLButtonDown(UINT nFlags, CPoint point) {
    // …
 
    // Устанавливаем флаг изменения документа
    pDoc->SetModifiedFlag();
 
    // Сообщаем всем окнам просмотра кроме данного об
    // изменении документа
    pDoc->UpdateAllViews(this);
 
    // Вызываем метод OnLButtonDown базового класса CView
    CView::OnLButtonDown(nFlags, point);
   }
   Постройте проект и запустите приложение. Теперь все окна просмотра документа синхронизированы. Когда вы меняете документ в одном окне, автоматически происходит изменения во всех остальных окнах просмотра.
   Вы можете заметить, что при изменении документа содержимое других окон просмотра перерисовывается полностью, несмотря на то что дорисовать надо только одну фигуру. Перерисовка всех объектов может заметно замедлить работу приложения, особенно на слабых компьютерах.
   Выход из этого положения существует. При вызове метода UpdateAllViews можно указать, какой объект надо дорисовать. А потом надо переопределить метод OnUpdate так, чтобы приложение дорисовывало в окнах просмотра одну только новую фигуру. Для передачи информации от метода UpdateAllViews методу OnUpdate используют параметры lHint и pHint.
   Рассмотрим более подробно, как работает метод OnUpdate:
   virtual void OnUpdate(CView* pSender, LPARAM lHint, CObject* pHint);
   Первый параметр pSender содержит указатель на объект класса окна просмотра, который вызвал изменение документа. Если обновляются все окна просмотра, этот параметр содержит значение NULL.
   Второй и третий параметры – lHint и pHint содержат дополнительную. информацию, указанную во время вызова метода UpdateAllViews. Если дополнительная информация не определена, тогда эти параметры содержат значения 0L и NULL соответственно.
   Метод OnUpdate вызывается, когда после изменения документа вызывается метод CDocument::UpdateAllViews. Метод также вызывается методом OnInitialUpdate (если вы не переопределите метод OnInitialUpdate).
   Реализация OnUpdate из класса CView, определяет, что вся внутренняя область окна просмотра подлежит обновлению и передает данному окну сообщение WM_PAINT (для этого вызывается функция InvalidateRect). Это сообщение обрабатывается методом OnDraw.
   Параметр lHint имеет тип LPARAM и может содержать любое 32-битное значение. В нашем случае мы можем передавать через этот параметр индекс элемента массива документа, который надо перерисовать.
   Параметр pHint является указателем на объект типа CObject. Поэтому если вы желаете его использовать, вы должны определить собственный класс, наследованный от базового класса CObject, создать объект этого класса и передать указатель на него методу UpdateAllViews.
   Указатель на объект класса, наследованного от CObject, можно присвоить указателю на объект класса CObject, поэтому такая операция разрешена. Следовательно, через этот указатель можно передавать объекты различных типов, наследованных от CObject.
   Когда вы будете разрабатывать метод OnUpdate, вы должны проверять тип объекта, передаваемого через параметр pHint. Для этого можно воспользоваться методом IsKindOf класса CObject. Метод IsKindOf позволяет узнать тип объекта уже на этапе выполнения приложения.
   В нашем приложении новые фигуры добавляются в документ во время обработки сообщения WM_LBUTTONDOWN методом OnLButtonDown класса окна просмотра. Модифицируем этот метод так, чтобы после изменения документа метод UpdateAllViews передавал остальным окнам просмотра индекс добавленного элемента в массиве pointFigCenter редактируемого документа:
   //////////////////////////////////////////////////////////////
   // Метод для обработки сообщения WM_LBUTTONDOWN
   void CMultiView::OnLButtonDown(UINT nFlags, CPoint point) {
    // …
    // Добавляем к массиву, определяющему документ, новый
    // элемент
    pDoc->pointFigCenter.Add(point);
 
    // Устанавливаем флаг изменения документа
    pDoc->SetModifiedFlag();
 
    // Записываем в переменную nNewFig индекс последнего
    // элемента массива pointFigCenter
    int nNewFig;
    nNewFig = pDoc->pointFigCenter.GetUpperBound();
 
    // Сообщаем всем окнам просмотра кроме данного об
    // изменении документа, указывая индекс нового элемента
    // массива, представляющего документ
    pDoc->UpdateAllViews(this, nNewFig);
 
    // Вызываем метод OnLButtonDown базового класса CView
    CView::OnLButtonDown(nFlags, point);
   }
   Теперь мы должны переопределить метод OnUpdate так, чтобы при вызове через метод UpdateAllViews он отображал на экране только последний элемент массива pointFigCenter.
   Для переопределения метода OnUpdate лучше всего воспользоваться средствами ClassWizard. ClassWizard создаст шаблон метода OnUpdate, который вы должны изменить, добавив операции для отображения новой фигуры в окне просмотра.
   Когда вы переопределяете метод OnUpdate, вы должны иметь в виду, что этот метод вызывается не только методом UpdateAllViews. В некоторых случаях он может быть вызван, если надо перерисовать все изображение в окне просмотра. В этом случае параметр lHint содержит 0, а параметр pHint – NULL Вы должны обрабатывать эту ситуацию отдельно, вызывая метод InvalidateRect и обновляя все окно целиком:
   //////////////////////////////////////////////////////////////
   // CMultiView
   void CMultiView::OnUpdate(CView* pSender, LPARAM lHint, CObject* pHint) {
    // Получаем указатель на документ, относящийся к данному
    // окну просмотра
    CMultiDoc* pDoc = GetDocument();
    ASSERT_VALID(pDoc);
 
    // Если lHint равен нулю, выполняем обработку по умолчанию
    if (lHint==0L) CView::OnUpdate(pSender, lHint, pHint);
 
    // В противном случае отображаем заданный элемент документа
    else {
     // Получаем контекст отображения окна просмотра
     CClientDC dc(this);
 
     // Отображаем фигуру, определенную элементом массива
     // pointFigCenter с индексом lHint
     dc.Rectangle(pDoc->pointFigCenter[lHint].x-10, pDoc->pointFigCenter[lHint].y-10, pDoc->pointFigCenter[lHint].x+10, pDoc->pointFigCenter[lHint].y+10);
    }
   }
   Постройте проект и запустите полученное приложение. Откройте несколько окон просмотра одного документа. Теперь все эти окна синхронизированы. Изменения, вносимые в документ через одно окно просмотра автоматически отображаются в других окнах. При этом обновление происходит быстрее, чем когда мы не использовали возможности метода OnUpdate.
   В нашем примере мы отображаем новый объект непосредственно из метода OnUpdate. Однако лучше если метод OnUpdate только укажет методу OnDraw область окна просмотра, которую надо перерисовать. Для этого можно воспользоваться методом CWnd::InvalidateRect.

   Некоторые многооконные приложения позволяют одновременно работать с документами различных типов. Примером такого приложения является сама среда разработки Visual C++. В ней вы одновременно можете открыть окно редактирования исходного текста приложения и редактор ресурсов. Большинство систем управления базами данных также позволяют работать с документами различных типов. Так FoxPro и Access позволяют в одном окне просматривать поля базы данных, а в другом разрабатывать диалоговую форму для отображения информации из этой базы данных.
   Ранее мы уже научились создавать приложения, которые могут отображать графические объекты (окружности, прямоугольники и т. д.) и текстовую информацию. Теперь мы приступим к разработке наиболее сложного приложения, которое может одновременно работать с документами двух различных типов – графическими и текстовыми.
   Для упрощения возьмите уже готовое многооконное приложение, которое уже может работать с простейшими графическими документами – Multi.

   Создайте два новых класса – класс документа и класс окна отображения для хранения и отображения на экране текстовой информации. Для создания новых классов используйте MFC ClassWizard .
   Сначала откройте панель ClassWizard и нажмите кнопку Add Class. Откроется новая диалоговая панель Create New Class. Введите в поле Name имя нового класса – CEditorDoc, а в поле Base Class выберите имя базового класса CDocument. Нажмите кнопку Create. ClassWizard создаст класс CEditorDoc, определение которого он разместит в файле CEditorDoc.h, а реализацию методов класса в файле CEditorDoc.cpp.
   Не закрывая ClassWizard, создайте класс окна просмотра текстового документа. Нажмите кнопку Add Class. В поле Name диалоговой панели Create New Class введите имя класса окна просмотра CEditorView, а в поле Base Class выберите имя его базового класса CEditView. Нажмите кнопку Create. ClassWizard создаст класс CEditorView, определение которого он разместит в файле CEditorView.h, а реализацию методов класса в файле CEditorView.cpp.
   Теперь вы можете определить, как записывать и считывать текстовый документ из файла на диске. Когда ClassWizard создает для вас класс документа, наследованный от базового класса CDocument, он сразу создает шаблон метода Serialize. К сожалению, этот шаблон придется переделать.
   Мы уже изучали класс CEditView в предыдущей книге, посвященной MFC, и вы должны знать, что объекты этого класса сами хранят данные редактируемого документа. Поэтому для записи и чтения документа метод Serialize класса документа должен вызвать соответствующий метод класса окна просмотра. Измените метод Serialize следующим образом:
   //////////////////////////////////////////////////////////////
   // Метод класса Serialize CEditorDoc
 
   void CEditorDoc::Serialize(CArchive& ar) {
    ((CEditView*)m_viewList.GetHead())->SerializeRaw(ar);
   }
   На этом реализация классов для хранения и отображения текстового документа закончена и можно перейти к самому интересному – к созданию шаблона нового документа.

   Шаблоны документов, с которыми работает приложение определяют все характеристики данного типа документа. Они включают информацию о классе документа, классе окна просмотра, классе окна рамки, а также о ресурсах, связанных с данным типом документов.
   Шаблоны документов создаются объектом приложения во время его инициализации. Откройте метод InitInstance главного класса приложения CMultiApp. В нем создается только один объект класса CMultiDocTemplate, который представляет графический документ и средства для работы с ним.
   Так как наше приложение должно работать не только с графическими, но и с текстовыми документами, вы должны создать еще один объект шаблона документов, представляющий текстовый документ. Класс текстового документа называется CEditorDoc, класс окна для его просмотра CEditorView. В качестве окна рамки мы используем класс CChildFrame. Ниже представлен соответствующий фрагмент метода InitInstance:
   //////////////////////////////////////////////////////////////
   // CMultiApp initialization
 
   BOOL CMultiApp::InitInstance() {
    // ...
    // Регистрируем шаблоны документов приложения
 
    CMultiDocTemplate* pDocTemplate;
    pDocTemplate = new CMultiDocTemplate(IDR_MULTITYPE, RUNTIME_CLASS(CMultiDoc), RUNTIME_CLASS(CChildFrame), RUNTIME_CLASS(CMultiView));
    AddDocTemplate(pDocTemplate);
 
    pDocTemplate = new CMultiDocTemplate(IDR_EDITORTYPE, RUNTIME_CLASS(CEditorDoc), RUNTIME_CLASS(CChildFrame), RUNTIME_CLASS(CEditorView));
    AddDocTemplate(pDocTemplate);
 
    // ...
 
    return TRUE;
   }
   При создании шаблона документов указывается идентификатор, который определяет меню, пиктограмму и некоторую другую полезную информацию, связанную с документами данного типа. Мы указали для шаблона текстового документа идентификатор IDR_EDITORTYPE. Здесь мы несколько забежали вперед, так как такой идентификатор еще не определен. Мы вернемся к ресурсам текстового документа в следующем разделе.
   Чтобы созданный шаблон текстовых документов добавить к списку шаблонов документов приложения, надо вызвать метод AddDocTemplate, указав ему адрес объекта шаблона.

   Откройте редактор ресурсов приложения. Вам требуется создать меню, пиктограмму и строковый ресурс с идентификатором IDR_EDITORTYPE. Самый простой путь для этого заключается в копировании и изменении идентификатора ресурсов, относящихся к графическим документам. Идентификатор этих ресурсов IDR_MULTITYPE. Чтобы скопировать ресурс, вы можете выбрать интересующий вас ресурс из окна проекта, записать его в обменный буфер clipboard, вставить его, а затем изменить идентификатор на IDR_EDITORTYPE.
   На первом этапе разработки приложения скопированные меню и пиктограмму вы можете оставить без изменения. Потом вы можете изменить их по своему усмотрению.
   Строковый ресурс IDR_EDITORTYPE, описывающий документ, желательно изменить сразу. Для графического документа строковый ресурс IDR_MULTITYPE выглядит следующим образом:
   \nGraph\nGraph\nGraph Files (*.LIS)\n.LIS\nGraph.Document\nGraph Document
   Чтобы текстовый документ имел другое название типа документа, расширение файлов принятое по умолчанию, измените строковый ресурс с идентификатором IDR_EDITORTYPE:
   \nText\nTexti\nTexti Files (*.TXT)\n.TXT\nText.Document\nText Document

   Все, приложение готово. Постройте проект и запустите полученный выполняемый файл. На экране появится диалоговая панель New, представленная на рисунке 1.15.
   Рис. 1.15. Выбор типа нового документа
 
   В списке New этой панели перечислены типы документов, с которыми работает приложение. Так как наше приложение работает с документами двух типов – текстовыми и графическими, то этот список содержит всего два элемента. Если в последствии вы добавите к приложению новые типы документов, их названия также появятся в этой панели.
   Выберите из списка тип документа, который вы будете создавать и нажмите на кнопку OK. Откроется главное окно приложения и окно MDI с новым документом выбранного типа.
   Когда вы будете создавать новые документы через меню (строка New меню File), или панель управления (кнопка ), вам будет предложено выбрать тип нового документа. Для этого также будет использоваться диалоговая панель New, описанная выше.
   Одновременно можно открыть несколько документов различного типа, причем каждый документ может иметь несколько окон просмотра. Документы каждого типа имеют различные названия и расширения имени файлов, используемые по умолчанию.

   Среда Microsoft Visual C++ предусматривает дополнительные возможности для повторного использования программного кода при создании новых программ. Для этого предназначена так называемая галерея компонентов – Component Gallery.
   Component Gallery служит вместилищем для компонентов. В качестве компонентов выступают классы (возможно вместе с необходимыми ресурсами), органы управления ActiveX (OCX), а также сложные компоненты. Компоненты Component Gallery можно включать в ваше приложение и использовать по своему усмотрению.
   При добавлении к проекту некоторых компонент в проект добавляются не только новые классы, но также новые ресурсы. В ряде случаев даже выполняется изменение исходных текстов самого приложения.

   Процедура использования Component Gallery для добавления разрабатываемому приложению новых возможностей предельно проста. Выберите из меню Insert строку Component. На экране появится диалоговая панель Component Gallery (рис. 2.1).
   Она состоит из нескольких страниц, в которых отображаются различные пиктограммы. Именно эти пиктограммы и представляют компоненты, которые вы можете добавить к вашему приложению.
   Количество страниц Component Gallery и набор компонент зависит от версии Visual C++ и постоянно расширяется. В Component Gallery можно включить компоненты, разработанные другими фирмами, например Blue Sky Software, VideoSoft. Более того, вы можете включить в Component Gallery собственные компоненты, разработанные вами. В простейшем случае, в качестве таких компонент могут выступать классы приложений, которые вы создали.
   Рис. 2.1. Диалоговая панель Component Gallery

   Сразу после установки среды Microsoft Visual C++ в диалоговой панели Component Gallery отображается две станицы, содержащие компоненты – Microsoft и OLE Controls. Каждая страница представляет разные категории компонентов.
   В диалоговой панели Component Gallery вы можете создавать и удалять страницы с компонентами, добавлять и удалять компоненты, перемещать их между категориями, переименовывать и выполнять над ними другие простые действия.
   Для управления страницами компонентов и отдельными компонентами достаточно нажать кнопку Customize. Вы сможете выполнить все настройки в открывшейся диалоговой панели Customize Component Gallery.
   Вся информация о компонентах и страницах Component Gallery записана в специальной базе данных. Эта база данных расположена в файле gallery.dat, в каталоге Msdev\Template. Если вы случайно удалили нужные компоненты с панели Component Gallery, вы можете восстановить их. Для этого надо удалить файл gallery.dat. Во время очередного запуска Microsoft Visual C++ заново создаст файл gallery.dat и восстановит все компоненты, поставляемые с Visual C++.

   На странице Microsoft диалоговой панели Component Gallery расположены компоненты, разработанные фирмой Microsoft. Среди них содержатся много интересных компонент, добавляющих к вашему приложению различные возможности практически без дополнительных затрат с вашей стороны. Среди них компонент, позволяющий приложениям использовать обменный буфер Windows Clipboard, компонент, выполняющий фоновые работы во время бездействия приложения, компонент, содержащий готовые диалоговые панели для ввода пароля и отображения хода различных процессов и многое многое другое.
   Чтобы получить полные описания каждого компонента, достаточно выбрать его в панели Component Gallery и нажать на кнопку с вопросительным знаком. Сейчас мы кратко опишем назначение компонент Microsoft, а затем рассмотрим использование одной из компонент на примере.
   Пиктограмма Назначение соответствующего компонента
    Предназначен для использования со средствами автоматизированной разработки проектов – Custom AppWizard
    Компонент добавляет к классам окон просмотра, наследованным от базового класса CView, методы для обработки команд меню Edit, предназначенные для взаимодействия с обменным буфером Clipboard
    Позволяет добавить к окну приложения панель управления, созданную на основе шаблона диалоговой панели
    Компонент выполняет регистрацию всех типов документов приложения. После этого документы приложения могут быть открыты и распечатаны при помощи приложений Windows Explorer или File Manager
    Этот компонент позволяет вам создать уникальный глобальный идентификатор – GUID. Такие идентификаторы используются при создании приложений, работающих с технологией OLE, регистрационной базой Windows и др. Созданный идентификатор записывается в буфер clipboard. Модификация проекта не выполняется, вы должны сами вставить идентификатор в исходный текст приложения
    Добавляет метод OnIdle к любому классу приложения, наследованному от базового класса CWinThread. Обычно в качестве такого класса выступает главный класс приложения. Метод OnIdle позволяет выполнять обработку во время бездействия приложения, когда очередь сообщений приложения пуста
    Компонент обеспечивает поддержку почтового API. Если вы не указали на необходимость работы с MAPI во время создания проекта и желаете, чтобы ваше приложение могло передавать и принимать почтовые сообщения, вставьте в проект этот компонент
    Включает поддержку OLE Automation
    Если во время создания приложения средствами MFC AppWizard вы не указали, что оно может использовать органы управления OCX, используйте этот компонент
    Компонент можно использовать для создания собственных органов управления, представляющих список или список с окном редактирования
    Используйте данный компонент, если ваше приложение должно работать с цветовыми палитрами
    Компонент добавляет к проекту диалоговую панель для ввода пароля и вызывает ее перед стартом приложения. Таким образом можно заблокировать несанкционированный доступ к вашему приложению
    Позволяет добавить к окнам вашего приложения временное (контекстное) меню, которое открывается при нажатии на правую кнопку мыши
    Компонент представляет из себя диалоговую панель, содержащую линейный индикатор. Используйте данную панель для отображения хода различных процессов
    Компонент позволяет добавить к приложению блокнот Property Sheet (диалоговую панель с несколькими страницами) или ряд панелей выбора свойств Wizard
    Данный компонент позволяет в момент запуска приложения отображать на экране рисунок
    Используйте компонент для разделения окна на несколько отдельных частей
    Компонент позволяет добавить к панели состояния главного окна приложения индикаторы для вывода текущей даты и времени
    Компонент добавляет к диалоговой панели About приложения сведения о ресурсах системы
    Если вы добавите этот компонент, то сразу после запуска приложения отображается диалоговая панель с различными короткими замечаниями
    Компонент позволяет реализовать краткие подсказки (органы управления Tool Tips) для диалоговых панелей приложения
    Используйте этот компонент при создании мультимедийных приложений. После включения компонента в проект вы можете обращаться к программному интерфейсу мультимедиа
    Компонент обеспечивает работу с сокетами Windows, что позволяет ему взаимодействовать с другими приложениями по протоколу TCP/IP. Если вы не указали во время создания проекта, что приложение будет использовать сокеты, вы можете добавить в проект этот компонент
   Как видите, некоторые компоненты, расположенные на странице Microsoft, дублируют возможности приложения, которыми можно управлять в ходе создания приложения средствами MFC AppWizard . Поэтому если во время начального создания проекта приложения вы не указали, что приложение будет работать с сокетами Windows то вместо кропотливого исправления проекта вручную можно просто добавить в него компонент Windows Sockets.
   Конечно, все возможности, которые предоставляют компоненты Microsoft, легко реализовать самому. Однако зачем тратить драгоценное время, когда уже есть готовое решение.

   Для добавления к вашему проекту новой компоненты, выберите соответствующую пиктограмму и нажмите кнопку Insert. Дальнейший процесс вставки компонента зависит от него самого. Наиболее общий сценарий выглядит следующим образом. Когда вы нажмете кнопку Insert, у вас запрашивается различная дополнительная информация о том, что вы желаете получить. Это могут быть какие-либо характеристики компонента, названия классов, файлов и т. д. Когда вы введете всю необходимую информацию, начнется модификация проекта. На этом этапе в проект могут быть добавлены новые ресурсы и классы, а в исходные тексты приложения могут быть автоматически внесены исправления.
   Сейчас мы расскажем об использовании компонент Microsoft на примере компоненты Splash Screen. Далее, когда мы будем рассказывать о меню, панелях управления и панелях состояния мы также будем делать ссылки на Component Gallry.

   Многие приложения Windows при запуске отображают на экране временную заставку. В ней, как правило, на фоне рисунка представлены название приложения, номер версии, другая справочная информация. Примером таких приложений могут служить Microsoft Word, Microsoft Excel и другие офисные приложения Microsoft. Microsoft Visual C++ также отображает заставку во время запуска.
   С помощью Component Gallry и компонента Splash Screen вы затратите всего нескольких минут, чтобы добавить к приложению заставку.
   Откройте проект приложения к которому надо добавить заставку. Выберите на панели Component Gallry из страницы Microsoft, пиктограмму Splash Screen. Затем нажмите кнопку Insert.
   На экране появится диалоговая панель Splash Screen (рис. 2.2). В ней вы должны указать ряд характеристик. В поле Class Name отображается имя класса CSplashWnd, который будет отвечать за отображение заставки. Вы можете изменить это имя по своему усмотрению или оставить его без изменения. Во втором поле диалоговой панели - Bitmap resource ID отображается идентификатор изображения bitmap, который будет служить заставкой для приложения. По умолчанию в качестве идентификатора предлагается использовать изображение bitmap с идентификатором IDB_SPLASH.
 
   Рис. 2.2. Диалоговая панель Splash Screen
 
   Компонент Splash Screen добавит к вашему приложению заготовку изображения bitmap с идентификатором IDB_SPLASH. Поэтому вам останется только отредактировать ее на свой вкус. Мы привели уже отредактированное нами изображение IDB_SPLASH на рисунке 2.3.
   Рис. 2.3. Изображение IDB_SPLASH
 
   Определение класса CSplashWnd, управляющего окном заставки, и его методы записываются в файлы с именами Splash.cpp и Splash.h. Эти файлы будут размещены в каталоге вместе с остальными исходными файлами приложения. Если вам надо изменить названия данных файлов, нажмите на кнопку Change.
   Когда вы заполните диалоговую панель Splash Screen, нажмите на кнопку OK. Начнется процесс встраивания компонента в проект. После его завершения закройте диалоговую панель Component Gallry, для чего нажмите на кнопку Close.
   Вы можете сразу встроить в проект несколько различных компонент. Однако, на наш взгляд, после встраивания очередного компонента стоит, как минимум, перестроить проект и убедиться в его работоспособности.

   Откройте окно просмотра проекта Project Workspace и обратите внимание на произошедшие в нем изменения. На странице ClassView появился новый класс CSplashWnd, включающий несколько методов и элементов данных. В главном классе приложения появился новый метод PreTranslateMessage.
   На странице ResourceView к ресурсам приложения добавился ресурс Bitmap с идентификатором IDB_SPLASH. На странице FileView также произошли изменения. В ней добавился файл Splash.cpp, а в папке зависимых файлов Dependencies появились имена файлов Splash.h и Splash16.bmp.
   Число 16 на конце имени файла Splash16.bmp означает, что в изображении используется шестнадцать цветов. К сожалению, компонент Splash Screen не работает с изображениями, имеющими большее количество цветов.
   Кроме перечисленных изменений, хорошо заметных из окна просмотра проекта Project Workspace, имеют место и изменения в существующих методах главного класса приложения. Такие изменения обнаружить значительно труднее, особенно если программный код приложения слишком велик и данный компонент не имеет полной документации.
   Для облегчения поиска фрагментов измененного кода они обозначаются специальными комментариями следующего вида:
   // CG:
   Символы CG являются сокращением от Component Gallry. После символов CG: как правило следует словесное описание добавленного программного кода. Так как Microsoft Visual C++ не умеет вставлять в текст программы русскоязычные комментарии, мы полностью заменили текст комментариев и добавили собственное описание программного кода компоненты Splash Screen.

Метод InitInstance класса CMultiApp

   Чтобы изучить измененный программный код, просмотрите метод InitInstance класса CMultiApp. Мы не стали приводить здесь первоначальный вид метода InitInstance класса CMultiApp, так как во первых, он уже был нами описан ранее в разделе “Приложение Multi”, а во вторых, изменения в методе InitInstance заключаются в добавлении единственного блока следующего за комментарием CG.
   В этом боле CG: сначала выполняется обработка командной строки приложения. Для этого используются метод ParseCommandLine, уже описанный ранее.
   Он записывает обработанную строку приложения в объект cmdInfo класса CCommandLineInfo. Для нас важно, если в командной строке приложения не указано имени файла, в элемент m_bShowSplash объекта cmdInfo записывается значение TRUE, а если указано — FALSE.
   Затем выполняется вызов метода EnableSplashScreen класса CSplashWnd. В качестве параметра ему передается элемент m_bShowSplash объекта cmdInfo. Он определяет, надо ли при запуске приложения показывать заставку. Если m_bShowSplash содержит значение TRUE, заставка показывается, если FALSE — нет.
   На этом блок CG:, добавленный компонентом Splash Screen, завершается. Далее идет уже знакомый вам текст метода InitInstance. Его описание вы найдете в разделе “Приложение Multi”:
   BOOL CMultiApp::InitInstance() {
    // CG: Следующий блок добавлен при вставке в проект
    // компонента Splash Screen
    {
     // Выполняем стандартную обработку командной строки
     // приложения
     CCommandLineInfo cmdInfo;
     ParseCommandLine(cmdInfo);
 
     CSplashWnd::EnableSplashScreen(cmdInfo.m_bShowSplash);
    }
 
   #ifdef _AFXDLL
    Enable3dControls();
   #else
    Enable3dControlsStatic();
   #endif
 
    // Загружаем файл конфигурации
    LoadStdProfileSettings();
 
    // Создаем шаблон документа
    CSingleDocTemplate* pDocTemplate;
    pDocTemplate = new CSingleDocTemplate(IDR_MAINFRAME, RUNTIME_CLASS(CMultiDoc), RUNTIME_CLASS(CMainFrame), RUNTIME_CLASS(CMultiView));
 
    // Регистрируем шаблон документа
    AddDocTemplate(pDocTemplate);
 
    // Выполняем стандартную обработку командной строки
    // приложения
    CCommandLineInfo cmdInfo;
    ParseCommandLine(cmdInfo);
 
    // Обрабатываем командную строку приложения
    if (!ProcessShellCommand(cmdInfo)) return FALSE;
 
    return TRUE;
   }

Метод PreTranslateMessage класса CMultiApp

   Виртуальный метод PreTranslateMessage , переопределенный в главном классе приложения CMultiApp, первоначально определен в базовом классе CWinApp. Метод PreTranslateMessage вызывается из цикла обработки сообщений перед тем как очередное сообщение будет распределено по назначению при помощи функций TranslateMessage и DispatchMessage. В качестве параметра pMsg, передается указатель на структуру типа MSG, которая представляет очередное сообщение, полученное в цикле обработки сообщений из очереди:
   virtual BOOL PreTranslateMessage(MSG* pMsg);
   Таким образом метод PreTranslateMessage позволяет выполнить дополнительную обработку сообщений или даже полностью изъять их из обработки (отфильтровать).
   Переопределив метод PreTranslateMessage вы должны возвращать нулевое значение, если данное сообщение должно быть обработано обычным образом или ненулевое значение, если метод PreTranslateMessage сам выполняет обработку сообщения и оно не должно передаваться приложению для дальнейшей обработки.
   Во время вставки в проект компонента Splash Screen в метод PreTranslateMessage главного класса приложения добавляется вызов метода PreTranslateAppMessage класса CSplashWnd.
   Если метод PreTranslateAppMessage класса CSplashWnd возвращает значение TRUE, тогда метод PreTranslateAppMessage класса CMultiApp также сразу завершается и возвращает значение TRUE. Сообщения, обработанные классом CSplashWnd более не передаются приложению для дальнейшей обработки.
   Если метод PreTranslateAppMessage класса CSplashWnd возвращает значение FALSE, тогда вызывается метод PreTranslateMessage базового класса CWinApp.
   Заметим, что по умолчанию метод PreTranslateMessage класса CWinApp выполняет некоторую дополнительную обработку сообщений, например выделяет сообщения от клавиатуры, соответствующие комбинациям клавиш, определенным в таблице акселераторов и преобразует их в командные сообщения. Более подробно о таблице акселераторов вы можете прочитать в разделе “Таблица акселераторов” главы “Меню, панели управления и панели состояния”, а также в 13 томе серии “Библиотека системного программиста”:
   BOOL CMultiApp::PreTranslateMessage(MSG* pMsg) {
    // CG: The following lines were added by the Splash Screen
    // component.
    if (CSplashWnd::PreTranslateAppMessage(pMsg)) return TRUE;
 
    return CWinApp::PreTranslateMessage(pMsg);
   }
   В случае, если сообщение передается для обработки методу PreTranslateMessage базового класса CWinApp – CWinApp::PreTranslateMessage, метод PreTranslateMessage класса CMultiApp возвращает результат работы этого метода.

Метод OnCreate класса CMainFrame

   Метод OnCreate создает главное окно приложения и отображает в нем панели управления и состояния. Описание метода OnCreate класса CMainFrame вы можете посмотреть в разделе “Приложение Multi”.
   Во время добавления компонента Splash Screen метод OnCreate класса CMainFrame модифицируется. К нему добавляется вызов метода ShowSplashScreen класса CSplashWnd.
   Метод ShowSplashScreen класса CSplashWnd, который создает и отображает на экране окно заставки, будет описан нами позже:
   int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct) {
    // Вызываем метод OnCreate базового класса
    if (CMDIFrameWnd::OnCreate(lpCreateStruct) == -1) return -1;
 
    // Создаем панель управления toolbar
    if (!m_wndToolBar.Create(this) || !m_wndToolBar.LoadToolBar(IDR_MAINFRAME)) {
     // Ошибка при создании панели управления toolbar
     TRACE0("Failed to create toolbar\n");
     return -1;
    }
 
    // Создаем панель состояния status bar
    if (!m_wndStatusBar.Create(this) || !m_wndStatusBar.SetIndicators(indicators, sizeof(indicators)/sizeof(UINT))) {
     // Ошибка при создании панели состояния status bar
     TRACE0("Failed to create status bar\n");
     return -1;
    }
 
    // TODO: вы можете изменить характеристики панели
    // управления, убрав некоторые флаги CBRS_
    m_wndToolBar.SetBarStyle(m_wndToolBar.GetBarStyle() | CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC);
    // TODO: вы можете запретить перемещение панели управления,
    // если удалите следующие три строки программы
    m_wndToolBar.EnableDocking(CBRS_ALIGN_ANY);
    EnableDocking(CBRS_ALIGN_ANY);
    DockControlBar(&m_wndToolBar);
 
    // CG: The following line was added by the Splash Screen
    // component.
    CSplashWnd::ShowSplashScreen(this);
    return 0;
   }

Класс CSplashWnd

   Практически весь программный код, отвечающий за отображение заставки Splash Screen, содержится в классе CSplashWnd. Этот класс включается в состав проекта и вы можете просмотреть его содержимое в окне проекта Project Workspace на странице ClassView (рис. 2.4).
   Рис. 2.4. Окно Project Workspace, класс CSplashWnd
 
   Определение класса CSplashWnd находится в файле Splash.h. Мы привели его полностью в листинге 2.1.
   Класс CSplashWnd создан на основе базового класса CWnd. Он включает в себя ряд методов и несколько элементов данных. Класс CSplashWnd может обрабатывать сообщения, поэтому для него в  файле Splash.h определена макрокоманда DECLARE_MESSAGE_MAP, а в файле реализации — Splash.cpp — таблица сообщений класса.

Листинг2.1. Файл Splash.h

   // CG: This file was added by the Splash Screen component.
 
   #ifndef _SPLASH_SCRN_
   #define _SPLASH_SCRN_
 
   // Splash.h : header file
   //
 
   //////////////////////////////////////////////////////////////
   //   Splash Screen class
 
   class CSplashWnd : public CWnd {
   // Construction
   protected:
    CSplashWnd();
 
   // Attributes:
   public:
    CBitmap m_bitmap;
 
   // Operations
   public:
    static void EnableSplashScreen(BOOL bEnable = TRUE);
    static void ShowSplashScreen(CWnd* pParentWnd = NULL);
    static void PreTranslateAppMessage(MSG* pMsg);
 
   // Overrides
    // ClassWizard generated virtual function overrides
    //{{AFX_VIRTUAL(CSplashWnd)
    //}}AFX_VIRTUAL
 
   // Implementation
   public:
    ~CSplashWnd();
    virtual void PostNcDestroy();
 
   protected:
    BOOL Create(CWnd* pParentWnd = NULL);
    void HideSplashScreen();
    static BOOL c_bShowSplashWnd;
    static CSplashWnd* c_pSplashWnd;
 
   // Generated message map functions
   protected:
    //{{AFX_MSG(CSplashWnd)
    afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
    afx_msg void OnPaint();
    afx_msg void OnTimer(UINT nIDEvent);
    //}}AFX_MSG
    DECLARE_MESSAGE_MAP()
   };
 
   #endif
   Методы класса CSplashWnd определены в файле реализации – Splash.cpp. Этот файл также добавляется к проекту Multi. Мы привели полный исходный текст этого файла в листинге 2.2.

Листинг2.2. Файл Splash.cpp

   Листинг 2.2. Файл Splash.cpp
   // CG: Файл Splash.cpp добавляется в проект во время вставки
   // компонента Splash Screen и содержит реализацию класса
   // CSplashWnd
 
   #include "stdafx.h"
   #include "resource.h"
 
   #include "Splash.h"
 
   #ifdef _DEBUG
   #define new DEBUG_NEW
   #undef THIS_FILE
   static char BASED_CODE THIS_FILE[] = __FILE__;
   #endif
 
   //////////////////////////////////////////////////////////////
   //   Splash Screen class
 
   BOOL CSplashWnd::c_bShowSplashWnd;
   CSplashWnd* CSplashWnd::c_pSplashWnd;
   CSplashWnd::CSplashWnd() {}
 
   CSplashWnd::~CSplashWnd() {
    // Clear the static window pointer.
    ASSERT(c_pSplashWnd == this);
    c_pSplashWnd = NULL;
   }
 
   BEGIN_MESSAGE_MAP(CSplashWnd, CWnd)
    //{{AFX_MSG_MAP(CSplashWnd)
    ON_WM_CREATE()
    ON_WM_PAINT()
    ON_WM_TIMER()
    //}}AFX_MSG_MAP
   END_MESSAGE_MAP()
 
   void CSplashWnd::EnableSplashScreen(BOOL bEnable /*= TRUE*/) {
    c_bShowSplashWnd = bEnable;
   }
 
   void CSplashWnd::ShowSplashScreen(CWnd* pParentWnd /*= NULL*/) {
    if (!c_bShowSplashWnd || c_pSplashWnd != NULL)      return;
 
    // Allocate a new splash screen, and create the window.
    c_pSplashWnd = new CSplashWnd;
    if (!c_pSplashWnd->Create(pParentWnd)) delete c_pSplashWnd;
    else c_pSplashWnd->UpdateWindow();
   }
 
   BOOL CSplashWnd::PreTranslateAppMessage(MSG* pMsg){
    if (c_pSplashWnd == NULL) return FALSE;
 
    // If we get a keyboard or mouse message, hide the splash
    // screen.
    if (pMsg->message == WM_KEYDOWN || pMsg->message == WM_SYSKEYDOWN || pMsg->message == WM_LBUTTONDOWN || pMsg->message == WM_RBUTTONDOWN || pMsg->message == WM_MBUTTONDOWN || pMsg->message == WM_NCLBUTTONDOWN || pMsg->message == WM_NCRBUTTONDOWN || pMsg->message == WM_NCMBUTTONDOWN)   {
     c_pSplashWnd->HideSplashScreen();
     return TRUE; // message handled here
    }
 
    return FALSE;   // message not handled
   }
 
   BOOL CSplashWnd::Create(CWnd* pParentWnd /*= NULL*/) {
    if (!m_bitmap.LoadBitmap(IDB_SPLASH)) return FALSE;
 
    BITMAP bm;
    m_bitmap.GetBitmap(&bm);
 
    return CreateEx(0, AfxRegisterWndClass(0, AfxGetApp()->LoadStandardCursor(IDC_ARROW)), NULL, WS_POPUP | WS_VISIBLE, 0, 0, bm.bmWidth, bm.bmHeight, pParentWnd->GetSafeHwnd(), NULL);
   }
 
   void CSplashWnd::HideSplashScreen(){
    // Destroy the window, and update the mainframe.
    DestroyWindow();
    AfxGetMainWnd()->UpdateWindow();
   }
 
   void CSplashWnd::PostNcDestroy(){
    // Free the C++ class.
    delete this;
   }
 
   int CSplashWnd::OnCreate(LPCREATESTRUCT lpCreateStruct) {
    if (CWnd::OnCreate(lpCreateStruct) == -1) return -1;
 
    // Center the window.
    CenterWindow();
 
    // Set a timer to destroy the splash screen.
    SetTimer(1, 750, NULL);
 
    return 0;
   }
 
   void CSplashWnd::OnPaint(){
    CPaintDC dc(this);
 
    CDC dcImage;
    if (!dcImage.CreateCompatibleDC(&dc)) return;
 
    BITMAP bm;
    m_bitmap.GetBitmap(&bm);
 
    // Paint the image.
    CBitmap* pOldBitmap = dcImage.SelectObject(&m_bitmap);
    dc.BitBlt(0, 0, bm.bmWidth, bm.bmHeight, &dcImage, 0, 0, SRCCOPY);
    dcImage.SelectObject(pOldBitmap);
   }
 
   void CSplashWnd::OnTimer(UINT nIDEvent) {
    // Destroy the splash screen window.
    HideSplashScreen();
   }
   Вы всегда можете получить файл Splash.cpp следуя инструкциям в начале раздела “Заставка для приложения”. Теперь опишем отдельные методы класса.

Конструктор и деструктор класса CSplashWnd

   Конструктор класса CSplashWnd не содержит программного кода. Вы можете использовать его как заготовку, если решите расширить возможности компонента Splash Screen.
   Деструктор класса CSplashWnd также не содержит ничего сложного, он используется исключительно для записи в указатель c_pSplashWnd значения NULL:
   c_pSplashWnd = NULL;

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

   Таблица сообщений класса CSplashWnd содержит всего три макрокоманды, которые расположены внутри блока //{{AFX_MSG_MAP и поэтому управляются через ClassWizard:
   BEGIN_MESSAGE_MAP(CSplashWnd, CWnd)
    //{{AFX_MSG_MAP(CSplashWnd)
    ON_WM_CREATE()
    ON_WM_PAINT()
    ON_WM_TIMER()
    //}}AFX_MSG_MAP
   END_MESSAGE_MAP()
   Две макрокоманды таблицы сообщений класса CSplashWnd уже давно вам знакомы. Это макрокоманда ON_WM_CREATE, которая вызывает метод OnCreate во время создания окна заставки (обработка сообщения WM_CREATE), и макрокоманда ON_WM_PAINT, которая вызывает метод OnPaint, когда надо перерисовать окно (обработка сообщения WM_PAINT).
   Таблицы сообщений класса CSplashWnd содержит также ранее не описанную нами макрокоманду ON_WM_TIMER. Эта макрокоманда предназначена для обработки сообщений WM_TIMER от таймера и вызывает метод OnTimer.
   Первоначально метод OnTimer определен в классе CWnd следующим образом. При вызове метода OnTimer для обработки сообщения WM_TIMER параметр nIDEvent содержит идентификатор таймера, вызвавшего это сообщение:
   afx_msg void OnTimer(UINT  nIDEvent);
   Для установки (“запуска”) таймера используется метод SetTimer, также входящий в состав класса CWnd. Мы расскажем об этом методе более подробно, когда будем описывать метод OnCreate класса CSplashWnd, так как именно он устанавливает таймер для отображения заставки.

Метод OnCreate класса CSplashWnd

   Метод OnCreate класса вызывается при создании окна CSplashWnd, когда через таблицу сообщений проходит сообщение WM_CREATE. Реализация метода OnCreate класса CSplashWnd сначала вызывает метод OnCreate базового класса CWnd, который собственно и создает окно:
   if (CWnd::OnCreate(lpCreateStruct) == -1) return -1;
   Далее вызывается метод CenterWindow, который выполняет центровку окна на экране:
   CenterWindow();
   Метод CenterWindow определен в классе CWnd следующим образом:
   void CenterWindow(CWnd* pAlternateOwner = NULL);
   Если вызвать метод CenterWindow без указания параметров, или указать в качестве параметра значение NULL, то дочернее окно будет отцентровано относительно своего родительского окна, а всплывающее окно — относительно его владельца. Воспользовавшись параметром pAlternateOwner, вы можете указать другие окна относительно которых надо выполнить центровку.
   Затем метод OnCreate создает таймер, посылающий окну CSplashWnd сообщения с идентификатором 1 каждые 750 миллисекунд:
   SetTimer(1, 750, NULL);
   Метод SetTimer определен в классе CWnd и имеет три параметра. Параметр nIDEvent задает идентификатор, который будет выступать в качестве идентификатора сообщений WM_TIMER от таймера. Таймер будет вырабатывать сообщения с периодом, приведенным во втором параметре метода — nElapse:
   UINT SetTimer(UINT nIDEvent, UINT nElapse, void (CALLBACK EXPORT* lpfnTimer)(HWND, UINT, UINT, DWORD));
   Если третий параметр lpfnTimer равен NULL, то сообщения от таймера передаются окну для которого вызван метод SetTimer. Именно так используется метод SetTimer компонентом Splash Screen. Все сообщения таймера поступают окну CSplashWnd и обрабатываются в его таблице сообщений.
   В качестве параметра lpfnTimer можно указать имя функции обратного вызова, которая будет обрабатывать сообщения WM_TIMER вместо таблицы сообщений окна. Более подробно об использовании таймера и, в частности, о функции обратного вызова таймера читайте в 11 томе серии “Библиотека системного программиста”.
   Метод SetTimer возвращает в случае успешного создания таймера его идентификатор — ненулевое значение. Если таймер не создан, метод возвращает нулевое значение.

Метод OnPaint класса CSplashWnd

   Метод OnPaint класса CSplashWnd вызывается для обработки сообщений WM_PAINT, когда надо перерисовать изображение в окне. Компонент Splash Screen использует этот метод, чтобы вывести изображение bitmap в окне заставки:
   void CSplashWnd::OnPaint() {
    CPaintDC dc(this);
 
    CDC dcImage;
    if (!dcImage.CreateCompatibleDC(&dc)) return;
 
    BITMAP bm;
    m_bitmap.GetBitmap(&bm);
 
    // Paint the image.
    CBitmap* pOldBitmap = dcImage.SelectObject(&m_bitmap);
    dc.BitBlt(0, 0, bm.bmWidth, bm.bmHeight, &dcImage, 0, 0, SRCCOPY);
    dcImage.SelectObject(pOldBitmap);
   }

Метод OnTimer класса CSplashWnd

   Метод OnTimer класса CSplashWnd вызывается для обработки сообщений от таймера, созданного в методе OnCreate. Этот метод вызывается всего один раз. При обработке первого сообщения от таймера он закрывает окно CSplashWnd и вместе с ним прекращает работу таймер.
   Для того чтобы закрыть окно заставки, используется метод HideSplashScreen, определенный в классе CSplashWnd:
   HideSplashScreen();

Метод EnableSplashScreen класса CSplashWnd

   Метод EnableSplashScreen класса CSplashWnd устанавливает флаг c_bShowSplashWnd, записывая в него значение, переданное через единственный параметр метода — bEnable:
   c_bShowSplashWnd = bEnable;

Метод ShowSplashScreen класса CSplashWnd

   Метод ShowSplashScreen класса CSplashWnd создает и отображает на экране окно заставки. Перед этим он проверяет состояние флага c_bShowSplashWnd и переменной c_pSplashWnd:
   if (!c_bShowSplashWnd || c_pSplashWnd != NULL) return;
   Если флаг c_bShowSplashWnd содержит значение FALSE или объект c_pSplashWnd, представляющий окно заставки уже создан, метод ShowSplashScreen немедленно завершает свою работу.
   Если эти условия не выполняются, метод ShowSplashScreen создает новый объект класса CSplashWnd, который будет представлять окно заставки:
   c_pSplashWnd = new CSplashWnd;
   Затем вызывается метод Create для объекта c_pSplashWnd (он, кстати, переопределен в классе CSplashWnd), который и выполняет фактическое создание окна заставки:
   if (!c_pSplashWnd->Create(pParentWnd)) delete c_pSplashWnd;
   else c_pSplashWnd->UpdateWindow();
   Если окно заставки не создано, метод Create возвращает нулевое значение и объект c_pSplashWnd удаляется. Если создание окна прошло успешно, для c_pSplashWnd вызывается метод UpdateWindow, вызывающий перерисовку окна. Такая перерисовка выполняется с помощью метода OnPaint класса CSplashWnd.

Метод PreTranslateAppMessage класса CSplashWnd

   Класс CSplashWnd имеет свою таблицу сообщений. Так как в классе CSplashWnd переопределен метод PreTranslateAppMessage, то он вызывается для каждого сообщения, поступающего в это окно перед его обработкой.
   В самом начале метод PreTranslateAppMessage проверяет, существует ли окно заставки. Если нет, то дополнительная обработка сообщений не выполняется:
   if (c_pSplashWnd == NULL) return FALSE;
   Когда окно заставки уже создано, метод PreTranslateAppMessage определяет тип сообщения. Если сообщение поступило от мыши или клавиатуры, то для окна заставки, представленного объектом c_pSplashWnd, вызывается метод HideSplashScreen, который его закрывает не дожидаясь первого сообщения от таймера. Метод PreTranslateAppMessage в этом случае возвращает значение TRUE и обработка сообщения завершается:
   if (pMsg->message == WM_KEYDOWN || pMsg->message == WM_SYSKEYDOWN || pMsg->message == WM_LBUTTONDOWN || pMsg->message == WM_RBUTTONDOWN || pMsg->message == WM_MBUTTONDOWN || pMsg->message == WM_NCLBUTTONDOWN || pMsg->message == WM_NCRBUTTONDOWN || pMsg->message == WM_NCMBUTTONDOWN) {
    c_pSplashWnd->HideSplashScreen();
    return TRUE; // message handled here
   }
   Если поступило какое-либо другое сообщение, метод PreTranslateAppMessage возвращает значение FALSE и оно передается далее для дальнейшей обработки:
   return FALSE;

Метод Create класса CSplashWnd

   В классе CSplashWnd компонент Splash Screen переопределяет виртуальный метод Create базового класса CWnd:
   BOOL CSplashWnd::Create(CWnd* pParentWnd /*= NULL*/) {
    /// …
   }
   Класс CSplashWnd добаляет к этому методу программный код, который загружает ресурс изображения IDB_SPLASH. Для этого используется метод LoadBitmap:
   if (!m_bitmap.LoadBitmap(IDB_SPLASH)) return FALSE;
   При помощи метода GetBitmap для объекта, представляющего изображения bitmap, определяются различные характеристики этого изображения, которые записываются в объект bm структуры BITMAP:
   BITMAP bm;
   m_bitmap.GetBitmap(&bm);
   Последний оператор, завершающий метод Create, вызывает метод CreateEx, который и создает окно заставки:
   return CreateEx(0, AfxRegisterWndClass(0, AfxGetApp()->LoadStandardCursor(IDC_ARROW)), NULL,  WS_POPUP | WS_VISIBLE, 0, 0, bm.bmWidth, bm.bmHeight, pParentWnd->GetSafeHwnd(), NULL);
   Метод CreateEx определен в классе CWnd. Первый параметр метода задает дополнительные стили создаваемого окна заставки. Этот параметр содержит нулевое значение. Описание дополнительных стилей вы можете найти в документации Microsoft Visual C++.
   Второй параметр метода CreateEx должен содержать имя класса Windows, на основе которого создается окно. Для этого параметра используется класс, зарегистрированный функцией AfxRegisterWndClass.
   Третий параметр метода CreateEx определяет текст заголовка создаваемого окна. Так как для окна заставки заголовок не нужен, то в качестве этого параметра передается значение NULL.
   В четвертом параметре должны быть указаны основные стили создаваемого окна. Мы используем в качестве этого параметра комбинацию флагов WS_POPUP и WS_VISIBLE. Эти флаги означают, что создается временное окно, которое сразу отображается на экране. Дополнительную информацию об основных и дополнительных стилях окон вы можете получить из 11 тома “Библиотеки системного программиста”.
   Пятый, шестой, седьмой и восьмой параметры метода CreateEx определяют начальное положение, а также ширину и высоту окна. Начальное положение окна заставки выбирается по умолчанию — пятый и шестой параметры содержат нулевые значения, а ширина и высота берутся исходя из размеров изображения bitmap.
   Предпоследний, девятый параметр метода определяет родительское окно для окна заставки. В качестве этого параметра используется идентификатор окна (полученный методом CWnd::GetSafeHwnd), указанного параметром pParentWnd метода CSplashWnd::Create. Метод GetSafeHwnd класса CWnd возвращает идентификатор окна, связанного с объектом класса CWnd. Если объект класса CWnd не связан с окном, то метод GetSafeHwnd возвращает значение NULL, и, в этом случае, окно заставки не имеет родительского окна.
   Последний - десятый параметр метода CreateEx, может содержать указатель на дополнительные параметры. В данном вызове метода CreateEx этот параметр не используется.
   Рассмотрим процедуру регистрации класса Windows для окна заставки более подробно. Для выполнения регистрации используется функция AfxRegisterWndClass, которая возвращает текстовую строку с именем зарегистрированного класса:
   LPCTSTR AFXAPI AfxRegisterWndClass(UINT nClassStyle, HCURSOR hCursor = 0, HBRUSH hbrBackground = 0, HICON hIcon = 0);
   Параметр nClassStyle указывает комбинацию стилей, используемых для создаваемого окна. Список стилей вы можете просмотреть в 11 томе “Библиотеки системного программиста” или в документации Microsoft Visual C++. Окна, созданные на основе зарегистрированного класса, будут использовать курсор с идентификатором hCursor, кисть с идентификатором hbrBackground и пиктограмму с идентификатором hIcon.
   В нашем примере для окна заставки регистрируется класс окна, который будет использовать стандартный кусор IDC_ARROW в форме стрелки.

Метод HideSplashScreen класса CSplashWnd

   Метод HideSplashScreen класса CSplashWnd закрывает окно заставки, вызывая метод DestroyWindow, а затем устанавливает флаг обновления для всех окон приложения с помощью метода UpdateWindow:
   DestroyWindow();
   AfxGetMainWnd()->UpdateWindow();

Метод PostNcDestroy класса CSplashWnd

   Метод PostNcDestroy класса CSplashWnd вызывается уже после того как окно заставки закрыто и используется дл того, чтобы удалить объект класса CSplashWnd, представляющий это окно в нашем приложении:
   delete this;

   Самый простой и удобный способ создания меню приложения основан на использовании специального ресурса – шаблона меню. Если вы применяете для создания приложения средства MFC AppWizard, то однооконное приложение по умолчанию будет иметь один ресурс меню, а многооконное два.
   Для создания и изменения меню приложения следует использовать редактор ресурсов Microsoft Visual C++. С помощью него вы разработаете меню буквально за несколько минут.
   Редактор ресурсов позволяет для каждой строки меню определить ее название, идентификатор, текст подсказки, а также некоторые дополнительные характеристики. Но самым ценным является возможность, добавив к меню новые строки, сразу запустить MFC ClassWizard и определить методы приложения, которые будут использоваться для обработки командных сообщений от этих строк меню.
   Чтобы добавить новую строку к меню, достаточно выполнить двойной щелчок левой кнопкой мыши по одному из пустых прямоугольников из точек, которые располагаются в конце главного меню (вы создадите еще одно меню верхнего уровня) и в низу каждого из меню (создается новая строка меню). При этом на экране появится диалоговая панель Menu Item Properties, которую вы должны заполнить (рис. 3.1).
 
   Рис. 3.1. Редактор меню и диалоговая панель Menu Item Properties
 
   Текст, который будет отображаться в строке меню, вы должны ввести в поле Caption. Затем в списке с полем редактирования ID надо выбрать идентификатор для этой строки меню. Если вы не заполните поле ID, редактор ресурсов самостоятельно создаст новый идентификатор на основе имени меню и строки.
   В поле Prompt вы можете ввести текстовую строку, которая будет отображаться при выборе данного элемента меню в панели состояния приложения. Редактор ресурсов Microsoft Visual C++ создаст для введенного текста новый строковый ресурс и запишет его в файл ресурсов приложения, присвоив ему тот же идентификатор, что и меню. Так как строки меню и описывающий их текст, имеют одинаковые идентификаторы, то MFC сможет использовать их вместе. При выборе строки меню, MFC просто загружает строковый ресурс с идентичным идентификатором и отображает его в панели состояния.
   Остальные переключатели диалоговой панели Menu Item Properties задают различные характеристики строк меню, отвечающие в первую очередь за их внешний вид. Изучите их самостоятельно, используя документацию Microsoft Visual C++.
   Также легко можно просмотреть и изменить свойства уже существующих строк меню. Для этого надо выполнить по ним двойной щелчок левой кнопкой мыши. На экране появится уже описанная нами выше диалоговая панель Menu Item Properties, которая уже заполнена текущими параметрами строки меню.

   Как и для других элементов пользовательского интерфейса, для управления меню в состав библиотеки классов MFC включен специальный класс – класс CMenu. Класс CMenu – один из самых незаметных классов библиотеки MFC. Ваше приложение может активно работать с меню, но все же в исходных текстах вы не найдете ни одного объекта этого класса.
   В приложениях, созданных с помощью MFC AppWizard меню создается автоматически вместе с панелью управления и панелью состояния. Для этого достаточно указать при создании шаблона документа общий идентификатор этих ресурсов:
   // Объявляем указатель на шаблон документа
   CSingleDocTemplate* pDocTemplate;
 
   // Создаем шаблон документа
   pDocTemplate = new CSingleDocTemplate(
    IDR_MAINFRAME,                // Идентификатор меню, панели
                                  // управления и пиктограммы
    RUNTIME_CLASS(CSingleDoc),    // Класс документа
    RUNTIME_CLASS(CMainFrame),    // Класс главного окна
    RUNTIME_CLASS(CSingleView));  // Класс окна просмотра
   В случае многооконного приложения дополнительно указываются ресурсы, используемые когда все окна просмотра документов закрыты. Все эти ресурсы имеют один и тот же идентификатор. В примере, представленном ниже, это идентификатор IDRMAINFRAME:
   // Создаем главное окно многооконного приложения
   CMainFrame* pMainFrame = new CMainFrame;
 
   // Загружаем ресурсы с идентификатором IDR_MAINFRAME,
   // в том числе и меню
   if (!pMainFrame->LoadFrame(IDR_MAINFRAME)) return FALSE;
   В приложениях MFC AppWizard, имеющих однооконный или многооконный интерфейс, меню создается и изменяется самой библиотекой MFC. Несмотря на это, вы также можете управлять меню. Самый простой способ заключается в обработке команд обновления от меню. Проблеме использования этих команд мы посвятили раздел “Класс CCmdUI”.
   Даже когда приложение создано без использования средств MFC AppWizard, процедура создания меню остается очень простой и также может не задействовать объекты класса CMenu напрямую.
   В таких приложениях, как правило, создается главное окно на основе класса CFrameWnd. Для этого сначала создается соответствующий объект класса CFrameWnd, а затем вызывается либо метод Create, либо метод LoadFrame, который в свою очередь уже создает само окно вместе с меню.

Метод Create

   Метод Create создает и инициализирует окно, связанное с объектом CFrameWnd. В случае успешного завершения метод Create возвращает ненулевое значение, а в противном случае – ноль:
   BOOL Create(
    LPCTSTR lpszClassName, // Класс окна
    LPCTSTR lpszWindowName, // Имя окна
    DWORD dwStyle = WS_OVERLAPPEDWINDOW, // Тип окна
    const RECT& rect = rectDefault, // Расположение окна
    CWnd* pParentWnd = NULL, // Родительское окно
    LPCTSTR lpszMenuName = NULL, // Меню
    DWORD dwExStyle = 0, // Дополнительные
    // характеристики окна
    CCreateContext* pContext = NULL); // Используется для
                                      // организации механизма
                                      // документ/окно просмотра
   Обязательно надо указать только два первых параметра метода Create. Первый параметр lpszClassName служит для задания класса окна. В качестве него можно также указать значение NULL, тогда по умолчанию будет использован класс, определенный для окон CFrameWnd. Второй параметр lpszWindowName указывает имя окна – оно будет отображаться в заголовке окна.
   Остальные параметры метода необязательные. Если их не указать, будут использованы значения, принятые по умолчанию. Нас, однако, сейчас интересует только параметр lpszMenuName. Через него вы можете указать имя ресурса меню, которое будет создано для данного окна. По умолчанию редактор ресурсов Microsoft Visual C++ присваивает созданным в нем ресурсам, в том числе меню, числовые идентификаторы. Чтобы получить из такого идентификатора значение, совместимое по типу с параметром lpszMenuName, следует использовать макрокоманду MAKEINTRESOURCE.
   Следующий пример показывает, как можно создать окно с меню:
   CMultiMenuWindow::CMultiMenuWindow() {
    // Создаем окно приложения, соответствующее
    // данному объекту класса CMultiMenuWindow
    Create(NULL, "Multi Menu Sample", WS_OVERLAPPEDWINDOW,  rectDefault, NULL, MAKEINTRESOURCE(IDR_MENU));
   }
   Класс CMultiMenuWindow, конструктор которого представлен выше, наследован от базового класса CFrameWnd. Конструктор CMultiMenuWindow создает окно с заголовком Multi Menu Sample. Это окно имеет меню IDR_MENU. Меню с идентификатором IDR_MENU должно быть определено в файле ресурсов приложения.

Метод LoadFrame

   Виртуальный метод LoadFrame позволяет динамически создавать окно, пользуясь информацией из файла ресурсов. В случае успешного завершения метод LoadFrame возвращает ненулевое значение, а в противном случае – ноль:
   virtual BOOL LoadFrame(UINT nIDResource, DWORD dwDefaultStyle = WS_OVERLAPPEDWINDOW|FWS_ADDTOTITLE, CWnd* pParentWnd = NULL, CCreateContext* pContext = NULL);
   Параметры метода LoadFrame практически идентичны параметрам метода Create, описанного ранее. Исключение составляет первый параметр – nIDResource. Он представляет идентификатор, общий для нескольких ресурсов, используемых при создании окна. К таким ресурсам относятся меню (будет использоваться как меню окна), строковый ресурс (заголовок окна), пиктограмма (отображается в случае минимизации окна) и таблица клавиш акселерации (используется для ускоренного выбора строк меню).

   Вы можете создать меню и без использования методов Create или LoadFrame. Для этого вы должны будете создать объект класса CMenu и вызвать для него несколько методов.

Конструктор класса CMenu

   Объект класса CMenu не является меню, он только представляет существующее меню. Вы можете создать объект класса CMenu как локальный, а после использования удалить. На меню это не повлияет:
   {
    CMenu myMenu;
   }

Метод LoadMenu

   После объявления объекта класса CMenu вы можете загрузить меню из ресурсов приложения, воспользовавшись для этой цели методом LoadMenu. В случае успешного завершения метод LoadMenu возвратит ненулевое значение, и нуль в противном случае:
   BOOL LoadMenu(LPCTSTR lpszResourceName);
   BOOL LoadMenu(UINT nIDResource);
   Метод LoadMenu загрузит меню, заданное именем lpszResourceName или идентификатором nIDResource, и свяжет его с соответствующим объектом класса CMenu. Теперь вы можете использовать для управления загруженным меню другие методы класса CMenu.
   После того как меню загружено, его можно “подключить” к окну. Для этого следует воспользоваться методом SetMenu входящим в класс CWnd.

Метод SetMenu класса CWnd

   В качестве параметра pMenu передайте методу SetMenu указатель на объект класса CMenu, представляющий меню. Если вы желаете просто удалить текущее меню, используемое окном, передайте методу SetMenu в качестве параметра значение NULL:
   BOOL SetMenu(CMenu* pMenu);
   В случае успешного завершения операции метод SetMenu вернет ненулевое значение. В противном случае SetMenu вернет ноль.
   После того, как вы установили меню, вызвав метод SetMenu, и до того, как соответствующий объект CMenu будет удален, надо вызвать метод Detach класса CMenu. Этот метод разорвет связь между меню и соответствующим объектом класса CMenu, после чего последний может быть удален:
   HMENU Detach();
   Метод Detach возвращает в случае успешного завершения идентификатор меню, а в случае ошибки – значение NULL.
   Сразу отметим, что если до установки меню окно уже имело меню, надо удалить его, воспользовавшись методом DestroyMenu класса CMenu. Если с меню, подлежащим удалению, не связан объект класса CMenu, вы можете обратиться к методу Attach:
   BOOL Attach(HMENU hMenu);
   Для этого создайте объект класса CMenu, а затем вызовите для него метод Attach, указав в качестве параметра hMenu идентификатор меню. Метод Attach возвращает в случае успешного завершения ненулевое значение, а в случае ошибки – ноль.
   Чтобы определить идентификатор меню известного окна, можно воспользоваться методом GetMenu, определенным в классе CWnd. Этот метод возвращает указатель на объект типа CMenu:
   CMenu* GetMenu() const;
   Вы можете получить из него идентификатор меню, если обратитесь к элементу данных m_hMenu, входящему в класс CMenu. Мы продемонстрируем различные методы создания и управления меню в приложении MultiMenu, а сейчас сделаем несколько замечаний относительно остальных методов класса CMenu.
   Класс CMenu, наследованный от базового класса CObject, содержит все необходимые методы для создания и управления меню. Используя эти методы, вы можете добавлять к меню новые строки, удалять и изменять их. Специальные методы класса CMenu позволяют выделять отдельные строки меню и даже создавать элементы меню, содержащие не только текст но и изображение.

   В MFC реализован специальный механизм для обновления таких объектов интерфейса пользователя как меню, панели управления и панели состояния. Этот механизм предусматривает передачу приложению команд обновления пользовательского интерфейса (update command user interface). Для обработки этих команд предназначена макрокоманда ON_UPDATE_COMMAND_UI, размещаемая в таблице сообщений класса.
   Для каждой строки меню, для каждой кнопки панели управления и для каждого индикатора панели состояния передается отдельное сообщение.
   Когда передаются команды обновления интерфейса пользователя? Многое зависит от самого обновляемого объекта.
   В случае меню, команды обновления передаются в момент, когда пользователь открывает меню. Для каждой строки меню посылается отдельное сообщение.
   Для кнопок панели управления и индикаторов панели состояния команды обновления передаются в период “бездействия” приложения, когда очередь сообщений приложения пуста.

Меню

   В момент, когда пользователь открывает меню, приложению передаются команды обновления. В результате для всех строк меню, для которых в таблице сообщений приложения присутствуют макрокоманды ON_UPDATE_COMMAND_UI, вызываются соответствующие методы-обработчики. Они могут изменить состояние меню — заблокировать отдельные строки меню, выделить их символами • или √.

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

   Если очередь сообщений приложения пуста, вызывается метод OnIdle главного класса приложения. В своем приложении вы можете переопределить метод OnIdle и выполнять с его помощью какую-либо фоновую работу.
   Метод OnIdle определен в классе CWinApp и по умолчанию выполняет обновление пользовательского интерфейса — передает команды обновления для тех кнопок панелей управления и индикаторов панелей состояния, которые имеют в таблице сообщений приложения макрокоманду ON_UPDATE_COMMAND_UI. Макрокоманда ON_UPDATE_COMMAND_UI вызывает методы-обработчики, которые могут изменить состояние кнопок и индикаторов панелей управления и панелей состояния.
   Как правило, ряд строк меню и кнопок панелей управления имеют одинаковые идентификаторы. В этом случае для обработки команд обновления строк меню и кнопок панели управления вызываются одни и те же методы.

Органы диалоговых панелей управления

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

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

   Макрокоманда ON_UPDATE_COMMAND_UI предназначена для использования в таблицах сообщений приложения и имеет следующий формат:
   ON_UPDATE_COMMAND_UI(id, memberFxn)
   Параметр id определяет идентификатор строки меню, кнопки панели управления или индикатора панели состояния, для которых надо обработать команду обновления. Параметр memberFxn задает метод, выполняющий обновление.
   Если один и тот же метод вызывается для обработки различных команд обновления, можно использовать другую макрокоманду — ON_UPDATE_COMMAND_UI_RANGE. Она вызывает метод memberFxn для обработки всех команд обновления, идентификаторы которых находятся в промежутке значений от id1 до id2:
   ON_UPDATE_COMMAND_UI_RANGE(id1, id2, memberFxn)
   Метод — обработчик команд обновления, который вызывается макрокомандами ON_UPDATE_COMMAND_UI и ON_UPDATE_COMMAND_UI_RANGE имеет следующий формат:
   afx_msg void memberFxn(CCmdUI* pCmdUI);
   Имя метода – обработчика обычно формируется из префикса OnUpdate и названия соответствующего объекта интерфейса пользователя – строки меню, кнопки панели управления или индикатора панели состояния.
   В качестве параметра pCmdUI методу передается указатель на объект класса CCmdUI. Этот объект представляет элемент интерфейса пользователя (строку меню, кнопку панели управления…), для которого надо обработать команду обновления. Вызывая методы класса CCmdUI, вы можете легко изменять состояние соответствующего объекта интерфейса пользователя.
   Более подробно самые важные методы класса CCmdUI мы рассмотрим в следующем разделе.

MFC ClassWizard и команды обновления

   Если приложение подготовлено с использованием MFC AppWizard, то наилучшим способом создания обработчиков команд обновления является использование средств ClassWizard. Процедура создания обработчиков команд обновления от строк меню и кнопок панелей управления практически не отличается от процедуры создания обычных обработчиков командных сообщений.
   Запустите ClassWizard. На экране появится диалоговая панель MFC ClassWizard. Выберите из нее страницу Message Maps (рис. 3.2). Теперь из списка Object IDs выберите идентификатор интересующей вас строки меню или кнопки панели управления. В списке Messages появятся две строки — COMMAND и ON_UPDATE_COMMAND_UI.
   Строка COMMAND позволяет создать обработчик командных сообщений, а строка ON_UPDATE_COMMAND_UI — обработчик команд обновления. О том как создавать с помощью MFC ClassWizard методы для обработки командных сообщений, мы рассказывали в 24 томе серии “Библиотека системного программиста”, посвященном библиотеке классов MFC.
   Чтобы создать обработчик для команды обновления, выберите из списка Messages строку ON_UPDATE_COMMAND_UI, а из списка Class name имя класса к которому будет добавлен новый метод. Нажмите кнопку Add Function. MFC ClassWizard предложит имя для нового метода. Вы можете согласиться с предложением ClassWizard или изменить имя метода по своему усмотрению. В частности, для  нескольких разных строк меню или кнопок панели управления вы можете указать один и тот же метод обработчик.
   Рис. 3.2. MFC ClassWizard
 
   К сожалению, MFC ClassWizard не позволяет назначить один обработчик команд обновления нескольким объектам пользовательского интерфейса с помощью макрокоманды ON_UPDATE_COMMAND_UI_RANGE. Вместо одной макрокоманды ON_UPDATE_COMMAND_UI_RANGE MFC ClassWizard разместит в таблице сообщений необходимое количество макрокоманд ON_UPDATE_COMMAND_UI.
   Еще одно неприятное ограничение MFC ClassWizard заключается в том, что он не дает возможности создать обработчики для команд обновления от индикаторов панели состояния. Такие обработчики вы должны будете добавлять к классам приложения вручную.

   Важную роль в работе таких объектов интерфейса пользователя, как меню, панели управления и панели состояния, играет класс CCmdUI. Методы этого класса позволяют заблокировать отдельные элементы меню, панелей управления и панелей состояния, отметить их символами √  или •.
   Класс CCmdUI один из немногих классов библиотеки MFC, который не имеет других базовых классов. Поэтому для объектов данного класса доступно относительно мало методов. Вы можете использовать только методы, определенные в самом классе CCmdUI.

Метод	Описание
Enable	Устанавливает или снимает блокировку
SetCheck	Помечает строку меню символом √
SetRadio	Помечает строку меню символом •
SetText	Устанавливает текст. Обычно используется для изменения текста в индикаторах панели состояния

Метод Enable

   Виртуальный метод Enable позволяет установить или снять блокировку с объекта интерфейса пользователя, представленного объектом класса CCmdUI. Метод имеет единственный параметр bOn. Если параметр bOn содержит значение TRUE или не указан совсем, то блокировка снимается. Если параметр bOn содержит значение FALSE, то блокировка устанавливается:
   virtual void Enable(BOOL bOn = TRUE);
   Заблокированные строки меню и кнопки панелей управления отображаются серым цветом и не могут быть использованы до момента снятия блокировки. В случае блокировки индикатора панели состояния его текст не будет отображаться.
   Метод Enable также можно использовать для блокирования органов диалоговых панелей управления.

Метод SetCheck

   Виртуальный метод SetCheck можно использовать для изменения состояния строки меню и кнопок панели управления:
   virtual void SetCheck(int nCheck = 1);
   Если вы используете метод SetCheck для управления меню и задали в качестве параметра nCheck нулевое значение, то соответствующая строка меню выделяется символом √, если параметр nCheck не указан или равен 1, то выделение снимается.
   В случае использования метода SetCheck для управления кнопкой панели управления, параметр nCheck задает новое состояние кнопки. Если параметр nCheck равен нулю, кнопка переходит в нажатое положение, если параметр nCheck не указан или равен единице – кнопка переходит в отжатое положение, а если параметр nCheck равен 2, кнопка принимает промежуточное состояние.
   Вы можете использовать метод SetCheck для управления внешним видом индикаторов панелей состояния. Если параметр nCheck равен нулю, то рамка индикатора изменяется таким образом, что он будет располагается выше общего уровня панели состояния. Если параметр nCheck равен 1, тогда индикатор переходит в нормальное состояние.
   Метод Enable также можно использовать для выбора положения переключателей в диалоговых панелей управления.

Метод SetRadio

   Виртуальный метод SetRadio, также как метод SetCheck, можно использовать для изменения состояния строки меню и кнопок панели управления:
   virtual void SetRadio(BOOL bOn = TRUE);
   Если вы используете метод SetRadio для управления меню и задали в качестве параметра bOn значение TRUE, то соответствующая строка меню выделяется символом •, если параметр nCheck равен FALSE, то выделение снимается.
   В случае использования метода SetRadio для управления кнопкой панели управления, параметр bOn задает новое состояние кнопки. Если параметр bOn равен FALSE, кнопка переходит в нажатое положение, если параметр bOn не указан или равен TRUE – кнопка переходит в отжатое положение.
   Вы можете использовать метод SetRadio для управления внешним видом индикаторов панелей состояния. Если параметр bOn равен FALSE, рамка индикатора изменяется таким образом, что он будет располагается выше общего уровня панели состояния. Если параметр bOn равен TRUE, тогда индикатор переходит в нормальное состояние.
   Метод Enable также можно использовать для выбора положения переключателей в диалоговых панелей управления.

Метод SetText

   Виртуальный метод SetText может быть использован для изменения текста, отображаемого в индикаторе панели состояния, в строке меню, в названии кнопок и некоторых органах диалоговых панелей управления. В качестве параметра lpszText надо указать текстовую строку, которую надо вывести:
   virtual void SetText(LPCTSTR lpszText);
   Следует отметить, что при использовании метода SetText для изменения текста в индикаторах панели состояния, вы должны отдельно позаботиться об изменении размера индикатора. Метод SetText не меняет размер индикатора, вы должны сами рассчитать ширину текста и изменить размер индикатора с помощью соответствующего метода. Более подробно об изменении параметров индикаторов панели состояния мы расскажем в разделе “Панель состояния”.

Элементы данных класса CCmdUI

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

Метод	Описание
m_nID	Идентификатор объекта, для которого вызвано сообщение
m_nIndex	Индекс объекта, для которого вызвано сообщение
m_pMenu	Указатель на меню. Если команда обновления передана не от меню, m_pOther содержит значение NULL
m_pOther	Указатель на панель состояния или панель управления для объекта которой выполняется обновление. Если команда обновления передана от меню, m_pOther содержит значение NULL

   Чтобы ускорить выбора строк из меню в приложениях используются таблицы клавиш акселераторов . Они задают соответствие комбинаций клавиш идентификаторам командных сообщений. Когда пользователь нажимает комбинацию клавиш, определенную в таблице акселераторов, приложению передается командное сообщение с соответствующим идентификатором. В принципе, можно определить комбинации клавиш акселерации, не только дублирующие строки меню, но и вызывающие передачу других командных сообщений.
   Для создания и изменения таблиц акселераторов следует использовать редактор ресурсов Microsoft Visual C++. Он позволяет определить соответствие комбинаций клавиш и идентификаторов командных сообщений (рис. 3.3).
   Рис. 3.3. Редактор таблицы клавиш ускорения
 
   Для приложений имеющих оконный интерфейс, и созданных с использованием MFC AppWizard, таблица акселераторов создается автоматически. Таблица акселераторов загружается приложением, во время создания главного окна приложения методом LoadFrame. Мы уже рассматривали этот метод, который также используется для загрузки меню и ряда других ресурсов:
   // Создаем главное окно многооконного приложения
   CMainFrame* pMainFrame = new CMainFrame;
 
   // Загружаем ресурсы с идентификатором IDR_MAINFRAME,
   // в том числе и таблицу акселераторов
   if (!pMainFrame->LoadFrame(IDR_MAINFRAME)) return FALSE;
   Для многооконных приложений каждый тип документа может иметь собственную таблицу акселераторов. Эта таблица будет загружена автоматически вместе с меню (и некоторыми другими ресурсами), когда пользователь откроет окно просмотра документа данного типа.
   Чтобы определить таблицу акселераторов для документов данного типа, надо просто включить ее в файл ресурсов приложения, присвоив ей идентификатор данного типа документов:
   CMultiDocTemplate* pDocTemplate;
   pDocTemplate = new CMultiDocTemplate(IDR_MULTITYPE, RUNTIME_CLASS(CMultiDoc), RUNTIME_CLASS(CChildFrame), RUNTIME_CLASS(CMultiView));
   AddDocTemplate(pDocTemplate);
   Если приложение создается без использования средств MFC AppWizard и модели документ – окно просмотра, вы можете загрузить таблицу акселераторов, с помощью метода LoadAccelTable , входящего в состав класса CFrameWnd:
   BOOL LoadAccelTable(LPCTSTR lpszResourceName);
   В качестве параметра lpszResourceName следует указать имя ресурса таблицы акселераторов. Если таблица акселераторов вместо строкового имени имеет числовой идентификатор, то вы должны воспользоваться макрокомандой MAKEINTRESOURCE.
   Как и многие другие методы классов MFC, метод LoadAccelTable возвращает в случае успешного завершения ненулевое значение и нуль в случае ошибки. Ошибка во время загрузки таблицы акселераторов может случиться, если вы неправильно укажите идентификатор (или имя) ресурса таблицы.

   Создайте новый проект под названием MultiMenu. В качестве типа приложения выберите из списка Type строку Application. Настройте проект MultiMenu, указав что приложение будет работать с библиотекой классов MFC.
   Наберите в редакторе исходный текст приложения и сохраните его в файле MultiMenu.cpp (листинг 3.1). Включите готовый файл MultiMenu.cpp в проект.

Листинг 3.1. Файл MultiMenu.cpp

   //============================================================
   // Приложение MultiMenu
   // (c) Frolov G.V., 1996
   // E-mail: frolov@glas.apc.org
   //============================================================
 
   // Включаемые файлы для MFC
   #include <afxwin.h>
   #include <afxext.h>
   #include <afxcmn.h>
 
   // Включаемый файл для ресурсов приложения и идентификаторов
   #include "resource.h"
 
   //============================================================
   // Класс CMultiMenuApp – главный класс приложения
   //============================================================
   class CMultiMenuApp : public CWinApp {
   public:
    // Мы будем переопределять метод InitInstance,
    // предназначенный для инициализации приложения
    virtual BOOL InitInstance();
   };
 
   // Создаем объект приложение класса CMultiMenuApp
   CMultiMenuApp MultiMenuApp;
 
   //============================================================
   // Класс CMultiMenuWindow – представляет главное окно
   //============================================================
   class CMultiMenuWindow : public CFrameWnd {
 
   protected:
    // Панель состояния
    CStatusBar m_wndStatusBar;
 
    // Флаг управляет строкой Prosess меню Mission
    BOOL bEnable;
 
    // Флаг управляет строкой Construction меню Mission
    BOOL bRadio;
 
    // Флаг управляет строкой Restrict меню Menu
    int nCheck;
 
   protected:
    // Метод для создания окна приложения и панели состояния
     afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
 
    // Методы для обработки командных сообщений
    // от меню приложения
    afx_msg void CMultiMenuWindow::OnDisable();
    afx_msg void CMultiMenuWindow::OnCommand();
    afx_msg void CMultiMenuWindow::OnExit();
    afx_msg void CMultiMenuWindow::OnConstruct();
    afx_msg void CMultiMenuWindow::OnRestrictMenu();
    afx_msg void CMultiMenuWindow::OnFullMenu();
 
    // Методы для обновления меню
    afx_msg void OnUpdateProcess(CCmdUI* pCmdUI);
    afx_msg void OnUpdateConstruct(CCmdUI* pCmdUI);
    afx_msg void OnUpdateDisable(CCmdUI* pCmdUI);
 
   public:
    // Конструктор класса CMultiMenuWindow
    CMultiMenuWindow();
 
    // Макрокоманда необходима, так как класс
    // CMultiMenuWindow обрабатывает сообщения
    DECLARE_MESSAGE_MAP()
   };
 
   //============================================================
   // Таблица сообщений класса CMultiMenuWindow
   //============================================================
   BEGIN_MESSAGE_MAP(CMultiMenuWindow, CFrameWnd)
    // Макрокоманда вызывает метод OnCreate
    ON_WM_CREATE()
 
    // Макрокоманда вызывает метод OnContextMenu
    ON_WM_CONTEXTMENU()
 
    // Макрокоманды для обработки командных сообщений
    ON_COMMAND(ID_MENU_DISABLE, OnDisable)
    ON_COMMAND(ID_MISSION_CONSTRUCT, OnConstruct)
    ON_COMMAND(ID_FILE_EXIT, OnExit)
    ON_COMMAND(ID_MISSION_PROCESS, OnCommand)
 
    ON_COMMAND(ID_MENU_RESTRICT, OnRestrictMenu)
    ON_COMMAND(ID_MENU_FULL, OnFullMenu)
 
    // Обработчики сообщений ON_UPDATE_COMMAND_UI
    ON_UPDATE_COMMAND_UI(ID_MISSION_PROCESS, OnUpdateProcess)
    ON_UPDATE_COMMAND_UI(ID_MISSION_CONSTRUCT, OnUpdateConstruct)
    ON_UPDATE_COMMAND_UI(ID_MENU_DISABLE, OnUpdateDisable)
   END_MESSAGE_MAP()
 
   // Индикатор панели управления
   UINT indicator = ID_SEPARATOR;
 
   //============================================================
   // Метод InitInstance класса CMultiMenuApp
   // Создает главное окно приложения и отображает его на экране
   //============================================================
   BOOL CMultiMenuApp::InitInstance() {
    m_pMainWnd = new CMultiMenuWindow();
    m_pMainWnd->ShowWindow(m_nCmdShow);
    m_pMainWnd->UpdateWindow();
 
    return TRUE;
   }
 
   //============================================================
   // Конструктор класса CMultiMenuWindow
   //============================================================
   CMultiMenuWindow::CMultiMenuWindow() {
    // Создаем окно приложения, соответствующее
    // данному объекту класса CMultiMenuWindow
    Create(NULL, "Multi Menu Sample", WS_OVERLAPPEDWINDOW, rectDefault, NULL, MAKEINTRESOURCE(IDR_FULL_MENU));
 
    // Загружаем таблицу клавиш акселерации
    LoadAccelTable(MAKEINTRESOURCE(IDR_ACCELERATOR));
 
    // Инициализируем флаги
    bEnable = TRUE;
    bRadio = TRUE;
    nCheck = 0;
   }
 
   //============================================================
   // Метод OnCreate класса CMultiMenuWindow
   // Вызывается во время создания окна приложения
   //============================================================
   int CMultiMenuWindow::OnCreate(LPCREATESTRUCT lpCreateStruct) {
    // Вызываем метод OnCreate базового класса
    if (CFrameWnd::OnCreate(lpCreateStruct) == -1) return -1;
 
    // Создаем панель состояния
    if (!m_wndStatusBar.Create(this)) {
     // Ошибка при создании панели состояния
     TRACE0("Failed to create status bar\n");
     return -1;
    }
 
    // Отображаем индикаторы панели состояния
    if (!m_wndStatusBar.SetIndicators(&indicator, 1)) {
     // Ошибка при установке индикатора
     TRACE0("Failed to set indicators\n");
     return -1;
    }
 
    return 0;
   }
 
   //============================================================
   // Метод OnDisable класса CMultiMenuWindow
   // Изменяем состояние флагов bEnable и nCheck
   //============================================================
   void CMultiMenuWindow::OnDisable(){
    // Меняем значение bEnable с TRUE на FALSE и наоборот
    bEnable = !bEnable;
 
    // Меняем значение bEnable с 1 на 0 и наоборот
    nCheck = (nCheck == 1) ? 0 : 1;
   }
 
   //============================================================
   // Метод OnRestrictMenu класса CMultiMenuWindow
   // Изменяем меню приложения с IDR_FULL_MENU на
   // IDR_RESTRICT_MENU
   //============================================================
   void CMultiMenuWindow::OnRestrictMenu(){
    CMenu menuOld;       // текущее меню
    CMenu menuRestrict;  // новое меню
    CMenu* pMenu;
 
    // Получаем указатель на текущее меню
    pMenu = this->GetMenu();
 
    // Связываем меню с объектом menuOld
    menuOld.Attach(pMenu->m_hMenu);
 
    // Удаляем меню
    menuOld.DestroyMenu();
 
    // Загружаем меню IDR_RESTRICT_MENU
    menuRestrict.LoadMenu(IDR_RESTRICT_MENU);
 
    // Устанавливаем загруженное меню
    SetMenu(&menuRestrict);
 
    // Разрываем связь меню с объектом menuRestrict
    menuRestrict.Detach();
   }
 
   //============================================================
   // Метод OnFullMenu класса CMultiMenuWindow
   // Изменяем меню приложения с IDR_RESTRICT_MENU на
   // IDR_FULL_MENU
   //============================================================
   void CMultiMenuWindow::OnFullMenu() {
    CMenu menuOld;
    CMenu menuRestrict;
    CMenu* pMenu;
 
    pMenu = this->GetMenu();
    menuOld.Attach(pMenu->m_hMenu);
    menuOld.DestroyMenu();
 
    menuRestrict.LoadMenu(IDR_FULL_MENU);
    SetMenu(&menuRestrict);
    menuRestrict.Detach();
   }
 
   //============================================================
   // Метод OnCommand класса CMultiMenuWindow
   //============================================================
   void CMultiMenuWindow::OnCommand() {
    MessageBox("Command not implemented");
   }
 
   //============================================================
   // Метод OnConstruct класса CMultiMenuWindow
   // Изменяем состояние флага bRadio
   //============================================================
   void CMultiMenuWindow::OnConstruct() {
    // Меняем значение bRadio с TRUE на FALSE и наоборот
    bRadio = !bRadio;
   }
 
   //============================================================
   // Метод OnExit класса CMultiMenuWindow
   //============================================================
   void CMultiMenuWindow::OnExit() {
    // Завершаем приложение
    DestroyWindow();
    return;
   }
 
   //============================================================
   // Метод OnUpdateProcess класса CMultiMenuWindow
   //============================================================
   void CMultiMenuWindow::OnUpdateProcess(CCmdUI* pCmdUI) {
    // Блокируем или разблокируем строку Process меню Mission
    pCmdUI->Enable(bEnable);
   }
 
   //============================================================
   // Метод OnUpdateConstruct класса CMultiMenuWindow
   //============================================================
   void CMultiMenuWindow::OnUpdateConstruct(CCmdUI* pCmdUI) {
    // Устанавливаем или снимаем пометку
    // строки Construction меню Mission
    pCmdUI->SetRadio(bRadio);
   }
 
   //============================================================
   // Метод OnUpdateDisable класса CMultiMenuWindow
   //============================================================
   void CMultiMenuWindow::OnUpdateDisable(CCmdUI* pCmdUI) {
    // Устанавливаем или удаляем пометку
    // у строки Disable меню Menu
    pCmdUI->SetCheck(nCheck);
   }
   Создайте новый файл ресурсов и включите его в проект под именем MultiMenu.rc. Включите в него два меню, присвоив им идентификаторы IDR_RESTRICT_MENU и IDR_FULL_MENU.
   Введите строки этих меню в соответствии с представленным нами файлом ресурсов (листинг 3.2). Для всех строк меню введите их описания. Они будут записаны в файл ресурсов как строковые ресурсы, имеющие одинаковые идентификаторы со строками меню.
   Добавьте в файл ресурсов строку Ready, выбрав для нее идентификатор AFX_IDS_IDLEMESSAGE. Эта строка будет отображаться в панели состояния во время “бездействия” приложения.
   Включите в файл ресурсов таблицу акселераторов, состоящую из трех команд: ID_MENU_DISABLE, ID_MISSION_PROCESS и ID_FILE_EXIT. Присвойте им комбинации клавиш <Ctrl+D>, <Ctrl+P> и <Ctrl+E> соответственно.

Листинг 3.2. Файл MultiMenu.rc

   //============================================================
   // Приложение MultiMenu
   // (c) Frolov G.V., 1996
   // E-mail: frolov@glas.apc.org
   //============================================================
 
   // Включаемые файлы для MFC
   #include <afxwin.h>
   #include <afxext.h>
   #include <afxcmn.h>
 
   // Включаемый файл для ресурсов приложения и идентификаторов
   #include "resource.h"
 
   //============================================================
   // Класс CMultiMenuApp - главный класс приложения
   //============================================================
   class CMultiMenuApp : public CWinApp {
   public:
    // Мы будем переопределять метод InitInstance,
    // предназначенный для инициализации приложения
    virtual BOOL InitInstance();
   };
 
   // Создаем объект приложение класса CMultiMenuApp
   CMultiMenuApp MultiMenuApp;
 
   //============================================================
   // Класс CMultiMenuWindow - представляет главное окно
   //============================================================
   class CMultiMenuWindow : public CFrameWnd {
 
   protected:
    // Панель состояния
    CStatusBar m_wndStatusBar;
 
    // Флаг управляет строкой Prosess меню Mission
    BOOL  bEnable;
 
    // Флаг управляет строкой Construction меню Mission
    BOOL  bRadio;
 
    // Флаг управляет строкой Restrict меню Menu
    int nCheck;
 
   protected:
    // Метод для создания окна приложения и панели состояния
    afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
 
    // Методы для обработки командных сообщений
    // от меню приложения
    afx_msg void CMultiMenuWindow::OnDisable();
    afx_msg void CMultiMenuWindow::OnCommand();
    afx_msg void CMultiMenuWindow::OnExit();
    afx_msg void CMultiMenuWindow::OnConstruct();
    afx_msg void CMultiMenuWindow::OnRestrictMenu();
    afx_msg void CMultiMenuWindow::OnFullMenu();
 
    // Методы для обновления меню
    afx_msg void OnUpdateProcess(CCmdUI* pCmdUI);
    afx_msg void OnUpdateConstruct(CCmdUI* pCmdUI);
    afx_msg void OnUpdateDisable(CCmdUI* pCmdUI);
 
   public:
    // Конструктор класса CMultiMenuWindow
    CMultiMenuWindow();
 
    // Макрокоманда необходима, так как класс
    // CMultiMenuWindow обрабатывает сообщения
    DECLARE_MESSAGE_MAP()
   };
 
   //============================================================
   // Таблица сообщений класса CMultiMenuWindow
   //============================================================
   BEGIN_MESSAGE_MAP(CMultiMenuWindow, CFrameWnd)   
    // Макрокоманда вызывает метод OnCreate
    ON_WM_CREATE()
 
    // Макрокоманда вызывает метод OnContextMenu
    ON_WM_CONTEXTMENU()
 
    // Макрокоманды для обработки командных сообщений
    ON_COMMAND(ID_MENU_DISABLE, OnDisable)
    ON_COMMAND(ID_MISSION_CONSTRUCT, OnConstruct)
    ON_COMMAND(ID_FILE_EXIT, OnExit)
    ON_COMMAND(ID_MISSION_PROCESS, OnCommand)
    ON_COMMAND(ID_MENU_RESTRICT, OnRestrictMenu)
    ON_COMMAND(ID_MENU_FULL, OnFullMenu)
 
    // Обработчики сообщений ON_UPDATE_COMMAND_UI
    ON_UPDATE_COMMAND_UI(ID_MISSION_PROCESS, OnUpdateProcess)
    ON_UPDATE_COMMAND_UI(ID_MISSION_CONSTRUCT, OnUpdateConstruct)
    ON_UPDATE_COMMAND_UI(ID_MENU_DISABLE, OnUpdateDisable)
 
   END_MESSAGE_MAP()
 
   // Индикатор панели управления
   UINT indicator = ID_SEPARATOR;
 
   //============================================================
   // Метод InitInstance класса CMultiMenuApp
   // Создает главное окно приложения и отображает его на экране
   //============================================================
   BOOL CMultiMenuApp::InitInstance() {
    m_pMainWnd = new CMultiMenuWindow();
    m_pMainWnd->ShowWindow(m_nCmdShow);
    m_pMainWnd->UpdateWindow();
    return TRUE;
   }
 
   //============================================================
   // Конструктор класса CMultiMenuWindow
   //============================================================
   CMultiMenuWindow::CMultiMenuWindow() {
    // Создаем окно приложения, соответствующее
    // данному объекту класса CMultiMenuWindow
     Create(NULL, "Multi Menu Sample", WS_OVERLAPPEDWINDOW, rectDefault, NULL, MAKEINTRESOURCE(IDR_FULL_MENU));
 
    // Загружаем таблицу клавиш акселерации
    LoadAccelTable(MAKEINTRESOURCE(IDR_ACCELERATOR));
 
    // Инициализируем флаги
    bEnable = TRUE;
    bRadio = TRUE;
    nCheck = 0;
   }
 
   //============================================================
   // Метод OnCreate класса CMultiMenuWindow
   // Вызывается во время создания окна приложения
   //============================================================
   int CMultiMenuWindow::OnCreate(LPCREATESTRUCT lpCreateStruct) {
    // Вызываем метод OnCreate базового класса
    if (CFrameWnd::OnCreate(lpCreateStruct) == -1) return -1;
 
    // Создаем панель состояния
    if (!m_wndStatusBar.Create(this)) {
     // Ошибка при создании панели состояния
     TRACE0("Failed to create status bar\n");
     return -1;  
    }
 
    // Отображаем индикаторы панели состояния
    if (!m_wndStatusBar.SetIndicators(&indicator, 1)) {
     // Ошибка при установке индикатора
     TRACE0("Failed to set indicators\n");
     return -1;  
    }
 
    return 0;
   }
 
   //============================================================
   // Метод OnDisable класса CMultiMenuWindow
   // Изменяем состояние флагов bEnable и nCheck
   //============================================================
   void CMultiMenuWindow::OnDisable() {
    // Меняем значение bEnable с TRUE на FALSE и наоборот
    bEnable = !bEnable;
 
    // Меняем значение bEnable с 1 на 0 и наоборот
    nCheck = (nCheck == 1) ? 0 : 1;
   }
 
   //============================================================
   // Метод OnRestrictMenu класса CMultiMenuWindow
   // Изменяем меню приложения с IDR_FULL_MENU на
   // IDR_RESTRICT_MENU
   //============================================================
   void CMultiMenuWindow::OnRestrictMenu() {
    CMenu menuOld;       // текущее меню
    CMenu menuRestrict;  // новое меню
    CMenu* pMenu;
 
    // Получаем указатель на текущее меню
    pMenu = this->GetMenu();
 
    // Связываем меню с объектом menuOld
    menuOld.Attach(pMenu->m_hMenu);
 
    // Удаляем меню
    menuOld.DestroyMenu();
 
    // Загружаем меню IDR_RESTRICT_MENU
    menuRestrict.LoadMenu(IDR_RESTRICT_MENU);
 
    // Устанавливаем загруженное меню
    SetMenu(&menuRestrict);
 
    // Разрываем связь меню с объектом menuRestrict
    menuRestrict.Detach();
   }
 
   //============================================================
   // Метод OnFullMenu класса CMultiMenuWindow
   // Изменяем меню приложения с IDR_RESTRICT_MENU на
   // IDR_FULL_MENU
   //============================================================
   void CMultiMenuWindow::OnFullMenu() {
    CMenu menuOld;
    CMenu menuRestrict;
    CMenu* pMenu;
 
    pMenu = this->GetMenu();
    menuOld.Attach(pMenu->m_hMenu);
    menuOld.DestroyMenu();
 
    menuRestrict.LoadMenu(IDR_FULL_MENU);
    SetMenu(&menuRestrict);
    menuRestrict.Detach();
   }
 
   //============================================================
   // Метод OnCommand класса CMultiMenuWindow
   //============================================================
   void CMultiMenuWindow::OnCommand() {
    MessageBox("Command not implemented");
   }
 
   //============================================================
   // Метод OnConstruct класса CMultiMenuWindow
   // Изменяем состояние флага bRadio
   //============================================================
   void CMultiMenuWindow::OnConstruct() {
    // Меняем значение bRadio с TRUE на FALSE и наоборот
    bRadio = !bRadio;
   }
 
   //============================================================
   // Метод OnExit класса CMultiMenuWindow
   //============================================================
   void CMultiMenuWindow::OnExit() {
    // Завершаем приложение
    DestroyWindow();
    return;
   }
 
   //============================================================
   // Метод OnUpdateProcess класса CMultiMenuWindow
   //============================================================
   void CMultiMenuWindow::OnUpdateProcess(CCmdUI* pCmdUI) {
    // Блокируем или разблокируем строку Process меню Mission
    pCmdUI->Enable(bEnable);
   }
 
   //============================================================
   // Метод OnUpdateConstruct класса CMultiMenuWindow
   //============================================================
   void CMultiMenuWindow::OnUpdateConstruct(CCmdUI* pCmdUI) {
    // Устанавливаем или снимаем пометку
    // строки Construction меню Mission
    pCmdUI->SetRadio(bRadio);
   }
 
   //============================================================
   // Метод OnUpdateDisable класса CMultiMenuWindow
   //============================================================
   void CMultiMenuWindow::OnUpdateDisable(CCmdUI* pCmdUI) {
    // Устанавливаем или удаляем пометку
    // у строки Disable меню Menu
    pCmdUI->SetCheck(nCheck);
   }
   Создайте новый файл ресурсов и включите его в проект под именем MultiMenu.rc. Включите в него два меню, присвоив им идентификаторы IDR_RESTRICT_MENU и IDR_FULL_MENU.
   Введите строки этих меню в соответствии с представленным нами файлом ресурсов (листинг 3.2). Для всех строк меню введите их описания. Они будут записаны в файл ресурсов как строковые ресурсы, имеющие одинаковые идентификаторы со строками меню.
   Добавьте в файл ресурсов строку Ready, выбрав для нее идентификатор AFX_IDS_IDLEMESSAGE. Эта строка будет отображаться в панели состояния во время “бездействия” приложения.
   Включите в файл ресурсов таблицу акселераторов, состоящую из трех команд: ID_MENU_DISABLE, ID_MISSION_PROCESS и ID_FILE_EXIT. Присвойте им комбинации клавиш <Ctrl+D>, <Ctrl+P> и <Ctrl+E> соответственно.

Листинг 3.3. Файл resource.h

   //{{NO_DEPENDENCIES}}
   // Microsoft Developer Studio generated include file.
   // Used by MultiMenu.rc
   //
   #define IDR_RESTRICT_MENU               106
   #define IDR_FULL_MENU                   107
   #define IDR_ACCELERATOR                 108
   #define ID_FILE_EXIT                    40009
   #define ID_MISSION_PROCESS              40013
   #define ID_HELP_HELPINDEX               40014
   #define ID_HELP_CONTEXTHELP             40015
   #define ID_HELP_SYSTEMINFO              40016
   #define ID_MISSION_CONSTRUCT            40017
   #define ID_MENU_RESTRICT                40019
   #define ID_MENU_FULL                    40020
   #define ID_MENU_DISABLE                 40025
 
   // Next default values for new objects
   //
   #ifdef APSTUDIO_INVOKED
   #ifndef APSTUDIO_READONLY_SYMBOLS
   #define _APS_NEXT_RESOURCE_VALUE        110
   #define _APS_NEXT_COMMAND_VALUE         40027
   #define _APS_NEXT_CONTROL_VALUE         1000
   #define _APS_NEXT_SYMED_VALUE           101
   #endif
   #endif
   Постройте приложение MultiMenu и запустите его. На экране появится окно приложения с главным меню и панелью состояния (рис. 3.4).
   В панели состояния расположен один индикатор. В нем отображается подсказка о выбранной строке меню приложения или системного меню, а если приложение “бездействует” – строка Ready.
   Рис. 3.4. Приложение MultiMenu
 
   Сразу после запуска приложения MultiMenu используется меню с идентификатором IDR_FULL_MENU. Если вы выберите из меню Menu строку Restrict, то меню приложения будет заменено на меню IDR_RESTRICT_MENU. Это сокращенный вариант меню IDR_FULL_MENU, в котором отсутствуют некоторые строки, а строка Process перенесена из меню Mission в меню File.
   Различные строки меню IDR_FULL_MENU и IDR_RESTRICT_MENU иллюстрируют режимы отображения строк меню. Так, при выборе из меню Menu строки Disable, блокируется строка Process в меню Mission. Около строки Disable при этом отображается символ √ (рис. 3.3). Чтобы снять блокировку, выберите строку Disable из меню Menu еще раз. Символ √ также исчезнет.
   При выборе строки Process из меню Mission на экране появляется сообщение. Когда строка Process заблокирована, выбрать ее невозможно.
   Если вы выберите из меню Mission строку Construction, то она будет выделена символом •. Повторный выбор этой строки снимает с нее выделение.
   Чтобы завершить работу приложения MultiMenu, можно выбрать из меню File строку Exit или выбрать из системного меню приложения строку Close. Все остальные строки меню приложения не работают и заблокированы.
   Для ускорения выбора некоторых команд из меню приложения можно воспользоваться клавишами акселерации. В программе определены три такие комбинации.

Комбинация клавиш	Соответствующая строка меню
<Ctrl+D>	Строка Disable из меню Menu
<Ctrl+P>	Строка Process из меню Mission или из меню File (для сокращенного варианта меню)
<Ctrl+E>	Строка Exit из меню File

Как работает приложение MultiMenu

   В приложении MultiMenu определены два класса – главный класс приложения CStateApp и класс главного окна приложения CStateWindow.

Главный класс приложения CMultiMenuApp

   Главный класс приложения CMultiMenuApp наследуется от базового класса CWinApp. Объект MultiMenuApp класса CMultiMenuApp объявлен как глобальный и создается сразу после запуска приложения.
   В класс CMultiMenuApp входит только метод InitInstance. Он создает главное окно приложения, представленное классом CMultiMenuWindow, наследованным от класса CFrameWnd .

Класс главного окна приложения CMultiMenuWindow

   Класс CMultiMenuWindow управляет главным окном приложения, создает меню, загружает панель управления а также обрабатывает сообщения, в том числе командные сообщения и команды обновления от меню.
   Фактически все методы, определенные в классе CMultiMenuWindow, можно условно разделить на три группы. В первую группу попал только один метод OnCreate. Он обрабатывает сообщение WM_CREATE, поступающее в момент создания окна приложения. Вторая группа состоит из шести методов — OnDisable, OnCommand, OnExit, OnConstruct, OnRestrictMenu и OnFullMenu. Эти методы используются для обработки командных сообщений от меню приложения. И, наконец, третья группа методов включает три метода - OnUpdateProcess, OnUpdateConstruct и OnUpdateDisable, которые обрабатывают команды обновления от трех различных строк меню приложения.
   В состав класса также входит несколько элементов данных. Это флаги bEnable, bRadio и nCheck, управляющие характеристиками трех строк меню, а также объект m_wndStatusBar класса CStatusBar, представляющий панель состояния нашего приложения.
   Рассмотрим отдельные методы класса CMultiMenuWindow более подробно.

Конструктор класса CMultiMenuWindow

   Конструктор класса CMultiMenuWindow используется для создания главного окна приложения, подключения меню, загрузки таблицы акселераторов и инициализации флагов.
   Для создания окна приложения вызывается метод Create класса CFrameWnd. Обратите внимание, что метод Create создает окно с меню, которое имеет идентификатор IDR_MENU:
   Create(NULL, "Status Bar Sample", WS_OVERLAPPEDWINDOW, rectDefault, NULL, MAKEINTRESOURCE(IDR_MENU));
   Затем выполняется загрузка таблицы акселераторов IDR_ACCELERATOR с помощью метода LoadAccelTable класса CFrameWnd:
   LoadAccelTable(MAKEINTRESOURCE(IDR_ACCELERATOR));
   И, в конце, конструктор устанавливает значение флагов bEnable, bRadio и nCheck. Флагам bEnable и bRadio присваивается значение TRUE, а флагу nCheck – нулевое значение.

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

   Таблица сообщений класса CMultiMenuWindow обрабатывает командные сообщения и команды обновления от меню приложения, а также содержит макрокоманду ON_WM_CREATE.
   Макрокоманда ON_WM_CREATE вызывает метод OnCreate во время создания окна:
   ON_WM_CREATE()
   Для обработки командных сообщений от меню приложения в таблицу сообщений класса CMultiMenuWindow включены шесть макрокоманд ON_COMMAND. Они вызывают обработчики OnDisable, OnConstruct, OnCommand, OnFullMenu, OnRestrictMenu и OnMenuExit:
   ON_COMMAND(ID_MENU_DISABLE, OnDisable)
   ON_COMMAND(ID_MISSION_CONSTRUCT, OnConstruct)
   ON_COMMAND(ID_FILE_EXIT, OnExit)
   ON_COMMAND(ID_MISSION_PROCESS, OnCommand)
   ON_COMMAND(ID_MENU_RESTRICT, OnRestrictMenu)
   ON_COMMAND(ID_MENU_FULL, OnFullMenu)
   Для обработки команд обновления в таблицу сообщений класса включены три макрокоманды ON_UPDATE_COMMAND_UI. Они вызывают методы OnUpdateProcess, OnUpdateConstruct и OnUpdateDisable:
   ON_UPDATE_COMMAND_UI(ID_MISSION_PROCESS, OnUpdateProcess)
   ON_UPDATE_COMMAND_UI(ID_MISSION_CONSTRUCT, OnUpdateConstruct)
   ON_UPDATE_COMMAND_UI(ID_MENU_DISABLE, OnUpdateDisable)
   Соответствие методов, вызываемых макрокомандами ON_COMMAND и ON_UPDATE_COMMAND_UI, строкам меню приложения вы можете посмотреть в файле ресурсов приложения, представленном в листинге 3.3.

Метод OnCreate класса CMultiMenuWindow

   Метод OnCreate класса CMultiMenuWindow сначала вызывает метод OnCreate базового класса CFrameWnd , чтобы создать главное окно приложения:
   if (CFrameWnd::OnCreate(lpCreateStruct) == –1) return –1;
   Затем мы создаем панель состояния, указывая в качестве ее родительского окна главное окно приложения. Для этого мы вызываем метод Create объекта m_wndStatusBar, представляющего панель состояния, передавая ему в качестве параметра значение this. В данном случае это означает, что окно приложения является родительским окном для панели состояния:
   if (!m_wndStatusBar.Create(this)) {
    // Ошибка при создании панели состояния
    TRACE0("Failed to create status bar\n");
    return -1;  
   }
   После того, как панель состояния создана, отображаем на ней единственный индикатор, вызывая метод SetIndicators. В качестве первого параметра передаем методу SetIndicators идентификатор этого единственного индикатора панели состояния, записанный в переменной indicator. Второй параметр метода SetIndicators, равен единице. Он определяет, что индикатор в панели состояния будет только один:
   if (!m_wndStatusBar.SetIndicators(&indicator,1)) {
    // Ошибка при установке индикатора
    TRACE0("Failed to set indicators\n");
    return -1;  
   }
   Более подробно о принципах устройства панелей состояния мы расскажем в отдельном разделе, который носит название “Панель состояния”.

Метод OnDisable класса CMultiMenuWindow

   Когда пользователь выбирает из меню Menu строку Disable или нажимает комбинацию клавиш <Ctrl+D>, приложению поступает командное сообщение, которое имеет идентификатор ID_MENU_DISABLE. Для обработки этого сообщения вызывается метод OnDisable класса CMultiMenuWindow. Этот метод изменяет состояние флагов bEnable и nCheck.
   Значение флага bEnable изменяется с TRUE на FALSE и наоборот, а значение флага bEnable с 1 на 0 и наоборот:
   bEnable = !bEnable;
   nCheck = (nCheck == 1) ? 0 : 1;
   Сам метод OnDisable не меняет состояния строк меню приложения, но изменение флагов bEnable и nCheck фиксируется обработчиком команд обновления меню.
   Так, флаг bEnable управляет блокировкой строки Process меню Mission (для полного варианта меню) и строки Process меню File (для укороченного варианта меню). Флаг bEnable проверяется методом OnUpdateProcess, который является обработчиком команд обновления от этих строк меню.
   Флаг nCheck управляет отображением символа √  около строки Disable меню Menu. Флаг nCheck проверяется методом OnUpdateDisable, который является обработчиком команд обновления от этой строки меню.

Метод OnCommand класса CMultiMenuWindow

   Когда пользователь выбирает строку Process из меню File (для укороченного варианта меню) или из меню Mission (для полного варианта меню), или просто нажимает комбинацию клавиш <Ctrl+P>, приложению поступает командное сообщение, которое имеет идентификатор ID_MISSION_PROCESS. Для обработки этого сообщения вызывается метод CMultiMenuWindow класса CMultiMenuWindow. Данный метод отображает на экране сообщение Command not implemented.

Метод OnConstruct класса CMultiMenuWindow

   Когда пользователь выбирает из меню Mission строку Construction, приложению поступает командное сообщение с идентификатором ID_MISSION_CONSTRUCT. Для обработки этого сообщения вызывается метод OnConstruct класса CMultiMenuWindow. Метод OnConstruct изменяет состояние флага bRadio, меняя значение bRadio с TRUE на FALSE и наоборот:
   bRadio = !bRadio;
   Флаг bRadio управляет отображением символа • около строки Construction меню Mission. Флаг bRadio проверяется методом OnUpdateConstruct, который является обработчиком команд обновления от этой строки меню.

Методы OnRestrictMenu и OnFullMenu класса CMultiMenuWindow

   Приложение MultiMenu имеет два меню, полное и укороченное. Вы можете выбирать, какое меню будет использоваться в данный момент, с помощью строки Restrict и Full меню Menu. Если в данный момент используется полный вариант меню, то чтобы заменить его укороченным вариантом, следует выбрать из меню Menu строку Restrict. Для обратной замены меню с укороченного варианта на полный, надо выбрать из меню Menu строку Full.
   При выборе строк Restrict и Full приложению передаются командные сообщения с идентификаторами IDR_RESTRICT_MENU и IDR_FULL_MENU, соответственно. Для их обработки вызываются методы OnRestrictMenu и OnFullMenu. По сути, методы OnRestrictMenu и OnFullMenu практически идентичны. Отличие между ними заключается только в том, что метод OnRestrictMenu заменяет текущее меню укороченным вариантом меню (идентификатор меню IDR_RESTRICT_MENU), а метод OnFullMenu меняет текущее меню на полный вариант меню (идентификатор меню IDR_FULL_MENU).
   Метод OnRestrictMenu работает следующим образом. Сначала он получает указатель на текущее меню окна приложения. Указатель на объект ласса CMenu, представляющий это меню, записывается во временную переменную pMenu:
   pMenu = this->GetMenu();
   Затем текущее меню удаляется, для чего вызывается метод DestroyMenu:
   pMenu->DestroyMenu();
   Теперь загружается ресурс нового меню, имеющего идентификатор IDR_RESTRICT_MENU (или IDR_FULL_MENU для метода OnFullMenu):
   CMenu menuRestrict; // Новое меню
   menuRestrict.LoadMenu(IDR_RESTRICT_MENU);
   Загруженное меню подключается к окну приложения – вызывается метод SetMenu класса окна. В качестве параметра ему передается указатель на объект menuRestrict, представляющий новое меню:
   SetMenu(&menuRestrict);
   И, наконец, вызывается метод Detach , отпускающий меню в “свободное плавание”, то есть отсоединяющее его от объекта menuRestrict класса CMenu:
   menuRestrict.Detach();

Метод OnUpdateProcess класса CMultiMenuWindow

   Команды обновления от строк Process меню File и Mission передаются для обработки методу OnUpdateProcess класса CMultiMenuWindow. Этот метод блокирует или снимает блокировку со строки Process в зависимости от значения флага bEnable:
   pCmdUI->Enable(bEnable);

Метод OnUpdateConstruct класса CMultiMenuWindow

   Команда обновления от строки Construction меню Mission передается для обработки методу OnUpdateConstruct класса CMultiMenuWindow. Этот метод устанавливает или снимаем отметку • со строки Construction в зависимости от значения флага bRadio:
   pCmdUI->SetRadio(bRadio);

Метод OnUpdateDisable класса CMultiMenuWindow

   Команда обновления от строки Disable меню Menu передается для обработки методу OnUpdateDisable класса CMultiMenuWindow. Этот метод устанавливает или снимаем отметку √ со строки Disable, в зависимости от значения флага nCheck:
   pCmdUI->SetCheck(nCheck);

Метод OnMenuExit класса CMultiMenuWindow

   Пользователь может завершить приложение, выбрав из меню File строку Exit. В этом случае приложению передается командное сообщение с идентификатором ID_FILE_EXIT. Соответствующая макрокоманда ON_COMMAND из таблицы сообщений класса CStateWindow вызывает для обработки этого сообщения метод OnMenuExit:
   ON_COMMAND(ID_WORK_EXIT, OnMenuExit)
   Метод OnMenuExit завершает работу приложения, для чего вызывает метод DestroyWindow, определенный в классе CWnd, для главного окна приложения:
   void CMultiMenuWindow::OnExit() {
    // Завершаем приложение
    DestroyWindow();
    return;
   }

   Новые операционные системы Windows 95 и Windows NT версии 4.0 и приложения, разработанные для них, значительно шире используют правую кнопку мыши, чем ранние версии Windows. Обычно при нажатии правой кнопки мыши на экране появляется временное меню, внешний вид которого зависит от выбранного объекта.
   Современные приложения используют правую клавишу мыши для вывода контекстного меню. В диалоговой панели Component Gallery расположен компонент Pop-up Menu. Он позволяет подключить контекстное меню к любому окну приложения.
   Если вы желаете подключить контекстное меню к вашему приложению, выберите в диалоговой Component Gallery панели компонент Pop-up Menu и нажмите кнопку Insert. На экране появится диалоговая панель Pop-up Menu. В списке Add pop-up menu to перечислены классы проекта, представляющие окна и диалоговые панели. К одному из них вы можете добавить контекстное меню. По умолчанию к проекту добавляется новое меню, состоящее из трех строк, которому присваивается идентификатор, состоящий из префикса CG_IDR_POPUP_, названия приложения и части названия класса окна, к которому добавлено меню.
   Далее мы опишем добавление компонента Pop-up Menu к приложению Multi, рассмотренному в разделе “Приложение Multi”.
   Загрузите в Microsoft Visual C++ проект Multi, откройте диалоговую панель Component Gallery, выберите компонент Pop-up Menu и нажмите кнопку Insert. На экране появится диалоговая панель Pop-up Menu (рис. 3.5). Выберите из списка Add pop-up menu to класс CMultiView.
   По умолчанию к проекту добавляется новое меню, состоящее из трех строк, которому присваивается идентификатор CG_IDR_POPUP_MULTI_VIEW.
   Рис. 3.5. Диалоговая панель Pop-up Menu
 
   Название идентификатора контекстного меню отображается в поле Menu resource ID диалоговой панели Pop-up Menu. Вы можете заменить его по своему усмотрению.
   Нажмите кнопку OK. Диалоговая панель Pop-up Menu закроется. В исходных текстах приложения будут выполнены все необходимые изменения, а к ресурсам добавиться новое меню с идентификатором CG_IDR_POPUP_MULTI_VIEW.
   Редактор ресурсов Microsoft Visual C++ позволяет изменять шаблон контекстного меню по вашему усмотрению. Из него можно удалить строки, добавленные Component Gallery по умолчанию, и вставить строки нужные вам.
   Когда вы построите проект и запустите приложение, то при нажатии на правую кнопку мыши будет открываться контекстное меню окна над которым расположен указатель мыши.
   Рис. 3.6. Контекстное меню, которое использует компонент Pop-up Menu
 
   В файл ресурсов будет добавлено определение контекстного меню CG_IDR_POPUP_MULTI_VIEW. Как видите, оно не отличается от меню, которые вы создавали или использовали ранее, за исключением того, что соответствующее меню верхнего уровня обозначено строкой _POPUP_ (рис. 3.6). Эта строка не будет отображаться в контекстном меню.
   Если в приложении имеется несколько окон, то вы можете добавить к каждому окну свое контекстное меню. Для этого вставьте в проект компонент Pop-up Menu несколько раз, указывая в поле Add pop-up menu to различные классы окон. Конечно, каждое вставленное в проект меню может состоять из различного набора строк.
   Например, если у вас многооконное приложение, то вы можете вставить компонент Pop-up Menu для главного окна приложения и для окна просмотра. Тогда если вы нажмете правую кнопку мыши в то время, когда указатель мыши находится в окне просмотра, то отображается одно контекстное меню, а если вы нажмете правую кнопку мыши когда ее указатель расположен вне окна просмотра – отображается другое контекстное меню.

Класс CMultiView

   Все изменения в программном коде приложения Multi, выполненные при вставке в него компонента Pop-up Menu, происходят только в классе окна, к которому добавляется контекстное меню. Компонент Pop-up Menu добавляет макрокоманду ON_WM_CONTEXTMENU к таблице сообщений класса CMultiView, а также встсавляет в класс CMultiView методы OnContextMenu и PreTranslateMessage.
   В определении класса CMultiView добавляется только метод-обработчик OnContextMenu. Все остальные элементы класса не изменяются. После добавления к проекту Pop-up Menu класс CMultiView, определенный в файле MultiView.h будет выглядеть следующим образом:
   class CMultiView : public CView {
   protected:
    // CG: Метод OnContextMenu добавлен компонентом Pop-up Menu
    afx_msg void OnContextMenu(CWnd*, CPoint point);
 
    CMultiView();
    DECLARE_DYNCREATE(CMultiView)
 
   // Attributes
   public:
    virtual BOOL PreTranslateMessage(MSG* pMsg);
    CMultiDoc* GetDocument();
 
   // Operations
   public:
 
   // Overrides
    //{{AFX_VIRTUAL(CMultiView)
   public:
    virtual void OnDraw(CDC* pDC);
    virtual BOOL PreCreateWindow(CREATESTRUCT& cs);
   protected:
    virtual BOOL OnPreparePrinting(CPrintInfo* pInfo);
    virtual void OnBeginPrinting(CDC* pDC, CPrintInfo* pInfo);
    virtual void OnEndPrinting(CDC* pDC, CPrintInfo* pInfo);
    //}}AFX_VIRTUAL
 
   // Implementation
   public:
    virtual ~CMultiView();
   #ifdef _DEBUG
    virtual void AssertValid() const;
    virtual void Dump(CDumpContext& dc) const;
   #endif
 
   protected:
    //{{AFX_MSG(CMultiView)
    //}}AFX_MSG
    DECLARE_MESSAGE_MAP()
   };
   Остальные классы приложения остаются без изменения.

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

   При добавлении контекстного меню к окну класса CMultiView, в таблицу сообщений класса CMultiView добавляется новая макрокоманда ON_WM_CONTEXTMENU:
   //////////////////////////////////////////////////////////////
   // Таблица сообщений класса CMultiView
 
   // Объекты класса CMultiView создаются динамически
   IMPLEMENT_DYNCREATE(CMultiView, CView)
 
   // Таблица сообщений класса CMultiView. В нее добавлена
   // макрокоманда ON_WM_CONTEXTMENU
   BEGIN_MESSAGE_MAP(CMultiView, CView)
    ON_WM_CONTEXTMENU()
    //{{AFX_MSG_MAP(CMultiView)
    //}}AFX_MSG_MAP
    // Стандартные команды
    ON_COMMAND(ID_FILE_PRINT, CView::OnFilePrint)
    ON_COMMAND(ID_FILE_PRINT_DIRECT, CView::OnFilePrint)
    ON_COMMAND(ID_FILE_PRINT_PREVIEW,CView::OnFilePrintPreview)
   END_MESSAGE_MAP()

Метод OnContextMenu класса CMultiView

   Когда пользователь нажимает правую кнопку мыши в окне, макрокоманда ON_WM_CONTEXTMENU вызывает метод-обработчик OnContextMenu из класса этого окна. Методу OnContextMenu передаются два параметра:
   afx_msg void OnContextMenu(CWnd* pWnd, CPoint pos);
   Параметр pWnd содержит указатель на объект класса CWnd. Он представляет окно, в котором находился указатель мыши, когда была нажата правая кнопка мыши. Это может быть окно класса к которому принадлежит таблица сообщений или его дочернее окно.
   Параметр pos, представляющий объект класса CPoint, содержит координаты указателя мыши, зафиксированные в момент нажатия правой кнопки мыши.
   Реализация метода OnContextMenu добавляется в файле MultiView.cpp:
   //////////////////////////////////////////////////////////////
   // Метод OnContextMenu класса CMultiView
   // CG: Метод OnContextMenu добавлен компонентом Pop-up Menu
   void CMultiView::OnContextMenu(CWnd*, CPoint point) {
    // Объект menu будет представлять контекстное меню
    CMenu menu;
    // Загружаем меню CG_IDR_POPUP_MULTI_VIEW
    VERIFY(menu.LoadMenu(CG_IDR_POPUP_MULTI_VIEW));
 
    // Получаем указатель на всплывающее меню
    CMenu* pPopup = menu.GetSubMenu(0);
    ASSERT(pPopup != NULL);
 
    // Получаем указатель на объект CWnd, представляющий окно
    // для которого надо отобразить контекстное меню
    CWnd* pWndPopupOwner = this;
    while (pWndPopupOwner->GetStyle() & WS_CHILD) pWndPopupOwner = pWndPopupOwner->GetParent();
 
    // Отображаем контекстное меню
    pPopup->TrackPopupMenu(TPM_LEFTALIGN | TPM_RIGHTBUTTON, point.x, point.y, pWndPopupOwner);
   }
   Для вывода контекстного меню на экран используется метод TrackPopupMenu, входящий в класс CMenu. Контекстное меню можно открыть в любом месте экрана. Вне зависимости от расположения меню, все командные сообщения от него передаются одному определенному окну.
   Параметры метода TrackPopupMenu задают расположение контекстного меню и выбирают для него окно, в которое будут передаваться командные сообщения:
   BOOL TrackPopupMenu(UINT nFlags, int x, int y, CWnd* pWnd, LPCRECT lpRect = 0);
   Параметр nFlags представляет собой комбинацию атрибутов. Они определяют, как будет отображаться меню и какая кнопка мыши используется для выбора строк из этого меню.
   Если в качестве nFlags указан атрибут TPM_CENTERALIGN, то контекстное меню отображается по центру относительно координаты, указанной параметром x. Если в параметре nFlags установлен атрибут TPM_LEFTALIGN, то параметр x определяет координату левой стороны меню, а если установлен атрибут TPM_RIGHTALIGN — правой.
   Кроме атрибутов TPM_CENTERALIGN, TPM_LEFTALIGN или TPM_RIGHTALIGN в параметре nFlags можно установить атрибут TPM_LEFTBUTTON или TPM_RIGHTBUTTON. Атрибут TPM_LEFTBUTTON говорит, что выбор из меню осуществляется нажатием левой, а TPM_RIGHTBUTTON — правой кнопкой мыши.
   Назначение параметра x зависит от атрибутов, установленных в параметре nFlags. Параметр y во всех случаях указывает расположение верхней стороны меню. Координаты x и y указываются в экранных координатах.
   Параметр pWnd должен содержать указатель на объект класса CWnd, представляющий окно, в которое будут передаваться все командные сообщения от контекстного меню.
   Контекстное меню закрывается, если вы нажмете на кнопку мыши вне меню. Параметр lpRect позволяет указать прямоугольник, внутри которого нажатие на кнопку мыши не будет вызывать закрытия меню. Если этот параметр равен NULL, меню закрывается, если пользователь нажал кнопку мыши в любом месте экрана вне меню.
   В случае успешного завершения, метод TrackPopupMenu ненулевое значение, а в противном случае нуль.

Метод PreTranslateMessage класса CMultiView

   Кроме добавления новой макрокоманды к таблице сообщений класса CMultiView и соответствующего метода-обработчика OnContextMenu, компонент Pop-up Menu добавляет метод PreTranslateMessage к классу CMultiView.
   В него записывается программный код, который обнаруживает нажатие комбинации клавиш <Shift+F10> или специальной клавиши на клавиатуре с дополнительными клавишами Windows 95 и напрямую вызывает метод OnContextMenu:
   //////////////////////////////////////////////////////////////
   // Метод PreTranslateMessage класса CMultiView
    BOOL CMultiView::PreTranslateMessage(MSG* pMsg) {
    // CG: Следующий блок добавлен компонентом Pop-up Menu
    {
     // Если нажата комбинация клавиш <Shift+F10>
     if ((((pMsg->message == WM_KEYDOWN || pMsg->message == WM_SYSKEYDOWN) && (pMsg->wParam == VK_F10) && (GetKeyState(VK_SHIFT) & ~1)) != 0) || // it's Shift+F10 OR Natural keyboard key
      (pMsg->message == WM_CONTEXTMENU)) {
      // Определяем экранные координаты клиентской части окна
      CRect rect;
      GetClientRect(rect);
      ClientToScreen(rect);
      // Записываем в объект point класса CPoint координаты
      // левого верхнего угла клиентской части окна, добавляя
      // к нему смещения в 5 пикселов по горизонтали и вертикали
      CPoint point = rect.TopLeft();
      point.Offset(5, 5);
      // Отображаем контекстное меню в позиции point
      OnContextMenu(NULL, point);
 
      // Возвращаем значение TRUE, так как сообщение обработано
      return TRUE;
     }
    }
 
    // Вызываем метод PreTranslateMessage базового класса CView
    return CView::PreTranslateMessage(pMsg);
   }

   Обычно, панель управления располагается в верхней части главного окна приложения. Она содержит ряд кнопок, дублирующих функции некоторых строк меню приложения. Так как кнопки располагаются непосредственно в окне приложения и всегда доступны, то нажать на кнопки можно быстрее, чем открыть меню и выбрать соответствующую строку.
   Если приложение имеет сложную систему управления и большое меню, то создавать для каждой строки меню отдельную кнопку в панели управления не надо. В противном случае кнопки просто не поместятся в окне приложения.
   Чтобы выйти из этого положения, создают несколько отдельных панелей управления, которые можно открывать или закрывать по своему усмотрению. Такая организация панелей управления используется очень часто. Достаточно взглянуть на любое офисное приложение Microsoft – Microsoft Word или Microsoft Excel, или даже на среду Microsoft Visual C++.

   Начиная с версии 4.0 Microsoft Visual C++, панель управления является отдельным ресурсом, таким же как меню или шаблон диалоговой панели. Редактор ресурсов Microsoft Visual C++ позволяет создать новую панель управления или изменить уже существующую. В редакторе вы не только можете нарисовать новые кнопки, вы сразу можете присвоить им идентификаторы и вызвать ClassWizard, чтобы добавить программный код, вызываемый при нажатии на данную кнопку. В самом простом случае процедура добавления новой кнопки к уже существующей панели управления займет у вас всего несколько минут.
   Создайте с помощью MFC AppWizard новый проект или откройте проект, созданный ранее, например, проект Multi. В окне Project Workspace откройте страницу ResourceView. Откройте папку ресурсов Toolbar. В ней располагается только один ресурс этого типа, имеющий идентификатор IDR_MAINFRAME. Загрузите этот ресурс в редактор ресурсов (рис. 3.7).
   Рис. 3.7. Редактор ресурсов toolbar
 
   В верхней части окна редактора ресурсов типа toolbar отображается редактируемая панель управления. С помощью мыши можно выбирать кнопки этой панели, которые вы желаете изменить. Редактирование изображения кнопок выполняется в нижней части окна редактора, разделенной на две области, в которых отображается кнопка в нормальном и увеличенном масштабе. Для редактирования предназначены инструменты, представленные в панели Graphics. Вы также можете задавать цвета из палитры Colors.
   Редактор ресурсов позволяет присвоить идентификаторы отдельным кнопкам панели управления. Для этого сделайте двойной щелчок по изображению кнопки в верхней части окна редактора. На экране появится диалоговая панель Toolbar Button Properties (рис. 3.8).
   Рис. 3.8. Диалоговая панель Toolbar Button Properties
 
   Идентификатор кнопки вводится в списке ID. По умолчанию в списке ID отображается идентификатор, который кнопка имеет в данный момент. Вы можете заменить его другим идентификатором, выбрав его из списка или введя его вручную. Если кнопке, идентификатор еще не присвоен и поле ID пустое, то когда вы закроете панель Toolbar Button Properties, идентификатор будет создан автоматически.
   В полях Width и Height выводятся, соответственно, ширина и высота кнопок панели управления в пикселах. Эти два значения относятся ко всем кнопкам панели, а не только к кнопке, выбранной для редактирования в данный момент.
   В поле Prompt отображается текстовая строка, описывающая кнопку панели управления. Строка состоит из двух частей, разделенных символом \n. Первая часть содержит описание кнопки, отображаемое в панели состояния когда кнопка выбрана (или соответствующей строки меню, если в меню есть строка с таким же идентификатором). Во второй части строки находится короткое описание кнопки. Оно отображается в окне подсказки tooltips, если вы поместите указатель мыши над кнопкой и некоторое время подождете.
   Каждая кнопка в панели управления и каждый разделитель имеют свой собственный индекс. Этот индекс соответствует порядковому номеру, под которым кнопка или разделитель отображаются на экране.

Как хранится ресурс, описывающий панели управления

   Каждый ресурс, представляющий панель управления в редакторе ресурсов Microsoft Visual C++, выступает как единое целое. Загрузив в редактор панель управления вы можете менять внешний вид кнопок, задавать их идентификаторы и строки описания, не открывая других ресурсов или дополнительных файлов.
   Если вы просмотрите исходный текст файла ресурсов приложения, то обнаружите, что на самом деле ресурс панели управления состоит из двух, а если быть точнее, то из трех частей.
   Первая часть описывает панель управления:
   //////////////////////////////////////////////////////////////
   // Панель управления toolbar
 
   IDR_MAINFRAME TOOLBAR DISCARDABLE  16, 15
   BEGIN
    BUTTON ID_FILE_NEW
    BUTTON ID_FILE_OPEN
    BUTTON ID_FILE_SAVE
    SEPARATOR
    BUTTON ID_EDIT_CUT
    BUTTON ID_EDIT_COPY
    BUTTON ID_EDIT_PASTE
    SEPARATOR
    BUTTON ID_FILE_PRINT
    BUTTON ID_APP_ABOUT
    BUTTON ID_TOOL_EXIT
   END
   В нашем примере эта панель имеет идентификатор IDR_MAINFRAME. После идентификатора следует ключевое слово TOOLBAR, а затем дополнительные параметры, описывающие режим использования ресурса и два числа, определяющие размер кнопок панели.
   Затем в блоке BEGIN - END идет описание каждой кнопки панели. После ключевого слова BUTTON, представляющего кнопку следует ее идентификатор. Между описаниями кнопок могут располагаться ключевые слова SEPARATOR.
   В нашем маленьком примере присутствуют два таких слова. Они означают, что между кнопками, разделенными строкой SEPARATOR, увеличено расстояние. За счет увеличения расстояния между отдельными кнопками достигается эффект разделения кнопок панели управления на три отдельные группы. Это, в свою очередь, улучшает восприятие приложения и делает его более удобным для пользователя.
   Как видите, в первой части ресурса панели управления отсутствуют сами изображения кнопок. Они располагаются отдельно и представляют вторую часть ресурса. Все кнопки представлены одним изображением bitmap, имеющим тот же идентификатор, что и соответствующий ресурс TOOLBAR:
   //////////////////////////////////////////////////////////////
   // Bitmap
 
   IDR_MAINFRAME   BITMAP   MOVEABLE PURE   "res\\Toolbar.bmp"
   Изображение кнопок нашей панели управления IDR_MAINFRAME хранится в файле Toolbar.bmp (рис. 3.9). Файл записан в каталоге RES основного каталога проекта. Все кнопки панели управления расположены последовательно, одна за другой. Порядок, в котором они расположены, соответствует порядку, в котором кнопки описаны в ресурсе TOOLBAR, и порядку в котором они будут отображаться на экране во время работы приложения.
   Рис. 3.9. Файл Toolbar.bmp с изображением кнопок панели управления
 
   Между отдельными изображениями кнопок отсутствуют промежутки, даже если в описании ресурса TOOLBAR присутствуют разделители SEPARATOR.
   Когда вы подготавливаете ресурс toolbar в редакторе ресурсов, то для каждой кнопки вы можете ввести описывающую ее текстовую строку. Эти строки как раз и представляют третью, необязательную часть ресурса toolbar. Хранятся они в стоковых ресурсах приложения.
   Соответствие строковых ресурсов кнопкам панели управления достигается за счет присвоения им одинаковых идентификаторов. Так, для нашего примера вы можете найти в файле ресурсов следующие текстовые ресурсы (мы привели только выборку из строковых ресурсов приложения):
   STRINGTABLE DISCARDABLE
   BEGIN
    ID_FILE_NEW   "Create a new document\nNew"
    ID_FILE_OPEN  "Open an existing document\nOpen"
    ID_FILE_SAVE  "Save the active document\nSave"
    ID_FILE_PRINT "Print the active document\nPrint"
    ID_EDIT_COPY  "Copy the selection and put it on the Clipboard\nCopy"
    ID_EDIT_CUT   "Cut the selection and put it on the  Clipboard\nCut"
    ID_EDIT_PASTE "Insert Clipboard contents\nPaste"
    ID_APP_ABOUT  "Display program information, version number and copyright\nAbout"
   END
   Надо сказать, что строки описания некоторых кнопок могут отсутствовать, или наоборот, использоваться еще и в других ресурсах, например, в описании ресурсов меню. Все кнопки стандартной панели управления, которая автоматически создается MFC AppWizard для однооконных и многооконных приложений, имеют соответствие в меню приложения.

   Чтобы добавить в панели управления новую кнопку, переместите указатель мыши на крайне правую кнопку в панели управления, отображаемой в верхней части окна редактора ресурсов, и нажмите на левую кнопку мыши. Теперь вы можете нарисовать изображение, которое будет отображаться на новой кнопке.
   Вместе с Microsoft Visual C++ поставляются несколько изображений кнопок панелей управления, которые можно использовать в разрабатываемых приложениях. Откройте файл ресурсов Common.res, записанный на компакт диске Microsoft Visual C++, и просмотрите записанные в нем ресурсы типа toolbar. Если вы обнаружите подходящие вам изображение, скопируйте его в обменный буфер Windows clipboard и вставьте в редактируемую панель управления. Для более полного описания файла Common.res обратитесь к разделу “Ресурсы Microsoft”.
   Введите идентификатор новой кнопки панели управления. Для этого, выполните двойной щелчок по изображению этой кнопки в верхней части окна редактирования. В поле ID, открывшейся диалоговой панели Toolbar Button Properties, введите идентификатор ID_MY_BUTTON (рис. 3.8).
   Теперь вы можете построить проект и запустить приложение. В панели управления появится новая кнопка, но она будет иметь серый цвет и будет заблокирована. Такая блокировка выполняется автоматически, если кнопка не имеет соответствующего обработчика сообщений.
   Когда вы разрабатываете в редакторе ресурсов меню или диалоговую панель, то достаточно нажать правую кнопку мыши и откроется временное меню из которого можно запустить ClassWizard. В окне редактора панелей управления toolbar правая кнопка не работает, точнее она задействована для других целей.
   Чтобы воспользоваться ClassWizard, сначала надо выбрать кнопку, к которой вы желаете привязать код, а затем нажать кнопку ClassWizard из панели Standard. ClassWizard откроет страницу Message Map и сразу предложит создать методы для выбранной кнопки (рис. 3.10).
   Рис. 3.10. Диалоговая панель ClassWizard
 
   По умолчанию, в списке Object IDs будет отображаться идентификатор кнопки, выбранной в редакторе панели управления — ID_MY_BUTTON. В списке Class name выбран класс CMainFrame — класс главного окна приложения. Вы можете выбрать и любой другой класс приложения, если желаете чтобы он обрабатывал команды от данной кнопки.
   Теперь выберите из списка Messages идентификатор сообщения, подлежащего обработке. Вам доступны два варианта — COMMAND и UPDATE_COMMAND_UI.
   Выберите из списка Messages идентификатор COMMAND и нажмите кнопку Add Function. ClassWizard добавит к таблице сообщений класса CMainFrame новую макрокоманду для обработки команды от кнопки и запросит имя метода для обработки этой команды. По умолчанию будет предложено имя OnMyButton. Вы можете согласиться с предложением и нажать кнопку OK. ClassWizard добавит к классу CMainFrame метод OnMyButton.
   Чтобы сразу перейти к редактированию данного метода, достаточно нажать на кнопку Edit Code. В окне редактирования появится файл с исходными текстами методов класса CMainFrame, а курсор будет установлен на метод OnMyButton:
   //////////////////////////////////////////////////////////////
   // Метод OnMyButton класса CMainFrame
 
   void CMainFrame::OnMyButton() {
    // TODO: Здесь вы можете добавить собственный
    // программный код
   }
   Как видите, метод OnMyButton не имеет параметров. Одно то, что он вызван, служит сигналом нажатия на кнопку ID_MY_BUTTON. Добавьте после комментария TODO код, который вы желаете выполнять по нажатию кнопки. Для нашего первого тестового примера достаточно добавить вызов всего одного метода MessageBox или функции AfxMessageBox:
   //////////////////////////////////////////////////////////////
   // Метод OnMyButton класса CMainFrame
 
   void CMainFrame::OnMyButton() {
    // TODO: Здесь вы можете добавить собственный
    // программный код
    MessageBox(“Button is pressed”);
   }
   Постройте проект и запустите полученное приложение. Теперь, когда вы добавили обработчик для команд от кнопки с идентификатором ID_MY_BUTTON, она отображается в нормальном виде и вы можете на нее нажать.
   Когда вы нажимаете на кнопку ID_MY_BUTTON, вызывается метод обработчик OnMyButton из класса CMainFrame. Он отображает на экране сообщение Button is pressed.

   В состав библиотеки MFC включены два класса для работы с панелями управления – CToolBar и CDialogBar. Оба они наследуются от базового класса CControlBar, реализующего основные функции панелей управления. Кроме того, от базового класса CControlBar наследуется еще один класс – CStatusBar. Он предназначен для работы с панелями состояния и будет рассмотрен позже:
   CToolBar  ←|←CControlBar←CWnd←CCmdTarget←CObject
   CDialogBar←|
   CStatusBar←|
   Класс CToolBar представляет панель управления, состоящую из ряда кнопок. При желании, вы, конечно, сможете разместить на панели управления и другие органы управления, например списки или поля редактирования, однако такая возможность требует дополнительного программирования.
   Если требуется создать панель, содержащую различные органы управления, а не только кнопки, то гораздо удобнее воспользоваться классом CDialogBar. Класс CDialogBar, также наследованный от базового класса CControlBar, позволяет создать панель управления на основе хорошо известного вам шаблона диалоговой панели. Более подробно о возможностях использования класса CDialogBar мы расскажем несколько позже, а сейчас остановим свое внимание на классе CToolBar.
   Кнопки панели управления могут работать как обычные кнопки, как переключатели и как переключатели с зависимой фиксацией. Тип кнопок панели управления выбирается методами класса CToolBar.
   Чтобы создать панель управления, сначала необходимо определить объект класса CToolBar, который будет представлять данную панель. Если панель имеет много органов управления, можно наследовать от класса CToolBar новый класс, расширить его дополнительными методами, и использовать полученный класс вместо класса CToolBar.
   Объект CToolBar обычно включают как элемент главного окна приложения. Так, например, в приложениях, созданных с помощью средств MFC AppWizard, панель управления объявляется как элемент класса CMainFrame, наследованного от класса CFrameWnd или CMDIFrameWnd (в зависимости от интерфейса приложения). Класс CMainFrame как раз представляет главное окно приложения, внутри которого расположены панели управления, окна просмотра и т. д.
   Конструктор класса CToolBar не имеет параметров:
   CToolBar();
   После того как объект класса CToolBar создан, следует вызвать метод Create, который создает панель управления. В качестве параметров, методу Create указываются различные характеристики создаваемой панели:
   BOOL Create(CWnd* pParentWnd, DWORD dwStyle = WS_CHILD | WS_VISIBLE | CBRS_TOP, UINT nID = AFX_IDW_TOOLBAR);
   Только первый параметр метода pParentWnd является обязательным. В нем надо указать идентификатор родительского окна для панели управления. В качестве такого окна обычно выступает главное окно приложения, элементом класса которого является объект класса CToolBar.
   Второй параметр метода dwStyle не обязательный, но именно он определяет, как будет отображаться панель управления. В качестве параметра pParentWnd можно указать комбинацию флагов, представленных в следующей таблице.

Флаг	Описание
CBRS_BOTTOM	Панель управления отображается в нижней части окна
CBRS_FLOATING	Панель управления отображается в отдельном окне
CBRS_FLYBY	Панель состояния отображает краткое описание выбранной кнопки. Конечно, для этого как минимум необходимо, чтобы окно, в котором располагается панель управления, также имело панель состояния и чтобы для кнопок панели были определены соответствующие строковые ресурсы
CBRS_SIZE_DYNAMIC	Размер панели управления можно изменять. При этом кнопки в панели управления перестраиваются в несколько рядов
CBRS_SIZE_FIXED	Панель состояния имеет фиксированную форму (размер)
CBRS_TOOLTIPS	Для кнопок панели управления отображаются их краткие описания в окнах tool tips
CBRS_TOP	Панель управления отображается в верхней части окна

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

   Приложения, созданные MFC AppWizard, имеют меню View, содержащее строки Toolbar и Status bar. Строка Toolbar с идентификатором ID_VIEW_TOOLBAR позволяет закрывать и снова открывать панель управления. Обработка стандартного командного сообщения ID_VIEW_TOOLBAR выполняется методом OnUpdateControlBarMenu класса CFrameWnd. Сразу отметим, что метод OnUpdateControlBarMenu может управлять отображением панели управления только в том случае, если она имеет идентификатор AFX_IDW_TOOLBAR. Более подробно о методе OnUpdateControlBarMenu можно прочитать в разделе “Недокументированные возможности класса CMainFrame”.

   Метод Create возвращает ненулевое значение в случае успешного создания панели или нуль в случае ошибки.
   После того как вы создали панель управления, надо загрузить ресурс панели управления. Для этого предназначен метод LoadToolBar класса CToolBar. Метод LoadToolBar имеет две реализации:
   BOOL LoadToolBar(LPCTSTR lpszResourceName);
   BOOL LoadToolBar(UINT nIDResource);
   В качестве параметра lpszResourceName следует указать имя ресурса панели управления. Если вы знаете идентификатор ресурса панели управления, используйте второй прототип метода и укажите идентификатор в качестве параметра nIDResource.
   Если загрузка ресурса прошла успешно, метод LoadToolBar возвращает ненулевое значение. В случае ошибки возвращается нуль.
   В Microsoft Visual C++ версии 2.х и более ранних версиях ресурс типа toolbar отсутствует. Вместо этого ресурса в файле ресурсов приложения записывалось только изображение кнопок панели управления. А вместо метода LoadToolBar класса CToolBar использовались вызовы двух других методов этого же класса – LoadBitmap и SetButtons.
   Метод LoadBitmap загружал из ресурсов приложения изображение кнопок панели управления, а метод SetButtons устанавливал соответствие каждой кнопке панели управления ее изображения и идентификатора. Так как при создании новых приложений лучше использовать новый метод для отображения панелей управления, предполагающий работу с ресурсами toolbar и методом LoadToolBar, то мы не будем останавливаться на методах LoadBitmap и SetButtons.
   На этом создание панели управления можно считать оконченным. Теперь ваше приложение имеет полноценную панель управления. Однако стоит изучить еще несколько методов класса CToolBar и его базового класса CControlBar , которые помогут сделать панель управления еще более удобной для пользователя.

Метод SetBarStyle класса CControlBar

   Во время создания панели управления вы можете указать ее характеристики через параметр dwStyle метода Create. Если вам потребовалось изменить эти характеристики уже во время работы приложения – используйте метод SetBarStyle. Метод SetBarStyle определен в классе CControlBar, который является базовым для класса CToolBar:
   void SetBarStyle(DWORD dwStyle);
   Параметр dwStyle задает новые характеристики панели управления. В качестве этого параметра можно использовать комбинацию флагов, представленных в следующей таблице.

Флаг	Описание
CBRS_ALIGN_TOP	Панель управления можно пристыковать к верхней границе окна
CBRS_ALIGN_BOTTOM	Панель управления можно пристыковать к нижней границе окна
CBRS_ALIGN_LEFT	Панель управления можно пристыковать к левой границе окна
CBRS_ALIGN_RIGHT	Панель управления можно пристыковать к правой границе окна
CBRS_ALIGN_ANY	Панель управления можно пристыковать к любой границе окна
CBRS_TOOLTIPS	Для кнопок панели управления отображаются их краткие описания в окнах tool tips
CBRS_FLYBY	Панель состояния отображает краткое описание выбранной кнопки

Метод GetBarStyle класса CControlBar

   Чтобы определить текущие характеристики панели управления, используйте метод GetBarStyle класса CControlBar. Метод GetBarStyle возвращает комбинацию флагов. Подробное описание флагов смотрите выше, в описании метода SetBarStyle:
   DWORD GetBarStyle();
   Перед тем как продолжить изучение панелей управления, приведем приложение Bar, которое имеет панель управления, состоящую из нескольких кнопок.

   Вы уже знаете, насколько просто добавить новые кнопки к панели управления, если приложение создано с помощью средств автоматизированной разработки MFC AppWizard. Однако приложение, подготовленное MFC AppWizard, достаточно многофункционально и состоит из нескольких сотен строк программного кода.
   Чтобы подробнее разобраться с устройством и возможностями панелей управления, гораздо лучше взять маленькое приложение, программный код которого можно охватить буквально одним взглядом. Возьмем за основу приложение MFStart с одним единственным окном, представленное нами в первой книге серии “Библиотека системного программиста”, посвященной программированию в Microsoft Visual C++ с применением классов MFC.

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

   Создайте новый проект под названием Bar. В качестве типа приложения выберите из списка Type строку Application. Выберите из меню Build строку Settings или нажмите комбинацию клавиш <Alt+F7>. На экране появится диалоговая панель Project Settings. В этой панели расположены несколько страниц, позволяющих настроить различные характеристики проекта.
   Откройте страницу General. Выберите из списка Microsoft Foundation Classes строку Use MFC in a Shared Dll или строку Use MFC in a Static Library. Эта настройка указывает Microsoft Visual C++, что в приложении используются классы библиотеки MFC.
   Наберите в редакторе исходный текст приложения и сохраните его в файле Bar.cpp (листинг 3.4). Затем включите этот файл в проект. Для простоты мы включили в один файл весь программный код приложения.

Листинг 3.4. Файл Bar.cpp

   //============================================================
   // Приложение Bar
   // (c) Frolov G.V., 1996
   // E-mail: frolov@glas.apc.org
   //============================================================
   // Исключаем редко используемые определения из
   // включаемых файлов
   #define VC_EXTRALEAN
 
   // Включаемый файл для MFC
   #include <afxwin.h>
   #include <afxext.h>
   #include <afxcmn.h>
 
   // Включаемый файл для ресурсов приложения
   #include "resource.h"
 
   //============================================================
   // Класс CBarApp - главный класс приложения
   //============================================================
   class CBarApp : public CWinApp {
   public:
    // Мы будем переопределять метод InitInstance,
    // предназначенный для инициализации приложения
    virtual BOOL InitInstance();
   };
 
   // Создаем объект приложение класса CBarApp
   CBarApp MyBarApp;
 
   //============================================================
   // Класс CBarWindow - представляет главное окно
   //============================================================
   class CBarWindow : public CFrameWnd {
 
   protected:  // control bar embedded members
    CToolBar    m_wndToolBar;
 
   protected:
    afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
 
   public:
    // Объявляем конструктор класса CBarWindow
    CBarWindow();
 
    // Объявляем методы для обработки команд меню
    afx_msg void BarCommand();
 
    // Макрокоманда необходима, так как класс
    // CBarWindow обрабатывает сообщения
    DECLARE_MESSAGE_MAP()   
   };
 
   //============================================================
   // Метод BarCommand
   // Обрабатывает команду ID_TEST_BEEP
   //============================================================
   void CBarWindow::BarCommand() {
    MessageBox("Command not implemented");
   }
 
   //============================================================
   // Таблица сообщений класса CBarWindow
   //============================================================
   BEGIN_MESSAGE_MAP(CBarWindow, CFrameWnd)
    ON_WM_CREATE()
    ON_COMMAND(ID_FILE_OPEN, CBarWindow::BarCommand)
    ON_COMMAND(ID_FILE_SAVE, CBarWindow::BarCommand)
    ON_COMMAND(ID_TOOL_EXIT, CBarWindow::BarCommand)
   END_MESSAGE_MAP()
 
   //============================================================
   // Метод InitInstance класса CBarApp
   //============================================================
   BOOL CBarApp::InitInstance() {
    // Создаем объект класса CBarWindow
    m_pMainWnd = new CBarWindow();
 
    // Отображаем окно на экране
    m_pMainWnd->ShowWindow(m_nCmdShow);
 
    // Обновляем содержимое окна
    m_pMainWnd->UpdateWindow();
    return TRUE;
   }
 
   //============================================================
   // Конструктор класса CBarWindow
   //============================================================
   CBarWindow::CBarWindow() {
    // Создаем окно приложения, соответствующее
    // данному объекту класса CBarWindow
    Create(NULL, "Hello MFC", WS_OVERLAPPEDWINDOW, rectDefault, NULL);
   }
 
   //============================================================
   // Метод OnCreate класса CBarWindow
   // Вызывается во время создания окна приложения
   //============================================================
   int CBarWindow::OnCreate(LPCREATESTRUCT lpCreateStruct) {
    // Вызываем метод OnCreate базового класса
    if (CFrameWnd::OnCreate(lpCreateStruct) == -1) return -1;
 
    // Создаем панель управления toolbar. В качестве
    // родительского окна указываем окно CBarWindow
    if (!m_wndToolBar.Create(this)) {
     // Ошибка при создании панели управления
     TRACE0("Failed to create toolbar\n");
     return -1;
    }
 
    if (!m_wndToolBar.LoadToolBar(IDR_MAINFRAME)) {
     // Ошибка при загрузке ресурса панели управления
     TRACE0("Failed to load toolbar\n");
     return -1;
    }
 
    return 0;
   }
   Теперь необходимо создать ресурс панели управления toolbar. Вы можете сделать это несколькими способами – создать панель управления “с нуля” или скопировать уже готовую панель управления из другого приложения, например из приложения Multi, представленного в главе “Многооконное приложение”.
   Перед тем как приступить к разработке панели управления, создайте файл ресурсов и включите его в проект. Для этого выберите из меню File строку New. Из открывшейся диалоговой панели New выберите строку Resource Script и нажмите на кнопку OK. Будет создан пустой файл ресурсов. Сохраните его в каталоге приложения под именем Bar.rc и включите в проект.

Создание новой панели управления

   Выберите из меню Insert строку Resource, а затем из открывшейся диалоговой панели Insert Resource выберите строку Toolbar и нажмите на кнопку OK.
   Запустится редактор ресурсов и в нем будет загружена новая панель управления. Создайте панель управления, постепенно добавляя к ней по одной кнопке. Для каждой кнопки нарисуйте ее изображение, а также присвойте ей уникальный идентификатор и строку описания (см. раздел “Редактор панели управления”).
   При создании панелей управления руководствуйтесь информацией из файла ресурсов приложения Bar (листинг 3.5) и изображениями кнопок панелей управления (рис. 3.9).
   Панель управления приложения Bar должна иметь идентификатор IDR_MAINFRAME. В ней следует расположить девять кнопок с идентификаторами ID_FILE_NEW, ID_FILE_OPEN, ID_FILE_SAVE, ID_EDIT_CUT, ID_EDIT_COPY, ID_EDIT_PASTE, ID_FILE_PRINT, ID_APP_ABOUT и ID_TOOL_EXIT.
   Между кнопками ID_FILE_SAVE и ID_EDIT_CUT, ID_EDIT_PASTE и ID_FILE_PRINT, вставьте разделители. Для каждой из кнопок вы также можете ввести их текстовые описания.
   Сохраните измененный файл ресурсов.

Копирование панели управления

   Чтобы ускорить процесс разработки панели управления приложения Bar, можно взять за основу панели управления ресурс toolbar приложения Multi, созданного с использованием средств MFC AppWizard. Мы описывали приложение Multi в разделе “Многооконное приложение”.
   Не закрывая проект Bar и файл ресурсов Bar.rc, откройте файл ресурсов приложения Multi. Выберите панель управления toolbar и запишите ее в буфер clipboard. Затем вставьте эту панель в файл ресурсов приложения Bar – Bar.rc.
   Оставьте название панели toolbar, изображения кнопок, их идентификаторы и текстовые описания без изменения. Добавьте в конце панели еще одну кнопку, и присвойте ей идентификатор IDTOOLEXIT. Введите текстовое описание кнопки – строку Exit\nExit.
   Сохраните измененный файл ресурсов приложения Bar и закройте файл ресурсов приложения Multi без изменений. Исходный текст файла ресурсов Bar.rc представлен в листинге 3.5.

Листинг 3.5. Файл Bar.rc

   //Microsoft Developer Studio generated resource script.
   //
   #include "resource.h"
 
   #define APSTUDIO_READONLY_SYMBOLS
   //////////////////////////////////////////////////////////////
   //
   // Generated from the TEXTINCLUDE 2 resource.
   //
   #include "afxres.h"
 
   //////////////////////////////////////////////////////////////
   #undef APSTUDIO_READONLY_SYMBOLS
 
   //////////////////////////////////////////////////////////////
   //
   // Russian resources
 
   #if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_RUS)
   #ifdef _WIN32
   LANGUAGE LANG_RUSSIAN, SUBLANG_DEFAULT
   #pragma code_page(1251)
   #endif //_WIN32
 
   #ifdef APSTUDIO_INVOKED
   //////////////////////////////////////////////////////////////
   //
   // TEXTINCLUDE
   //
 
   1 TEXTINCLUDE DISCARDABLE
   BEGIN
    "resource.h\0"
   END
 
   2 TEXTINCLUDE DISCARDABLE
   BEGIN
    "#include ""afxres.h""\r\n"
    "\0"
   END
 
   3 TEXTINCLUDE DISCARDABLE
   BEGIN
    "\r\n"
    "\0"
   END
 
   #endif    // APSTUDIO_INVOKED
 
   #endif    // Russian resources
   //////////////////////////////////////////////////////////////
 
   //////////////////////////////////////////////////////////////
   // English (U.S.) resources
 
   #if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
   #ifdef _WIN32
   LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
   #pragma code_page(1252)
   #endif //_WIN32
 
   //////////////////////////////////////////////////////////////
   //
   // Toolbar
   //
 
   IDR_MAINFRAME TOOLBAR DISCARDABLE  16, 15
   BEGIN
    BUTTON ID_FILE_NEW
    BUTTON ID_FILE_OPEN
    BUTTON ID_FILE_SAVE
    SEPARATOR
    BUTTON ID_EDIT_CUT
    BUTTON ID_EDIT_COPY
    BUTTON ID_EDIT_PASTE
    SEPARATOR
    BUTTON ID_FILE_PRINT
    BUTTON ID_APP_ABOUT
    BUTTON ID_TOOL_EXIT
   END
 
   //////////////////////////////////////////////////////////////
   //
   // Bitmap
   //
   IDR_MAINFRAME BITMAP MOVEABLE PURE "res\\Toolbar.bmp"
 
   //////////////////////////////////////////////////////////////
   //
   // String Table
   //
 
   STRINGTABLE DISCARDABLE
   BEGIN
    ID_TOOL_EXIT "Exit\nExit"
   END
 
   #endif // English (U.S.) resources
   //////////////////////////////////////////////////////////////
 
 
   #ifndef APSTUDIO_INVOKED
   //////////////////////////////////////////////////////////////
   // Generated from the TEXTINCLUDE 3 resource.
   //
 
   //////////////////////////////////////////////////////////////
   #endif // not APSTUDIO_INVOKED
   Идентификаторы всех ресурсов приложения Bar определены в файле resource.h. Этот файл создается автоматически редактором ресурсов Microsoft Visual C++ (листинг 3.6).
   Листинг 3.6. Файл resource.h
   //{{NO_DEPENDENCIES}}
   // Microsoft Developer Studio generated include file.
   // Used by Bar.rc
   //
   #define IDR_HAND_BAR   101
   #define IDR_MAINFRAME  128
   #define ID_TOOL_EXIT   32771
   #define ID_BUTTON40001 40001
   #define ID_BUTTON40002 40002
   #define ID_BUTTON40003 40003
   #define ID_BUTTON40004 40004
   #define ID_BUTTON40005 40005
   #define ID_FILE_NEW    0xE100
   #define ID_FILE_OPEN   0xE101
   #define ID_FILE_SAVE   0xE103
   #define ID_FILE_PRINT  0xE107
   #define ID_EDIT_COPY   0xE122
   #define ID_EDIT_CUT    0xE123
   #define ID_EDIT_PASTE  0xE125
   #define ID_APP_ABOUT   0xE140
 
   // Next default values for new objects
   //
   #ifdef APSTUDIO_INVOKED
   #ifndef APSTUDIO_READONLY_SYMBOLS
   #define _APS_NEXT_RESOURCE_VALUE 103
   #define _APS_NEXT_COMMAND_VALUE  40006
   #define _APS_NEXT_CONTROL_VALUE  1000
   #define _APS_NEXT_SYMED_VALUE    101
   #endif
   #endif
   Изображения кнопок панели управления IDR_MAINFRAME располагаются в файле Toolbar.bmp (рис. 3.11). Файл Toolbar.bmp содержит только изображения кнопок, разделители SEPARATOR в нем не представлены.
   Рис. 3.11. Файл Toolbar.bmp с изображением кнопок панели управления
 
   Постройте приложение Bar и запустите его на выполнение. На экране появится главное окно приложения, содержащее панель управления (рис. 3.12). Панель управления нельзя переместить в другое место, она жестко зафиксирована в верхней части окна.
   Рис. 3.12. Приложение Bar
 
   Все кнопки, кроме трех, недоступны и отображаются серым цветом.
   При нажатии на первые две доступные кнопки из панели управления на экране появляется сообщение о том, что данная команда недоступна. Если вы нажмете на последнюю кнопку в панели управления, то приложение завершит свою работу.

Как устроено приложение CBarApp

   Обратите внимание на первые строки файла Bar.cpp. Они содержат директивы #include, которые включают в исходный текст два файла – afxwin.h и afxext.h:
   // Включаемый файл для MFC
   #include <afxwin.h>
   #include <afxext.h>
 
   // Включаемый файл для ресурсов приложения
   #include "resource.h"
   С файлом afxwin.h вы уже знакомы. В этом файле определены классы, методы, константы и другие структуры для библиотеки классов MFC. Кроме того, файл afxwin.h автоматически подключает другой включаемый файл – windows.h.
   Файл afxext.h необходим, так как в нем описываются классы, используемые для создания панели управления, в том числе сам класс панели управления – CToolBar.
   Кроме системных файлов afxwin.h и afxext.h, в исходный текст файла Bar.cpp включен файл resource.h. Этот файл создается автоматически редактором ресурсов Microsoft Visual C++ и содержит определение различных идентификаторов приложения.
   В приложении Bar определены два класса CBarApp и CBarWindow. Главный класс приложения CBarApp наследуется от базового класса CWinApp. Объект MyBarApp класса CBarApp объявлен как глобальный и создается сразу после запуска приложения.
   В класс CBarApp входит единственный метод InitInstance. Метод InitInstance создает главное окно приложения, представленное классом CBarWindow, наследованным от класса CFrameWnd.
   Взаимодействие главного класса приложения и главного класса окна приложения мы описывали в первой книге серии “Библиотека системного программиста”, посвященной программированию в Microsoft Visual C++ с использованием библиотеки классов MFC.
   Обратите внимание, что в состав класса CBarWindow входит объект m_wndToolBar класса CToolBar. Именно этот объект и будет представлять панель управления. Включение объекта класса CToolBar в состав класса главного окна приложения вполне закономерно, так как панель управления, точно также как и меню, является атрибутом именно главного окна приложения:
   class CBarWindow : public CFrameWnd {
   protected:
    CToolBar m_wndToolBar;
   // …
   }
   Объект m_wndToolBar, представляющий панель управления, объявлен как protected. Доступ к нему открыт только для методов класса CBarWindow. Если надо открыть доступ к панели управления из вне класса CBarWindow,  тогда ключевое слово protected надо заменить на public.
   В таблице сообщений класса CBarWindow находится макрокоманда ON_WM_CREATE. Поэтому в процессе создания главного окна приложения вызывается метод OnCreate. Мы используем метод OnCreate для создания панели управления.
   Метод OnCreate класса CBarWindow сначала вызывает метод OnCreate базового класса CFrameWnd. Затем создается панель управления toolbar. Для этого вызывается метод Create объекта m_wndToolBar. В качестве указателя на родительское окно панели управления методу Create передается ключевое слово this, указывающее на текущий объект, то есть на главное окно приложения.
   После создания панели управления вызывается метод LoadToolBar, загружающий панель управления с идентификатором IDR_MAINFRAME. Если вы запустите приложение под отладкой, то в случае возникновения ошибок при создании панели управления вызывается макрокоманда TRACE0. Она отображает сообщение об ошибке на странице Debug панели Output. Панель Output обычно располагается в нижней части окна Microsoft Visual C++.
   Каждый раз, когда пользователь нажимает на кнопки в панели управления, в окно приложения, являющееся родительским окном панели управления, поступают командные сообщения. Идентификатор этих командных сообщений соответствует идентификатору нажатой кнопки.
   Чтобы обработать командные сообщения от панели управления, в таблицу сообщений класса CBarWindow включены макрокоманды ON_COMMAND. В приложении Bar мы обрабатываем командные сообщения только от трех кнопок панели управления — ID_FILE_OPEN, ID_FILE_SAVE и ID_TOOL_EXIT:
   //============================================================
   // Таблица сообщений класса CBarWindow
   //============================================================
   BEGIN_MESSAGE_MAP(CBarWindow, CFrameWnd)
 
    // Макрокоманда необходима для перехвата сообщения
    // WM_CREATE. Для обработки сообщения вызывается
    // метод OnCreate
      ON_WM_CREATE()
 
    // Обработка сообщений от кнопок панели управления
    ON_COMMAND(ID_FILE_OPEN, CBarWindow::BarCommand)
    ON_COMMAND(ID_FILE_SAVE, CBarWindow::BarCommand)
    ON_COMMAND(ID_TOOL_EXIT, CBarWindow::BarCommand)
 
   END_MESSAGE_MAP()
   Чтобы не усложнять исходный текст приложения мы вызываем для обработки командных сообщений от кнопок панели управления один и тот же метод BarCommand. Метод BarCommand входит в состав класса CBarWindow. Единственное, что делает метод BarCommand – это выводит на экран сообщение, что данная команда не реализована.
   Конечно, вы можете назначить для каждой кнопки панели управления свой собственный метод обработчик, выполняющий любые определенные вами действия.

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

   Панель управления приложения Bar нельзя переместить с одной границы окна к другой и нельзя разместить ее в отдельном окне, независимом от главного окна приложения. Единственное, что вы можете сделать, так это выбрать начальное положение панели управления, установив в момент вызова метода Create флаг CBRS_TOP или CBRS_BOTTOM.
   Чтобы вы смогли перемещать панель управления с одной границы окна к другой надо:
   1. Разрешить перемещение панели управления для окна, которое содержит панель управления. Для этого следует вызвать метод EnableDocking данного окна. Метод EnableDocking является элементом класса CFrameWnd
   2. Разрешить такое перемещение для самой панели управления. Для этого следует вызвать метод EnableDocking панели управления. Метод EnableDocking является элементом класса CControlBar
   3. Переместить панель управления к одной из сторон окна приложения или вывести ее в отдельном окне. Для этого необходимо вызвать метод DockControlBar или FloatControlBar данного окна приложения. Методы DockControlBar и FloatControlBar являются элементами класса CFrameWnd
   Если в одном окне отображается несколько панелей управления, то вы должны вызвать для этого окна метод EnableDocking, а затем для каждой панели управления в отдельности вызвать методы EnableDocking и DockControlBar (или FloatControlBar).

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

   Параметры методов CFrameWnd::EnableDocking, CControlBar::EnableDocking, а также CFrameWnd::DockControlBar и CFrameWnd::FloatControlBar определяют границы окна, к которым можно пристыковать панель управления. Рассмотрим эти методы более подробно.

Метод EnableDocking класса CFrameWnd

   Метод EnableDocking класса CFrameWnd разрешает пристыковку панели управления к определенным границам окна:
   void EnableDocking(DWORD dwDockStyle);
   Параметр dwDockStyle задает границы окна, к которым можно пристыковать панель управления. В качестве этого параметра надо использовать комбинации из флагов, перечисленных в следующей таблице.

Флаг	Описание
CBRS_ALIGN_TOP	Панель управления можно пристыковать к верхней границе окна
CBRS_ALIGN_BOTTOM	Панель управления можно пристыковать к нижней границе окна
CBRS_ALIGN_LEFT	Панель управления можно пристыковать к левой границе окна
CBRS_ALIGN_RIGHT	Панель управления можно пристыковать к правой границе окна
CBRS_ALIGN_ANY	Панель управления можно пристыковать к любой границе окна

Метод EnableDocking класса CControlBar

   Чтобы панель управления можно было перемещать с одной стороны окна к другой, надо вызвать метод EnableDocking для окна и для каждой панели управления (если их несколько).
   Формат вызова метода EnableDocking класса CFrameWnd соответствует формату метода EnableDocking класса CControlBar. Однако набор флагов, которые можно указать в качестве параметра dwStyle, расширен:
   void EnableDocking(DWORD dwStyle);

Флаг	Описание
CBRS_ALIGN_TOP	Панель управления можно пристыковать к верхней границе окна
CBRS_ALIGN_BOTTOM	Панель управления можно пристыковать к нижней границе окна
CBRS_ALIGN_LEFT	Панель управления можно пристыковать к левой границе окна
CBRS_ALIGN_RIGHT	Панель управления можно пристыковать к правой границе окна
CBRS_ALIGN_ANY	Панель управления можно пристыковать к любой границе окна

   Если ни один из флагов не установлен, и параметр dwStyle равен нулю, то данная панель управления не может быть пристыкована ни к одной границе окна. В этом случае надо вызвать метод CFrameWnd::FloatControlBar и панель управления появится в отдельном мини-окне.
   Панель управления можно пристыковать только к тем границам окна, которые одновременно выбраны методами CFrameWnd::EnableDocking и CControlBar::EnableDocking.

Методы DockControlBar и FloatControlBar класса CFrameWnd

   Чтобы пристыковать панель управления к границе окна, надо вызвать метод DockControlBar класса CFrameWnd :
   void DockControlBar(CControlBar * pBar, UINT nDockBarID = 0, LPCRECT lpRect = NULL);
   Панель управления, заданная параметром pBar, пристыковывается к границе окна, указанной параметром nDockBarID. В качестве nDockBarID можно использовать один или несколько флагов, перечисленных ниже.

Флаг	Описание
AFX_IDW_DOCKBAR_TOP	Панель управления присоединяется к верхней границе окна
AFX_IDW_DOCKBAR_BOTTOM	Панель управления присоединяется к нижней границе окна
AFX_IDW_DOCKBAR_LEFT	Панель управления присоединяется к левой границе окна
AFX_IDW_DOCKBAR_RIGHT	Панель управления присоединяется к правой границе окна

   Если параметр nDockBarID равен нулю, то панель управления присоединяется к любой стороне окна.
   Как видите, параметр nDockBarID может задавать несколько сторон окна одновременно. В этом случае панель управления присоединяется к той границе окна, которая одновременно указана методами CFrameWnd::EnableDocking и CControlBar::EnableDocking. Если таких границ несколько, то они выбираются в следующем порядке – сначала верхняя, а если к ней панель не может быть присоединена, тогда нижняя, левая, и правая стороны окна.
   Последний параметр lpRect определяет, где именно будет отображаться панель управления. Положение панели задается в экранных координатах.
   Если вам надо отобразить панель управления в отдельном мини-окне и не пристыковывать его к границам окна, то вместо метода DockControlBar вызовите метод FloatControlBar класса CFrameWnd:
   CFrameWnd* FloatControlBar(CControlBar * pBar, CPoint point);
   Панель управления, указанная параметром pBar, отображается в отдельном мини-окне. Расположение окна панели управления задается параметром point, который указывает координаты верхнего левого угла панели управления. Используются экранные координаты.
   Метод FloatControlBar возвращает указатель на текущее окно.
   По умолчанию, панель управления не имеет заголовка. Для установки и изменения текста заголовка используйте метод SetWindowText, определенный в классе CWnd:
   void SetWindowText(LPCTSTR lpszString);
   Параметр lpszString должен содержать указатель на объект класса CString или строку символов, закрытую двоичным нулем. В ней должен быть записан заголовок для панели управления.

   Панель управления может иметь постоянную форму, которую пользователь не может изменить, или может быть динамически изменяемой. В последнем случае пользователь может менять форму панели управления с помощью мыши.
   Можно изменить форму панели управления или нет, определяется методом Create класса CToolBar. Если при создании панели управления был установлен флаг CBRS_SIZE_DYNAMIC ее форму можно менять, а если был установлен флаг CBRS_SIZE_FIXED — нельзя.
   В состав класса CToolBar входит метод SetButtonStyle. Этот метод позволяет определить режим работы кнопок панели управления, сгруппировать несколько кнопок вместе:
   void SetButtonStyle(int nIndex, UINT nStyle);
   Параметр nIndex выбирает индекс кнопки или разделителя в панели управления, а параметр nStyle позволяет установить новый режим работы для выбранной кнопки или разделителя. Индекс кнопки или разделителя соответствует ее порядковому номеру в панели управления.
   В качестве параметра nStyle можно указать комбинацию из следующих флагов:

Флаг	Режим кнопки или разделителя
TBBS_BUTTON	Стандартная кнопка
TBBS_SEPARATOR	Разделитель
TBBS_CHECKBOX	Переключатель
TBBS_GROUP	С данной кнопки начинается группа кнопок
TBBS_CHECKGROUP	С данной кнопки начинается группа переключателей
TBBS_WRAPPED	Этот флаг позволяет создать панель управления, в которой кнопки расположены в несколько рядов. Установите этот флаг для самых последних кнопок в каждом ряду. Кнопка, следующая за кнопкой с установленным флагом TBBS_WRAPPED, отображается в новом ряду

   Заметим, что стиль TBBS_WRAPPED не описан в документации Microsoft Visual C++, но активно используется в примерах приложений и работает как положено

   Перед тем, как изменить режим работы кнопки или указать группу кнопок, рекомендуется определить текущий режим кнопки. Для этого следует воспользоваться методом GetButtonStyle класса CToolBar:
   UINT GetButtonStyle(int nIndex) const;
   Метод возвращает комбинацию флагов, определяющих режим работы кнопки с индексом nIndex. Мы уже рассматривали эти флаги при описании метода SetButtonStyle класса CToolBar.
   Вы можете определить индекс (порядковый номер) любой кнопки панели управления, если знаете ее идентификатор. Для этого предназначен метод CommandToIndex класса CToolBar. Он возвращает индекс кнопки, имеющей идентификатор nIDFind. Если вы укажите идентификатор несуществующей кнопки, тогда метод CommandToIndex возвращает значение –1:
   int CommandToIndex(UINT nIDFind);
   Обратную задачу выполняет метод GetItemID класса CToolBar. Этот метод возвращает идентификатор кнопки с индексом nIndex. Если в качестве параметра nIndex указать индекс разделителя, тогда метод GetItemID возвращает идентификатор ID_SEPARATOR:
   UINT GetItemID(int nIndex) const;

   Панель управления, созданная на основе класса CToolBar, состоит из одних только кнопок и разделителей. Стандартные средства для отображения в ней других органов управления, таких как поле редактирование или список, отсутствуют.
   Однако, вы все же можете вывести в панели toolbar другие органы управления. Так как панель управления является ни чем иным как дочерним окном, то вы можете самостоятельно разместить в нем другие органы управления.
   Для этого предлагается использовать следующий метод.
   • В том месте панели управления toolbar, где вы желаете разместить дополнительный орган управления, вставьте разделитель
   • Сразу после создания панели управления, измените размер разделителя вместо которого надо вставить другой орган управления. Присвойте ему другой идентификатор
   • Создаем на месте разделителя нужный вам орган управления. Указываем, для него в качестве родительского окна – идентификатор панели управления
   В состав класса CToolBar входит метод SetButtonInfo. Этот метод позволяет изменить внешний вид панели управления. Используя метод SetButtonInfo, можно изменить идентификатор, изображение, режим работы и размер разделителей кнопок панели управления:
   void SetButtonInfo(int nIndex, UINT nID, UINT nStyle, int iImage);
   Параметр nIndex метода SetButtonInfo определяет индекс кнопки или разделителя. Остальные параметры задают новые характеристики для этой кнопки.
   Параметр nID позволяет задать новый идентификатор кнопки или разделителя.
   Параметр nStyle определяет режимы работы данной кнопки и может содержать комбинацию флагов, которые уже были нами представлены при описании метода SetButtonStyle класса CToolBar.
   Последний параметр метода позволяет изменить изображение кнопки. Новое изображение берется из ресурса панели управления. При этом используется изображение с порядковым номером, заданным параметром iImage.
   Если вы вызвали метод SetButtonInfo и указали ему через параметр nIndex индекс разделителя, то назначение параметра iImage изменяется. В этом случае параметр iImage будет определять новую ширину разделителя.
   Перед тем как изменять характеристики кнопок панели управления, вы можете воспользоваться методом GetButtonStyle класса CToolBar, чтобы узнать текущие характеристики кнопки:
   void GetButtonInfo(int nIndex, UINT& nID, UINT& nStyle, int& iImage) const;
   В параметре nIndex надо указать индекс кнопки, о которой надо получить информацию. Через остальные три параметра методу GetButtonInfo передаются ссылки на переменные, в которые будут записаны характеристики кнопок.
   Через параметр nID вы получите идентификатор кнопки, через параметр nStyle – режим ее работы, а через параметр iImage – индекс изображения кнопки в ресурсе панели управления.
   Если метод GetButtonInfo вызывается для разделителя, то через параметр iImage вы получите не индекс изображения, а ширину разделителя в пикселах.
   Когда вы создаете на панели управления дополнительный орган управления, например поле редактирования, вы должны указать координаты прямоугольной области которую он будет занимать. Для определения этих координат следует воспользоваться методом GetItemRect класса CToolBar:
   virtual void GetItemRect(int nIndex, LPRECT lpRect);
   Вызов метода GetItemRect заполняет структуру lpRect координатами прямоугольной области, занимаемой кнопкой или разделителем, с индексом nIndex.

   Изучая пример приложения DOCKTOOL, поставляемого вместе с Microsoft Visual C++, мы обнаружили, что для отображения и удаления с экрана панелей управления используется метод OnBarCheck.
   Метод вызывается из таблицы сообщений класса главного окна приложения CMainFrame. Для этого используется макрокоманда ON_COMMAND_EX. В случае прихода командных сообщений от строк меню, отвечающих за показ на экране панелей управления, вызывается метод OnBarCheck и ему в качестве параметра передается идентификатор соответствующей строки меню:
   BEGIN_MESSAGE_MAP(CMainFrame, CFrameWnd)
    // Другие макрокоманды таблицы сообщений
    ON_COMMAND_EX(IDW_BROWSE_BAR, OnBarCheck)
    ON_COMMAND_EX(IDW_DEBUG_BAR, OnBarCheck)
    ON_COMMAND_EX(IDW_EDIT_BAR, OnBarCheck)
   END_MESSAGE_MAP()
   Таким образом, когда пользователь выбирает из меню View приложения строку с именем панели управления, выдается командное сообщение с идентификатором, соответствующим строке меню и самой панели управления (идентификаторы панелей управления идентичны идентификаторам соответствующих строк меню View). Командное сообщение обрабатывается таблицей сообщений класса CMainFrame. Для его обработки вызывается метод OnBarCheck, которому в качестве параметра передается идентификатор панели управления.
   Если вы решите поискать описание метода OnBarCheck в справочной системе Microsoft Visual C++, вас ждет разочарование. Ни в класс CFrameWnd, ни в один из его базовых классов метод OnBarCheck не входит. Когда вы вернетесь к исходным текстам самого приложения, в них вы также не обнаружите определение этого метода.
   Мы проявили настойчивость и смогли обнаружить метод OnBarCheck только в исходных текстах библиотеки классов MFC. Оказывается, несмотря на отсутствие описания метода OnBarCheck в документации библиотеки MFC, этот метод входит в хорошо известный вам класс CFrameWnd.
   В файле Afxwin.h, в котором объявлен класс CFrameWnd, вы можете найти объявления входящих в него методов OnUpdateControlBarMenu и OnBarCheck:
   class CFrameWnd : public CWnd {
   // ...
   // Command Handlers
   public:
    afx_msg void OnUpdateControlBarMenu(CCmdUI* pCmdUI);
    afx_msg BOOL OnBarCheck(UINT nID);
   }
   Определения исходных текстов методов OnUpdateControlBarMenu и OnBarCheck содержатся в файле Winfrm.cpp.
   В файле Winfrm.cpp также можно найти обращения к методам OnUpdateControlBarMenu и OnBarCheck в таблице сообщений класса CFrameWnd. Приведем соответствующий фрагмент этой таблицы:
   BEGIN_MESSAGE_MAP(CFrameWnd, CWnd) 
    // turning on and off standard frame gadgetry
    ON_UPDATE_COMMAND_UI(ID_VIEW_STATUS_BAR, OnUpdateControlBarMenu)
    ON_COMMAND_EX(ID_VIEW_STATUS_BAR, OnBarCheck)
    ON_UPDATE_COMMAND_UI(ID_VIEW_TOOLBAR, OnUpdateControlBarMenu)
    ON_COMMAND_EX(ID_VIEW_TOOLBAR, OnBarCheck)
   END_MESSAGE_MAP()
   Две пары макрокоманд ON_UPDATE_COMMAND_UI и ON_COMMAND_EX вызывают методы OnUpdateControlBarMenu и OnBarCheck для обработки командных сообщений с идентификаторами ID_VIEW_STATUS_BAR и ID_VIEW_TOOLBAR. Командные сообщения с такими идентификаторами поступают при выборе строк Toolbar и Status Bar меню View.
   Меню View, содержащее строки Toolbar и Status Bar, вставляется во все приложения с оконным интерфейсом, которые созданы с использованием средств MFC AppWizard.
   Рассмотрим теперь сами методы OnBarCheck и OnUpdateControlBarMenu. Метод OnBarCheck класса CFrameWnd определен следующим образом:
   //////////////////////////////////////////////////////////////
   // Метод OnBarCheck класса CFrameWnd
   BOOL CFrameWnd::OnBarCheck(UINT nID){
    ASSERT(ID_VIEW_STATUS_BAR == AFX_IDW_STATUS_BAR);
    ASSERT(ID_VIEW_TOOLBAR == AFX_IDW_TOOLBAR);
 
    CControlBar* pBar = GetControlBar(nID);
    if (pBar != NULL) {
     ShowControlBar(pBar, (pBar->GetStyle() & WS_VISIBLE) == 0, FALSE);
     return TRUE;
    }
    return FALSE;
   }
   Отладочная версия метода OnBarCheck класса CFrameWnd проверяет соответствие идентификаторов ID_VIEW_STATUS_BAR, AFX_IDW_STATUS_BAR и ID_VIEW_TOOLBAR, AFX_IDW_TOOLBAR. Отметим, что эти идентификаторы определены в файле Afxres.h следующим образом:
   #define AFX_IDW_TOOLBAR    0xE800
   #define AFX_IDW_STATUS_BAR 0xE801
 
   #define ID_VIEW_TOOLBAR    0xE800
   #define ID_VIEW_STATUS_BAR 0xE801
   Метод GetControlBar класса CFrameWnd определяет указатель на объект класса CControlBar, который представляет панель управления или панель состояния с идентификатором nID. Идентификаторы строк меню ID_VIEW_TOOLBAR и ID_VIEW_STATUS_BAR соответствуют стандартным идентификаторам панели управления AFX_IDW_TOOLBAR и панели состояния AFX_IDW_STATUS_BAR. 
   При выборе из меню View строки Toolbar передается командное сообщение ID_VIEW_TOOLBAR, а при выборе строки Status bar — сообщение ID_VIEW_STATUS_BAR. Во время обработки этих сообщений, вызов метода GetControlBar определит объект класса CControlBar, соответствующий либо панели управления AFX_IDW_TOOLBAR, либо панели состояния AFX_IDW_STATUS_BAR.
   Затем метод ShowControlBar отображает или закрывает соответствующую панель. Если панель была открыта, метод ShowControlBar скрывает ее и наоборот.
   Аналогичным образом устроен метод OnUpdateControlBarMenu класса CFrameWnd, который обрабатывает команды обновления (по умолчанию, он обрабатывает команды обновления от строк Toolbar и Status bar меню View).
   Метод OnUpdateControlBarMenu проверяет, отображается ли на экране панель управления или панель состояния с идентификатором, соответствующим идентификатору команды обновления. Если панель отображается, то строка меню отмечается символом √:
   //////////////////////////////////////////////////////////////
   // Метод OnUpdateControlBarMenu класса CFrameWnd
   void CFrameWnd::OnUpdateControlBarMenu(CCmdUI* pCmdUI){
    ASSERT(ID_VIEW_STATUS_BAR == AFX_IDW_STATUS_BAR);
    ASSERT(ID_VIEW_TOOLBAR == AFX_IDW_TOOLBAR);
 
    CControlBar* pBar = GetControlBar(pCmdUI->m_nID);
    if (pBar != NULL)   {
     pCmdUI->SetCheck((pBar->GetStyle() & WS_VISIBLE) != 0);
     return;
    }
    pCmdUI->ContinueRouting();
   }
   В конце метода OnUpdateControlBarMenu класса CFrameWnd вызывается метод ContinueRouting класса CCmdUI, который направляет команду обновления для дальнейшей обработки другим классам MFC (см. раздел “ Обработка командных сообщений ”).

   Создайте новый проект под названием MultiBar. В качестве типа приложения выберите из списка Type строку Application. Настройте проект MultiBar, точно также как вы настраивали проект Bar – укажите, что приложение будет работать с библиотекой классов MFC.
   Наберите в редакторе исходный текст приложения и сохраните его в файле MultiBar.cpp (листинг 3.7). За основу вы можете взять файл Bar.cpp приложения Bar. Включите готовый файл MultiBar.cpp в проект.

Листинг 3.7. Файл MultiBar.cpp

   //============================================================
   // Приложение MultiBar
   // (c) Frolov G.V., 1996
   // E-mail: frolov@glas.apc.org
   //============================================================
   // Исключаем редко используемые определения из
   // включаемых файлов
   #define VC_EXTRALEAN
 
   // Включаемый файл для MFC
   #include <afxwin.h>
   #include <afxext.h>
   #include <afxcmn.h>
 
   // Включаемый файл для ресурсов приложения
   #include "resource.h"
 
   //============================================================
   // Класс CMultiBarApp - главный класс приложения
   //============================================================
   class CMultiBarApp : public CWinApp {
   public:
    // Мы будем переопределять метод InitInstance
    virtual BOOL InitInstance();
   };
 
   // Создаем объект приложение класса CMultiBarApp
   CMultiBarApp MultiBarApp;
 
   //============================================================
   // Класс CExtendedBar - класс панели управления Extended
   //============================================================
   class CExtendedBar : public CToolBar {
   public:
    // Дополнительные органы управления панели Extended
    CEdit m_edit;          // текстовый редактор
    CComboBox m_combo_box; // список с текстовым редактором
   };
 
   //============================================================
   // Класс CMultiBarWindow - представляет главное окно
   //============================================================
   class CMultiBarWindow : public CFrameWnd {
   // Определяем панели управления
   protected:
    // Панель управления Player
    CToolBar m_wndPlayerBar;
    // Панель управления Style
    CToolBar m_wndStyleBar;
    // Панель управления Extended
    CExtendedBar m_wndExtendedBar;
 
   protected:
    // Метод OnCreate используется для создания
    // панелей управления
    afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
 
   public:
    // Объявляем конструктор класса CMultiBarWindow
    CMultiBarWindow();
 
    // Объявляем методы для обработки команд от панелей
    // управления
    afx_msg void BarCommandOne();
    afx_msg void BarCommandRange(UINT nID);
    afx_msg void AddStringToComboBox();
 
    // Объявляем метод для обработки команд от меню View
    afx_msg BOOL ShowStyle(UINT nID);
 
    // Макрокоманда необходима, так как класс
    // CMultiBarWindow обрабатывает сообщения
    DECLARE_MESSAGE_MAP()   
   };
 
   //============================================================
   // Метод BarCommandRange
   // Обрабатывает команды от панели управления
   //============================================================
   void CMultiBarWindow::BarCommandRange(UINT nID) {
    // Обработчик не выполняет никакой работы
   }
   //============================================================
   // Метод BarCommand
   // Обрабатывает команды от кнопок панелей управления
   //============================================================
   void CMultiBarWindow::BarCommandOne() {
    // Отображаем сообщение о том, что команда не реализована
    MessageBox("Command not implemented");
   }
 
   //============================================================
   // Метод AddStringToComboBox
   // Обрабатывает команду от кнопки Add панели
   // управления Extended
   //============================================================
   void CMultiBarWindow::AddStringToComboBox() {
    // Получаем строку, введенную в текстовом редакторе m_edit
    char  tmpStr[39];
    m_wndExtendedBar.m_edit.GetLine(0, tmpStr,40);
 
    // Добавляем новую строку к списку m_combo_box
    m_wndExtendedBar.m_combo_box.AddString(tmpStr);
   }
 
   //============================================================
   // Метод ShowStyle
   // Обрабатывает команды от меню View
   //============================================================
   BOOL CMultiBarWindow::ShowStyle(UINT nID) {
    // Определяем указатель на панель управления,
    // соответствующую идентификатору nID
    CControlBar* pBar = GetControlBar(nID);
 
    // Определяем, отображается в данный момент панель
    // управления на экране или нет
    BOOL bShow = ((pBar->GetStyle() & WS_VISIBLE) != 0);
 
    // Изменяем состояние панели управления: если панель
    // управления отображается на экране, удаляем ее с экрана,
    // если нет - отображаем
    ShowControlBar(pBar, !bShow, FALSE);
 
    return TRUE;
   }
   //============================================================
   // Таблица сообщений класса CMultiBarWindow
   //============================================================
   BEGIN_MESSAGE_MAP(CMultiBarWindow, CFrameWnd)
 
    // Макрокоманда вызывает метод OnCreate
    ON_WM_CREATE()
 
    // Обработчики команд от панели управления Player
    ON_COMMAND(ID_STOP, BarCommandOne)
    ON_COMMAND(ID_PLAY, BarCommandOne)
    ON_COMMAND(ID_PAUSE, BarCommandOne)
    ON_COMMAND_RANGE(ID_LEFT, ID_RIGHT, BarCommandRange)
    ON_COMMAND_RANGE(ID_TYPE, ID_WAVE,  BarCommandRange)
 
    // Обработчики команд от панели управления Extended
    ON_COMMAND(ID_ADD, AddStringToComboBox)
    ON_COMMAND_RANGE(ID_FOTO, ID_DISK,  BarCommandRange)
 
    // Обработчик команд от панели управления Style
    ON_COMMAND_RANGE(ID_UNDERLINE, ID_MARK_4, BarCommandRange)
 
    // Обработчики команд меню View
    ON_COMMAND_EX(ID_Style, ShowStyle)
    ON_COMMAND_EX(ID_Extended, ShowStyle)
    ON_COMMAND_EX(ID_Player, ShowStyle)
 
   END_MESSAGE_MAP()
 
   //============================================================
   // Метод InitInstance класса CMultiBarApp
   // Создает главное окно приложения и отображает его на экране
   //============================================================
   BOOL CMultiBarApp::InitInstance() {
    m_pMainWnd = new CMultiBarWindow();
    m_pMainWnd->ShowWindow(m_nCmdShow);
    m_pMainWnd->UpdateWindow();
 
    return TRUE;
   }
 
   //============================================================
   // Конструктор класса CMultiBarWindow
   //============================================================
   CMultiBarWindow::CMultiBarWindow() {
    // Создаем окно приложения, соответствующее
    // данному объекту класса CMultiBarWindow
    Create(NULL, "Multi Bar", WS_OVERLAPPEDWINDOW, rectDefault, NULL, MAKEINTRESOURCE(IDR_MENU));
   }
 
   //============================================================
   // Метод OnCreate класса CMultiBarWindow
   // Используется для создания панелей управления
   //============================================================
   int CMultiBarWindow::OnCreate(LPCREATESTRUCT lpCreateStruct) {
    // Вызываем метод OnCreate базового класса
    if (CFrameWnd::OnCreate(lpCreateStruct) == -1) return -1;
 
    // Разрешаем присоединение панелей управления ко
    // всем сторонам окна CMultiBarWindow
    EnableDocking(CBRS_ALIGN_ANY);
 
    // Переменные для изменения стилей кнопок
    UINT nBarStyle;
    int nIndex;
    //============================================================
    // Создаем и отображаем панель управления Player
    //============================================================
    // Создаем панель управления toolbar
    if (!m_wndPlayerBar.Create(this, WS_CHILD | WS_VISIBLE | CBRS_SIZE_DYNAMIC | CBRS_BOTTOM  | CBRS_TOOLTIPS, ID_Player))   {
     // Ошибка при создании панели управления
     TRACE0("Failed to create toolbar\n");
     return -1;
    }
 
    // Загружаем ресурс панели управления Player
    if (!m_wndPlayerBar.LoadToolBar(IDR_PLAYER)) {
     // Ошибка при загрузке ресурса панели управления
     TRACE0("Failed to load toolbar\n");
     return -1;
    }
 
    // Устанавливаем заголовок панели управления Player
    m_wndPlayerBar.SetWindowText("Player");     
 
    // Из кнопок с идентификаторами ID_TYPE, ID_CD_DRV и
    // ID_WAVE делаем трехпозиционный переключатель с зависимой
    // фиксацией. Устанавливаем для этих кнопок стиль
    // TBBS_CHECKGROUP
    nIndex = m_wndPlayerBar.CommandToIndex(ID_TYPE);
    nBarStyle = m_wndPlayerBar.GetButtonStyle(nIndex) | TBBS_CHECKGROUP;
    m_wndPlayerBar.SetButtonStyle(nIndex, nBarStyle);
 
    nIndex = m_wndPlayerBar.CommandToIndex(ID_CD_DRV);
    nBarStyle = m_wndPlayerBar.GetButtonStyle(nIndex) | TBBS_CHECKGROUP;
    m_wndPlayerBar.SetButtonStyle(nIndex, nBarStyle);
 
    nIndex = m_wndPlayerBar.CommandToIndex(ID_WAVE);
    nBarStyle = m_wndPlayerBar.GetButtonStyle(nIndex) | TBBS_CHECKGROUP;
    m_wndPlayerBar.SetButtonStyle(nIndex, nBarStyle);
 
    // Из кнопки с идентификатором ID_PAUSE делаем
    // переключатель. Устанавливаем для этой кнопки стиль
    // TBBS_CHECKBOX
    nIndex = m_wndPlayerBar.CommandToIndex(ID_PAUSE);
    nBarStyle = m_wndPlayerBar.GetButtonStyle(nIndex) | TBBS_CHECKBOX;
    m_wndPlayerBar.SetButtonStyle(nIndex, nBarStyle);
 
    // Разрешаем пристывковывать панель управления Player к
    // любой строке родительского окна
    m_wndPlayerBar.EnableDocking(CBRS_ALIGN_ANY);
 
    // Пристывковываем панель управления Player к
    // родительскому окну
    DockControlBar(&m_wndPlayerBar);
 
    //============================================================
    // Создаем и отображаем панель управления Style
    //============================================================
    // Создаем панель управления toolbar
    if (!m_wndStyleBar.Create(this, WS_CHILD | WS_VISIBLE | CBRS_SIZE_FIXED | CBRS_TOP | CBRS_TOOLTIPS, ID_Style)) {
     // Ошибка при создании панели управления
     TRACE0("Failed to create toolbar\n");
     return -1;
    }
 
    // Загружаем ресурс панели управления Style
    if (!m_wndStyleBar.LoadToolBar(IDR_STYLE)) {
     // Ошибка при загрузке ресурса панели управления
     TRACE0("Failed to load toolbar\n");
     return -1;
    }
 
    // Устанавливаем заголовок панели управления Style
    m_wndStyleBar.SetWindowText("Style");  
 
    // Запрещаем пристывковывать панель управления Player к
    // родительскому окну
    m_wndStyleBar.EnableDocking(0);
 
    // Устанавливаем для кнопки ID_SUBSCRIPT стиль TBBS_WRAPPED
    nIndex = m_wndStyleBar.CommandToIndex(ID_SUBSCRIPT);
    nBarStyle = m_wndStyleBar.GetButtonStyle(nIndex) | TBBS_WRAPPED;
    m_wndStyleBar.SetButtonStyle(nIndex, nBarStyle);
 
    // Устанавливаем для кнопки ID_TEXT_JUSTIFY стиль
    // TBBS_WRAPPED
    nIndex = m_wndStyleBar.CommandToIndex(ID_TEXT_JUSTIFY);
    nBarStyle = m_wndStyleBar.GetButtonStyle(nIndex) | TBBS_WRAPPED;
    m_wndStyleBar.SetButtonStyle(nIndex, nBarStyle);
 
    // Отображаем панель управления Style в мини-окне.
    // Начальные координаты панели управления определяются
    // значением объекта pointStyleBar класса CPoint
    CPoint pointStyleBar(100, 100);
    FloatControlBar(&m_wndStyleBar, pointStyleBar);
 
    //============================================================
    // Создаем и отображаем панель управления Extended
    //============================================================
    // Создаем панель управления Extended
    if (!m_wndExtendedBar.Create(this, WS_CHILD | WS_VISIBLE | CBRS_SIZE_DYNAMIC | CBRS_TOP | CBRS_TOOLTIPS, ID_Extended)) {
     // Ошибка при создании панели управления
     TRACE0("Failed to create toolbar\n");
     return -1;
    }
 
    // Загружаем ресурс панели управления Extended
    if (!m_wndExtendedBar.LoadToolBar(IDR_EXTENDED)) {
     // Ошибка при загрузке ресурса панели управления
     TRACE0("Failed to load toolbar\n");
     return -1;
    }
 
    // Устанавливаем заголовок панели управления Extended
    m_wndExtendedBar.SetWindowText("Extended");
 
    // Увеличиваем размер первого разделителя.
    // Этот разделитель имеет индекс 2
    m_wndExtendedBar.SetButtonInfo(2, IDW_EDIT, TBBS_SEPARATOR, 130);
 
    // Определяем координаты прямоугольной области панели
    // управления, занимаемой разделителем
    CRect rectEdit;
    m_wndExtendedBar.GetItemRect(2, &rectEdit);
 
    // Делаем отступ с левой и правой стороны
    rectEdit.left += 6;
    rectEdit.right -= 6;
 
    // Размещаем на панели управления Extended, в области
    // rectEdit однострочный текстовый редактор
    if (!m_wndExtendedBar.m_edit.Create(WS_CHILD |  ES_AUTOHSCROLL|WS_VISIBLE|WS_TABSTOP|WS_BORDER,  rectEdit, &m_wndExtendedBar, IDW_EDIT)) {
     // Ошибка при создании текстового редактора
     TRACE0("Failed to create edit-box\n");
     return FALSE;
    }
 
    // Увеличиваем размер второго разделителя.
    // Этот разделитель имеет индекс 4
    m_wndExtendedBar.SetButtonInfo(4, IDW_COMBO, TBBS_SEPARATOR, 150);
 
    // Определяем координаты прямоугольной области панели
    // управления, занимаемой разделителем
    CRect rectComboBox;
    m_wndExtendedBar.GetItemRect(4, &rectComboBox);
 
    // Делаем отступ с левой и правой стороны
    rectComboBox.left += 6;
    rectComboBox.right -= 6;
 
    // Увеличиваем высоту прямоугольной области, чтобы в ней
    // можно было разместить список combo-box
    rectComboBox.bottom = rectComboBox.top + 80;
 
    // Размещаем на панели управления Extended, в области
    // rectComboBox список combo-box
    if (!m_wndExtendedBar.m_combo_box.Create(CBS_DROPDOWN | WS_CHILD | WS_VISIBLE | WS_VSCROLL |      ES_AUTOHSCROLL | CBS_DISABLENOSCROLL, rectComboBox, &m_wndExtendedBar, IDW_COMBO)) {
     // Ошибка при создании списка
     TRACE0("Failed to create combo-box\n");
     return FALSE;
    }
 
    // Добавляем три строки в список m_combo_box
    m_wndExtendedBar.m_combo_box.AddString("One");
    m_wndExtendedBar.m_combo_box.AddString("Two");
    m_wndExtendedBar.m_combo_box.AddString("Third");
 
    // Разрешаем пристывковывать панель управления Extended к
    // любой из строн родительского окна
    m_wndExtendedBar.EnableDocking(CBRS_ALIGN_ANY);
 
    // Пристывковываем панель управления Extended к
    // родительскому окну
    DockControlBar(&m_wndExtendedBar);
 
    return 0;
   }

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

   Создайте новый файл ресурсов и включите его в проект под именем MultiBar.rc. Теперь надо создать три панели управления toolbar и включить их в файл ресурсов. Изображения кнопок панелей управления вы можете нарисовать самостоятельно или скопировать их из файла ресурсов Common.res, поставляемого вместе с Microsoft Visual C++. Более подробная информация о файле Common.res представлена в разделе “Ресурсы Microsoft”.
   При создании панелей управления руководствуйтесь информацией из файла ресурсов приложения MultiBar (листинг 3.3) и изображениями кнопок панелей управления (рис. 3.3, 3.4, 3.5).
   Первая панель управления должна иметь идентификатор IDR_PLAYER и содержать девять кнопок с идентификаторами ID_LEFT, ID_PLAY, ID_RIGHT, ID_STOP, ID_PAUSE, ID_EJECT, ID_TYPE, ID_CD_DRV и ID_WAVE. Между кнопками ID_RIGHT и ID_STOP, ID_PAUSE и ID_EJECT, ID_EJECT и ID_TYPE вставьте разделители. Для каждой из кнопок вы также можете ввести их текстовые описания.
   Вторая панель управления должна иметь идентификатор IDR_STYLE и содержать двенадцать кнопок с идентификаторами ID_UNDERLINE, ID_2_UNDERLINE, ID_SUPERSCRIPT, ID_SUBSCRIPT, ID_TEXT_LEFT, ID_ID_TEXT_CENTER, ID_TEXT_RIGHT, ID_TEXT_JUSTIFY, ID_MARK_1, ID_MARK_2, ID_MARK_3 и ID_MARK_4. Для первых шести кнопок введите их текстовые описания.
   Третья панель управления должна иметь идентификатор IDR_EXTENDED. Определите в ней четыре кнопки с идентификаторами ID_FOTO, ID_PRINTER, ID_ADD и ID_DISK. Между кнопками ID_PRINTER и  ID_ADD, а также ID_ADD и ID_DISK вставьте разделители. Введите текстовые описания кнопок.
   В файл ресурсов, кроме панелей управления toolbar, включите меню IDR_MENU с тремя строками Style, Extended и Player, которые имеют идентификаторы ID_Style, ID_Extended и ID_Player. Обратите внимание, что идентификаторы строк меню соответствуют идентификаторам панелей управления.
   Файл ресурсов приложения MultiBar мы привели в листинге 3.8. В нем определены ресурсы панелей управления toolbar с идентификаторами IDR_PLAYER, IDR_STYLE и IDR_EXTENDED, ресурсы изображений этих панелей управления с соответствующими идентификаторами, меню приложения, а также несколько строковых ресурсов с описаниями кнопок панелей управления. Идентификаторы строковых ресурсов соответствуют идентификаторам кнопок панелей управления, которые они описывают.

Листинг 3.8. Файл MultiBar.rc

   //Microsoft Developer Studio generated resource script.
   //
   #include "resource.h"
 
   #define APSTUDIO_READONLY_SYMBOLS
   //////////////////////////////////////////////////////////////
   //
   // Generated from the TEXTINCLUDE 2 resource.
   //
   #include "afxres.h"
 
   //////////////////////////////////////////////////////////////
   #undef APSTUDIO_READONLY_SYMBOLS
 
   //////////////////////////////////////////////////////////////
   //
   // Russian resources
 
   #if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_RUS)
   #ifdef _WIN32
   LANGUAGE LANG_RUSSIAN, SUBLANG_DEFAULT
   #pragma code_page(1251)
   #endif //_WIN32
 
   #ifdef APSTUDIO_INVOKED
   //////////////////////////////////////////////////////////////
   //
   // TEXTINCLUDE
   //
 
   1 TEXTINCLUDE DISCARDABLE
   BEGIN
    "resource.h\0"
   END
 
   2 TEXTINCLUDE DISCARDABLE
   BEGIN
    "#include ""afxres.h""\r\n"
    "\0"
   END
 
   3 TEXTINCLUDE DISCARDABLE
   BEGIN
    "\r\n"
    "\0"
   END
 
   #endif    // APSTUDIO_INVOKED
 
   //////////////////////////////////////////////////////////////
   //
   // Toolbar
   //
 
   IDR_PLAYER TOOLBAR DISCARDABLE 16, 15
   BEGIN
    BUTTON ID_LEFT
    BUTTON ID_PLAY
    BUTTON ID_RIGHT
    SEPARATOR
    BUTTON ID_STOP
    BUTTON ID_PAUSE
    SEPARATOR
    BUTTON ID_EJECT
    SEPARATOR
    BUTTON ID_TYPE
    BUTTON ID_CD_DRV
    BUTTON ID_WAVE
   END
 
   IDR_STYLE TOOLBAR DISCARDABLE 16, 15
   BEGIN
    BUTTON ID_UNDERLINE
    BUTTON ID_2_UNDERLINE
    BUTTON ID_SUPERSCRIPT
    BUTTON ID_SUBSCRIPT
    BUTTON ID_TEXT_LEFT
    BUTTON ID_ID_TEXT_CENTER
    BUTTON ID_TEXT_RIGHT
    BUTTON ID_TEXT_JUSTIFY
    BUTTON ID_MARK_1
    BUTTON ID_MARK_2
    BUTTON ID_MARK_3
    BUTTON ID_MARK_4
   END
 
   IDR_EXTENDED TOOLBAR DISCARDABLE 16, 15
   BEGIN
    BUTTON ID_FOTO
    BUTTON ID_PRINTER
    SEPARATOR
    BUTTON ID_ADD
    SEPARATOR
    BUTTON ID_DISK
   END
 
   //////////////////////////////////////////////////////////////
   //
   // Bitmap
   //
 
   IDR_PLAYER   BITMAP DISCARDABLE "player.bmp"
   IDR_STYLE    BITMAP DISCARDABLE "style.bmp"
   IDR_EXTENDED BITMAP DISCARDABLE "extended.bmp"
 
   //////////////////////////////////////////////////////////////
   //
   // Menu
   //
 
   IDR_MENU MENU DISCARDABLE
   BEGIN
    POPUP "View"
    BEGIN
     MENUITEM "Style",    ID_Style
     MENUITEM "Extended", ID_Extended
     MENUITEM "Player",   ID_Player
    END
   END
 
   //////////////////////////////////////////////////////////////
   //
   // String Table
   //
 
   STRINGTABLE DISCARDABLE
   BEGIN
    ID_LEFT        "Rewind to begin\nRewind to begin"
    ID_RIGHT       "Rewind to end\nRewind to end"
    ID_PLAY        "Play\nPlay"
    ID_STOP        "Stop\nStop"
    ID_PAUSE       "Pause\nPause"
    ID_EJECT       "Eject\nEject"
    ID_TYPE        "Type drive\nType"
    ID_CD_DRV      "CD drive\nCD"
    ID_BUTTON40010 "Wave/nWave File"
    ID_WAVE        "Wave file\nWAWE"
    ID_UNDERLINE   "Underline\nUnderline"
    ID_2_UNDERLINE "Double underline\nDouble underline"
    ID_SUPERSCRIPT "Superscript\nSuperscript"
    ID_SUBSCRIPT   "Subscript\nSubscript"
   END
 
   STRINGTABLE DISCARDABLE
   BEGIN
    ID_ADD "Add from edit-box item to combobox\nAdd item to list"
   END
 
   STRINGTABLE DISCARDABLE
   BEGIN
    ID_TEXT_LEFT      "Left text\nLeft"
    ID_ID_TEXT_CENTER "Center text\nCenter"
    ID_TEXT_RIGHT     "Right text\nRight"
    ID_TEXT_JUSTIFY   "Justify text\nJustify"
    ID_FOTO           "Foto\nFoto"
    ID_PRINTER        "Printer\nPrinter"
    ID_DISK           "Disk\nDisk"
   END
 
   STRINGTABLE DISCARDABLE
   BEGIN
    IDW_EDIT  "Edit\nEdit"
    IDW_COMBO "Combo box\nCombo box"
   END
 
   #endif    // Russian resources
   //////////////////////////////////////////////////////////////
 
   #ifndef APSTUDIO_INVOKED
   //////////////////////////////////////////////////////////////
   // Generated from the TEXTINCLUDE 3 resource.
   //
 
   //////////////////////////////////////////////////////////////
   #endif    // not APSTUDIO_INVOKED
   Изображения кнопок панелей управления располагаются в отдельных файлах player.bmp (рис. 3.14), style.bmp (рис. 3.15) и extended.bmp (рис. 3.13) в главном каталоге проекта. Файлы изображений панелей управления содержат только изображения кнопок. В них не представлены разделители и дополнительные органы управления.
   В принципе, изображения панели управления можно редактировать в любом графическом редакторе, который работает с 16-цветными изображениями в формате BMP. Примером такого приложения является графический редактор Microsoft Paint, поставляемый вместе с операционными системами Windows 95 и Windows NT версии 4.0. Однако, лучше использовать редактор ресурсов среды Microsoft Visual C++, так как он не только разрешает редактировать существующие кнопки, но также позволяет добавлять новые кнопки вместе с соответствующими идентификаторами и строковыми ресурсами.
   Рис. 3.13. Изображение кнопок панели управления Extended
 
   Рис. 3.14. Изображение кнопок панели управления Player
 
   Рис. 3.15. Изображение кнопок панели управления Style
 
   Идентификаторы всех ресурсов приложения MultiBar и идентификаторы дополнительных органов управления панели Extended определены в файле resource.h. Этот файл автоматически создается редактором ресурсов Microsoft Visual C++.
   Мы привели исходный текст файла resource.h в листинге 3.9.

Листинг 3.9. Файл resource.h

   //{{NO_DEPENDENCIES}}
   // Microsoft Developer Studio generated include file.
   // Used by MultiBar.rc
   //
   #define IDW_EDIT          101
   #define IDW_COMBO         102
   #define IDR_PLAYER        103
   #define IDR_STYLE         105
   #define IDR_EXTENDED      107
   #define IDR_MENU          109
   #define ID_LEFT           40001
   #define ID_RIGHT          40002
   #define ID_PLAY           40003
   #define ID_STOP           40004
   #define ID_PAUSE          40005
   #define ID_EJECT          40007
   #define ID_TYPE           40008
   #define ID_CD_DRV         40009
   #define ID_WAVE           40011
   #define ID_UNDERLINE      40012
   #define ID_2_UNDERLINE    40013
   #define ID_SUPERSCRIPT    40014
   #define ID_SUBSCRIPT      40015
   #define ID_TEXT_LEFT      40017
   #define ID_ID_TEXT_CENTER 40018
   #define ID_TEXT_RIGHT     40019
   #define ID_TEXT_JUSTIFY   40020
   #define ID_MARK_1         40021
   #define ID_MARK_2         40022
   #define ID_MARK_3         40023
   #define ID_MARK_4         40024
   #define ID_FOTO           40025
   #define ID_PRINTER        40026
   #define ID_DISK           40027
   #define ID_Style          40029
   #define ID_Extended       40030
   #define ID_Buttons        40031
   #define ID_Player         40031
   #define ID_ADD            40032
 
   // Next default values for new objects
   //
   #ifdef APSTUDIO_INVOKED
   #ifndef APSTUDIO_READONLY_SYMBOLS
   #define _APS_NEXT_RESOURCE_VALUE  110
   #define _APS_NEXT_COMMAND_VALUE   40033
   #define _APS_NEXT_CONTROL_VALUE   1000
   #define _APS_NEXT_SYMED_VALUE     103
   #endif
   #endif
   #endif

Панели управления приложения MultiBar

   Постройте приложение MultiBar и запустите его. На экране появится главное окно приложения MultiBar, в котором отображаются сразу три панели управления – Extended, Player и Slyle. Панели управления Extended и Player присоединены к верхней и нижней границам окна, а панель управления Slyle отображается в отдельном мини-окне (рис. 3.16).
   Рис. 3.16. Приложение MultiBar
 
   Приложение MultiBar имеет меню View, состоящее из названий панелей управления Extended, Player и Slyle. Выбирая из меню View названия панелей управления, вы можете убрать их с экрана и опять отобразить (закрыть и открыть).
   Панели управления, которые отображаются в мини-окнах, также можно закрыть, если нажать на переключатель  в верхнем правом углу окна. Чтобы снова открыть закрытую панель управления, используйте меню View.

Панель управления Player

   Панель управления Player состоит из девяти кнопок, сгруппированных в четыре отдельные группы. Панель Player предназначена для управления музыкальным центром. Все кнопки имеют краткие подсказки.
   При нажатии на кнопки панели управления Player на экране появляется сообщение, о том, что команда не поддерживается. Обратите внимание на кнопки Pause, Type, CD и WAVE.
   Кнопка Pause работает как переключатель. Если вы на нее нажмете – она остается в нажатом положении до тех пор, пока вы не нажмете на нее еще один раз. Кнопки Type, CD и WAVE работают вместе как переключатель с зависимой фиксацией. Одновременно может быть нажата только одна из этих кнопок.
   Панель управления Player можно присоединить к трем из четырех сторон главного окна приложения – к верхней, левой и нижней. К правой стороне окна панель Player не присоединяется (рис. 3.17). Вы также можете использовать для панели Player отдельное мини окно, форму которого можно изменять.
   Рис. 3.17. Изменение формы панели управления Player
 

Панель управления Extended

   Панель Extended демонстрирует использование в панелях управления toolbar дополнительных органов управления – поля редактирования и списка combo-box. Сразу после запуска приложения MultiBar в списке combo-box содержатся три строки – First, Second и Third. В поле редактирования можно ввести новые строки для этого списка. После того, как вы наберете строку, нажмите кнопку . Введенная строка появится в конце списка combo-box.
   На рисунке 3.18 мы показали внешний вид панели управления Extended с открытым списком combo-box, после того как в нее добавлена строка Fifth.
   Рис. 3.18. Новая строка в списке combo-box
 
   Панель управления Extended можно присоединить к любой стороне главного окна приложения или разместить в отдельном мини-окне. Когда панель управления Extended отображается в мини-окне, ее форму можно изменять. Ширина панели Extended не может быть меньше, чем самый широкий орган управления.

Панель управления Slyle

   Панель управления Slyle отображается исключительно в отдельном мини-окне. Вы не сможете пристыковать ее ни к одной из сторон главного окна приложения MultiBar. Кнопки панели управления Slyle отображаются в три ряда по четыре кнопки в каждом ряду. В отличие от панелей управления Extended и Player, форма панели управления Slyle не изменяется.
   Два верхних ряда кнопок в панели управления MultiBar имеют краткие подсказки. Если указатель мыши задержится над ними на некоторое время, то около него появится маленькое окно tooltip с кратким описанием соответствующей кнопки. Кнопки из нижнего ряда подсказок не имеют.

Как устроено приложение MultiBar

   В приложении MultiBar определены три класса CMultiBarApp, CMultiBarWindow и CExtendedBar. Классы CMultiBarApp и CMultiBarWindow представляют основные классы приложения, класс CExtendedBar представляет одну из панелей управления и будет рассмотрен ниже.

Главный класс приложения CMultiBarApp

   Главный класс приложения CMultiBarApp наследуется от базового класса CWinApp. Объект MyMultiBarApp класса CMultiBarApp объявлен как глобальный и создается сразу после запуска приложения.
   В класс CMultiBarApp входит только метод InitInstance. Он создает главное окно приложения, представленное классом CMultiBarWindow, наследованным от класса CFrameWnd.
   В класс CMultiBarWindow входят три объекта — m_wndPlayerBar, m_wndStyleBar и m_wndExtendedBar, представляющие панели управления Player, Style и Extended:
   class CMultiBarWindow : public CFrameWnd {
   // Определяем панели управления
   protected:
    // Панель управления Player
    CToolBar m_wndPlayerBar;
    // Панель управления Style
    CToolBar m_wndStyleBar;
    // Панель управления Extended
    CExtendedBar m_wndExtendedBar;
 
    // ...
   }
   Панели управления Player и Style представлены объектами класса CToolBar. Панель управления Extended представлена объектом m_wndExtendedBar класса CExtendedBar. Класс CExtendedBar определен в нашем приложении. Он наследуется от базового класса CToolBar и дополняет его двумя элементами m_edit и m_combo_box. Эти элементы представляют текстовый редактор и список combo-box, которые будут размещены на панели управления:
   class CExtendedBar : public CToolBar {
   public:
    // Дополнительные органы управления панели Extended
    CEdit m_edit;          // текстовый редактор
    CComboBox m_combo_box; // список с текстовым редактором
   };
   В таблице сообщений класса CMultiBarWindow, находится макрокоманда ON_WM_CREATE. Поэтому в процессе создания главного окна приложения вызывается метод OnCreate. Мы используем метод OnCreate для создания сразу трех панелей управления. Рассмотрим метод OnCreate более подробно.

Метод OnCreate класса CMultiBarWindow

   Метод OnCreate класса CMultiBarWindow сначала вызывает метод OnCreate базового класса CFrameWnd.
   Чтобы разрешить перемещение панелей управления, вызываем метод EnableDocking для главного окна приложения.  Чтобы разрешить присоединение панелей управления ко всем сторонам окна, передаем методу EnableDocking значение CBRS_ALIGN_ANY:
   // Разрешаем присоединение панелей управления ко
   // всем сторонам окна CMultiBarWindow
   EnableDocking(CBRS_ALIGN_ANY);
   • Создание панели управления Player
   Затем мы приступаем к созданию трех панелей управления. Сначала создается панель управления Player. В ней расположен ряд кнопок, три из которых объединены в переключатель с зависимой фиксацией и еще одна кнопка является переключателем.
   Чтобы создать панель управления Player, вызывается метод Create объекта m_wndPlayerBar. Ему передаются набор флагов, определяющий характеристики панели управления. Флаг CBRS_SIZE_DYNAMIC определяет, что пользователь сможет менять форму панели управления Player. Флаг CBRS_BOTTOM задает начальное положение панели - вверху окна приложения. Флаг CBRS_TOOLTIPS разрешает отображение кратких подсказок для тех кнопок панели управления, которые имеют соответствующие строковые ресурсы:
   if (!m_wndPlayerBar.Create(this, WS_CHILD | WS_VISIBLE | CBRS_SIZE_DYNAMIC | CBRS_BOTTOM |  CBRS_TOOLTIPS, ID_Player)) {
    // Ошибка при создании панели управления
    TRACE0("Failed to create toolbar\n");
    return -1;
   }
   После создания панели управления загружаем ресурс IDR_PLAYER, описывающий кнопки панели управления:
   if (!m_wndPlayerBar.LoadToolBar(IDR_PLAYER)) {
    // Ошибка при загрузке ресурса панели управления
    TRACE0("Failed to load toolbar\n");
    return -1;
   }
   Когда панель управления отображается в мини-окне, она имеет заголовок. Чтобы установить текст в этих заголовках, вызываем метод SetWindowText:
   m_wndPlayerBar.SetWindowText("Player");
   Теперь мы указываем, что кнопки панели управления с идентификаторами ID_TYPE, ID_CD_DRV и ID_WAVE составляют трехпозиционный переключатель с зависимой фиксацией. Для этого мы последовательно определяем стиль каждой из этих кнопок и добавляем к ним стиль TBBS_CHECKGROUP:
   nIndex = m_wndPlayerBar.CommandToIndex(ID_TYPE);
   nBarStyle = m_wndPlayerBar.GetButtonStyle(nIndex) | TBBS_CHECKGROUP;
   m_wndPlayerBar.SetButtonStyle(nIndex, nBarStyle);
 
   nIndex = m_wndPlayerBar.CommandToIndex(ID_CD_DRV);
   nBarStyle =  m_wndPlayerBar.GetButtonStyle(nIndex) | TBBS_CHECKGROUP;
   m_wndPlayerBar.SetButtonStyle(nIndex, nBarStyle);
 
   nIndex = m_wndPlayerBar.CommandToIndex(ID_WAVE);
   nBarStyle =  m_wndPlayerBar.GetButtonStyle(nIndex) | TBBS_CHECKGROUP;
   m_wndPlayerBar.SetButtonStyle(nIndex, nBarStyle);
   Далее кнопку с идентификатором ID_PAUSE мы превращаем в переключатель. Для этого определяем стиль этой кнопки и добавляем к нему стиль TBBS_CHECKBOX:
   nIndex = m_wndPlayerBar.CommandToIndex(ID_PAUSE);
   nBarStyle =  m_wndPlayerBar.GetButtonStyle(nIndex) | TBBS_CHECKBOX;
   m_wndPlayerBar.SetButtonStyle(nIndex, nBarStyle);
   Когда стили всех кнопок панели управления установлены, разрешаем присоединять ее к любой стороне родительского окна. Для этого вызываем метод EnableDocking, передав ему в качестве параметра значение CBRS_ALIGN_ANY:
   m_wndPlayerBar.EnableDocking(CBRS_ALIGN_ANY);
   Последним шагом в процессе создания панели управления Player является вызов метода DockControlBar для окна приложения. Этот метод пристывковывает панель управления Player к родительскому окну:
   DockControlBar(&m_wndPlayerBar);
   • Создание панели управления Style
   Панель управления Style состоит из двенадцати кнопок, расположенных в три ряда по четыре кнопки в каждом ряду.
   Чтобы создать панель управления Style вызывается метод Create объекта m_wndStyleBar. Ему передается набор флагов, определяющий характеристики панели управления. Флаг CBRS_SIZE_FIXED указывает, что панель управления имеет фиксированную форму, которую пользователь не сможет изменить. Флаг CBRS_TOP задает начальное положение панели — вверху окна приложения. Флаг CBRS_TOOLTIPS разрешает отображение кратких подсказок для тех кнопок панели управления, которые имеют соответствующие строковые ресурсы.
   Файл ресурсов содержит строки описания только для первых восьми кнопок панели Style. Последние четыре кнопки не имеют соответствующих строковых ресурсов, поэтому для них подсказка не отображается:
   if (!m_wndStyleBar.Create(this, WS_CHILD | WS_VISIBLE | CBRS_SIZE_FIXED | CBRS_TOP | CBRS_TOOLTIPS, ID_Style)) {
    // Ошибка при создании панели управления
    TRACE0("Failed to create toolbar\n");
    return -1;
   }
   После создания панели управления загружаем ресурс IDR_STYLE, описывающий кнопки панели управления:
   if (!m_wndStyleBar.LoadToolBar(IDR_STYLE)) {
    // Ошибка при загрузке ресурса панели управления
    TRACE0("Failed to load toolbar\n");
    return -1;
   }
   Когда панель управления создана, вызываем метод SetWindowText, чтобы установить текст в ее заголовке:
   m_wndStyleBar.SetWindowText("Style");
   Панель управления Style задумана нами как панель управления, которая все время отображается в отдельном мини-окне. Поэтому мы запрещаем пристывковывать панель управления Player к родительскому окну. Для этого вызываем метод EnableDocking, указав ему в качестве параметра нулевое значение:
   m_wndStyleBar.EnableDocking(0);
   Чтобы установить форму панели управления (разделить кнопки на несколько рядов) добавляем к стилям кнопок, завершающих каждый ряд, стиль TBBS_WRAPPED:
   nIndex = m_wndStyleBar.CommandToIndex(ID_SUBSCRIPT);
   nBarStyle =  m_wndStyleBar.GetButtonStyle(nIndex) | TBBS_WRAPPED;
   m_wndStyleBar.SetButtonStyle(nIndex, nBarStyle);
 
   nIndex = m_wndStyleBar.CommandToIndex(ID_TEXT_JUSTIFY);
   nBarStyle =  m_wndStyleBar.GetButtonStyle(nIndex) | TBBS_WRAPPED;
   m_wndStyleBar.SetButtonStyle(nIndex, nBarStyle);
   Когда стили всех кнопок установлены, вызываем метод FloatControlBar главного окна приложения, чтобы вывести панель управления Style в отдельном мини-окне. В качестве координат, в которых отображается панель Style, произвольно выбираем точку (100,100):
   CPoint pointStyleBar(100, 100);
   FloatControlBar(&m_wndStyleBar, pointStyleBar);
   • Создание панели управления Extended
   Панель управления Extended содержит дополнительные органы управления – текстовый редактор и список combo-box.
   Чтобы создать панель управления Extended вызывается метод Create объекта m_wndExtendedBar. Ему передаются набор флагов, определяющий характеристики панели управления. Флаг CBRS_SIZE_DYNAMIC указывает, что пользователь может изменить форму панели управления. Флаг CBRS_TOP задает начальное положение панели - вверху окна приложения. Флаг CBRS_TOOLTIPS разрешает отображение кратких подсказок для тех кнопок панели управления, которые имеют соответствующие строковые ресурсы:
   if (!m_wndExtendedBar.Create(this,    WS_CHILD | WS_VISIBLE | CBRS_SIZE_DYNAMIC |    CBRS_TOP | CBRS_TOOLTIPS, ID_Extended)) {
    // Ошибка при создании панели управления
    TRACE0("Failed to create toolbar\n");
    return -1;
   }
   После создания панели управления загружаем ресурс IDR_ EXTENDED, описывающий кнопки панели управления:
   if (!m_wndExtendedBar.LoadToolBar(IDR_EXTENDED)) {
    // Ошибка при загрузке ресурса панели управления
    TRACE0("Failed to load toolbar\n");
    return -1;
   }
   Когда панель управления создана, вызываем метод SetWindowText, чтобы установить текст в ее заголовке:
   m_wndExtendedBar.SetWindowText("Extended");
   Теперь мы приступаем к созданию дополнительных органов управления – текстового редактора и списка combo-box. Эти органы управления размещаются в панелях управления на месте разделителей.
   • Отображаем текстовый редактор
   По умолчанию разделитель имеет слишком маленький размер, чтобы разместить на его месте какой-либо орган управления. Поэтому сначала мы увеличиваем его размер. Для этого используем метод SetButtonInfo:
   m_wndExtendedBar.SetButtonInfo(2, IDW_EDIT, TBBS_SEPARATOR, 130);
   Этот метод увеличивает размер первого разделителя, имеющего индекс 2, до 130 пикселов в ширину. Теперь надо определить координаты прямоугольной области разделителя в которых будет размещен текстовый редактор:
   CRect rectEdit;
   m_wndExtendedBar.GetItemRect(2, &rectEdit);
   Метод GetItemRect записывает в rectEdit координаты разделителя. Чтобы отделить текстовый редактор от соседних кнопок, уменьшаем ширину прямоугольника rectEdit, делая отступ по 6 пикселов с правой и с левой стороны:
   rectEdit.left += 6;
   rectEdit.right -= 6;
   Координаты прямоугольной области для текстового редактора вычислены и мы вызываем метод Create для текстового редактора m_edit, который, собственно, и размещает текстовый редактор на панели управления:
   if (!m_wndExtendedBar.m_edit.Create(WS_CHILD | ES_AUTOHSCROLL | WS_VISIBLE | WS_TABSTOP | WS_BORDER,   rectEdit, &m_wndExtendedBar, IDW_EDIT)) {
    // Ошибка при создании текстового редактора
    TRACE0("Failed to create edit-box\n");
    return FALSE;
   }
   Обратите внимаете на стили, указанные при создании текстового редактора. Наибольшее значение имеет стиль WS_CHILD, означающий, что текстовый редактор является дочерним окном панели управления. В принципе, стиль WS_CHILD можно не указывать. В этом случае он будет установлен автоматически в процессе создания текстового редактора.
   Стиль ES_AUTOHSCROLL позволяет вводить в текстовом редакторе длинные строки. Если строка не помещается в окне редактора, она сдвигается.
   Стиль WS_VISIBLE устанавливается, чтобы текстовый редактор появился на экране сразу после создания. Если его не указать, то текстовый редактор останется невидимым.
   Мы установили для текстового редактора стиль WS_BORDER, чтобы лучше выделить его на фоне панели управления. Этот стиль отображает вокруг текстового редактора тонкую рамку.
   Панель управления не позволяет использовать клавишу <Tab> для перемещения фокуса ввода между кнопками. Однако если вы размещаете на панели управления дополнительные органы управления, для них можно установить стиль WS_TABSTOP. Тогда вы получите возможность перемещать фокус ввода между ними, нажимая клавишу <Tab>. Мы установили стиль WS_TABSTOP для двух дополнительных органов управления - текстового редактора и списка combo-box.
   • Отображаем список combo-box
   Теперь, когда текстовый редактор появился в панели управления, мы повторяем проделанные шаги и отображаем список combo-box.
   Увеличиваем размер второго разделителя панели управления, который имеет индекс 4 до 150 пикселов:
   m_wndExtendedBar.SetButtonInfo(4, IDW_COMBO, TBBS_SEPARATOR, 150);
   Определяем координаты прямоугольной области панели управления, занимаемой этим разделителем, и уменьшаем ее ширину на 6 пикселов с каждой стороны:
   CRect rectComboBox;
   m_wndExtendedBar.GetItemRect(4, &rectComboBox);
 
   rectComboBox.left += 6;
   rectComboBox.right -= 6;
   Список combo-box раскрывается вниз. Отводим для него дополнительно 80 пикселов. Если не увеличить вертикальные размеры прямоугольной области, предназначенной для размещения списка combo-box, то вы не сможете его открыть. Для этого просто не хватит высоты панели управления:
   rectComboBox.bottom = rectComboBox.top + 80;
   Для создания списка combo-box вызываем метод Create для объекта m_combo_box. Он размещает список в прямоугольной области rectComboBox:
   if (!m_wndExtendedBar.m_combo_box.Create(CBS_DROPDOWN | WS_CHILD | WS_VISIBLE | WS_VSCROLL |   ES_AUTOHSCROLL | CBS_DISABLENOSCROLL, rectComboBox, &m_wndExtendedBar, IDW_COMBO)) {
    // Ошибка при создании списока с полем редактирования
    TRACE0("Failed to create combo-box\n");
    return FALSE;
   }
   Как и при создании текстового редактора, мы передали методу Create несколько стилей, определяющих режим работы и характеристики списка combo-box.
   Так как список размещается в панели управления, то он является его дочерним окном. Поэтому мы указали для него стиль WS_CHILD. Вы можете опустить стиль WS_CHILD. В этом случае он будет установлен автоматически в процессе создания списка combo-box.
   Стиль WS_VISIBLE устанавливается, чтобы список появился на экране сразу после создания. Если его не указать, список останется невидимым.
   Стиль WS_VSCROLL добавляет к списку combo-box вертикальную полосу просмотра, если в списке слишком много строк. Мы также добавили стиль CBS_DISABLENOSCROLL, означающий что вертикальная полоса просмотра отображается, даже если все строки помещаются в списке. В этом случае, однако, полоса просмотра отображается серым цветом и не доступна для использования.
   Внешний вид списка combo-box определяется стилем CBS_DROPDOWN, который означает, что список будет открываться в случае нажатия на кнопку .
   Мы также установили для списка стиль WS_TABSTOP, который позволяет использовать клавишу <Tab> для передачи ему фокуса ввода. Напомним, что этот стиль также установлен для текстового редактора.
   Сразу после создания списка combo-box мы записываем в него три строки: One, Two и Third. Вы увидите эти строки если откроете список combo-box в панели управления приложения.
   Для добавления новых строк к списку нами используется метод AddString класса CComboBox:
   m_wndExtendedBar.m_combo_box.AddString("One");
   m_wndExtendedBar.m_combo_box.AddString("Two");
   m_wndExtendedBar.m_combo_box.AddString("Third");
   Когда стили всех кнопок панели управления выбраны, разрешаем присоединять ее к любой стороне родительского окна. Для этого вызываем метод EnableDocking, передав ему в качестве параметра значение CBRS_ALIGN_ANY:
   m_wndExtendedBar.EnableDocking(CBRS_ALIGN_ANY);
   Последним шагом в процессе создания панели управления Extended является вызов метода DockControlBar для окна приложения. Этот метод пристывковывает панель управления Extended к родительскому окну:
   DockControlBar(&m_wndExtendedBar);

Команды панелей управления

   Каждый раз когда пользователь нажимает на кнопки в панели управления или работает с дополнительными органами управления (текстовым редактором и списком combo-box), в окно приложения, являющееся родительским окном панели управления, поступают соответствующие сообщения.
   Кнопки панели управления передают в родительское окно командные сообщения. Идентификатор этих командных сообщений соответствует идентификатору нажатой кнопки. В родительское окно панели управления также поступают сообщения от дополнительных органов управления – текстового редактора и списка combo-box. Коды извещения этих сообщений определяют их назначение.
   Таблица сообщений класса CMultiBarWindow обрабатывает целый ряд сообщений от меню и панелей управления. Кроме них в таблице сообщений класса CMultiBarWindow располагается макрокоманда ON_WM_CREATE, которая вызывает метод OnCreate во время создания окна:
   ON_WM_CREATE()
   Для обработки командных сообщений от кнопок панелей Player и Style мы вызываем методы BarCommandOne и BarCommandRange, входящие в класс CMultiBarWindow.
   Метод BarCommandOne отображает на экране сообщение о том, что данная команда не реализована - Command not implemented. Метод BarCommandRange не выполняет никаких действий:
   // Обработчики команд от панели управления Player
   ON_COMMAND(ID_STOP, BarCommandOne)
   ON_COMMAND(ID_PLAY, BarCommandOne)
   ON_COMMAND(ID_PAUSE, BarCommandOne)
   ON_COMMAND_RANGE(ID_LEFT, ID_RIGHT, BarCommandRange)
   ON_COMMAND_RANGE(ID_TYPE, ID_WAVE,  BarCommandRange)
 
   // Обработчик команд от панели управления Style
   ON_COMMAND_RANGE(ID_UNDERLINE, ID_MARK_4, BarCommandRange)
   Для перехвата командных сообщений от панели управления Player и Style используются макрокоманды ON_COMMAND и ON_COMMAND_RANGE. Макрокоманда ON_COMMAND вызывает метод, указанный во втором параметре командного сообщения, соответствующего идентификатору, приведенному в первом параметре. Макрокоманда ON_COMMAND_RANGE. работает аналогично ON_COMMAND, но позволяет вызвать метод обработчик, указанный в третьем параметре, сразу для нескольких командных сообщений. Идентификаторы обрабатываемых сообщений находятся в промежутке значений, указанных первым и вторым параметрами макрокоманды.
   Для обработки командных сообщений от кнопок панели управления Extended мы также используем метод BarCommandRange. Исключение составляет только кнопка ID_ADD. Сообщения от этой кнопки обрабатываются методом AddStringToComboBox класса CMultiBarWindow:
   // Обработчики команд от панели управления Extended
   ON_COMMAND(ID_ADD, AddStringToComboBox)
   ON_COMMAND_RANGE(ID_FOTO, ID_DISK,  BarCommandRange)
   В таблице сообщений класса CMultiBarWindow также расположены макрокоманды для обработки командных сообщений от меню View. Для их обработки используется метод ShowStyle класса CMultiBarWindow:
   // Обработчики команд меню View
   ON_COMMAND_EX(ID_Style, ShowStyle)
   ON_COMMAND_EX(ID_Extended, ShowStyle)
   ON_COMMAND_EX(ID_Player, ShowStyle)
   Командные сообщения от всех строк меню View обрабатываются одним методом ShowStyle,  однако его вызов осуществляется с помощью макрокоманды ON_COMMAND_EX. Эта макрокоманда вызывает для обработки командного сообщения с идентификатором, заданным первым параметром, метод указанный во втором параметре. В отличие от макрокоманды ON_COMMAND, макрокоманда ON_COMMAND_EX передает методу-обработчику идентификатор полученного командного сообщения.
   Метод ShowStyle использует этот идентификатор, чтобы определить какая строка меню была выбрана.

Методы BarCommandOne и BarCommandRange класса CMultiBarWindow

   Методы BarCommandOne и BarCommandRange определены в классе главного окна приложения CMultiBarWindow и используются для обработки сообщений от кнопок панелей управления.
   Фактически методы BarCommandOne и BarCommandRange не выполняют никакой полезной работы. Единственное, что делает метод BarCommandOne, – это отображает на экране сообщение о том, что выбранная вами команда не реализована. Для этого мы используем метод MessageBox:
   void CMultiBarWindow::BarCommandOne() {
    // Отображаем сообщение о том, что команда не реализована
    MessageBox("Command not implemented");
   }
   Метод BarCommandRange вообще не выполняет никакой полезной работы. Однако не спешите исключать его из программы. Если вы удалите методы BarCommandOne и BarCommandRange из программы и удалите соответствующие макрокоманды из таблицы сообщений класса окна, тогда все кнопки, для обработки сообщений от которых использовались эти методы, окажутся заблокированы. MFC определит, что сообщения от кнопок не обрабатываются и запретит их использование:
   void CMultiBarWindow::BarCommandRange(UINT nID) {
    // Обработчик не выполняет никакой работы
   }

Метод AddStringToComboBox класса CMultiBarWindow

   Метод AddStringToComboBox класса CMultiBarWindow выполняет обработку командных сообщений от кнопки ID_ADD панели управления Extended. Для этого он сначала считывает строку, введенную в текстовом редакторе m_edit, а затем добавляет ее в список m_combo_box:
   void CMultiBarWindow::AddStringToComboBox() {
    // Получаем строку, введенную в текстовом редакторе m_edit
    char  tmpStr[39];
    m_wndExtendedBar.m_edit.GetLine(0, tmpStr,40);
 
    // Добавляем новую строку к списку m_combo_box
    m_wndExtendedBar.m_combo_box.AddString(tmpStr);
   }

   В том случае, если в панели управления приложения надо разместить много разнообразных органов управления, то значительно удобнее создать его на основе другого класса, имеющего название CDialogBar :
   CDialogBar←CControlBar←CWnd←CCmdTarget←CObject
   Этот класс, также как класс CToolBar , наследован от базового класса CControlBar. Класс CDialogBar позволяет создать диалоговую панель управления на основе шаблона диалоговой панели. В отличии от обычной диалоговой панели, диалоговая панель управления, созданная на основе класса CDialogBar, имеет все свойства панели управления. Она может быть присоединена к одной из границ окна или может отображаться в отдельном мини-окне.
   Приложение может иметь несколько панелей управления, созданных на основе классов CToolBar и CDialogBar.

   Непосредственно в состав класса CDialogBar входят всего два метода – это конструктор класса CDialogBar и метод Create.
   Конструктор класса CDialogBar создает только соответствующий объект, но не саму панель управления:
   CDialogBar();
   Чтобы создать панель управления, следует вызвать метод Create и указать ему шаблон диалоговой панели, используемый для создания диалоговой панели управления.
   Метод Create имеет два различных формата:
   BOOL Create(CWnd* pParentWnd, LPCTSTR lpszTemplateName, UINT nStyle, UINT nID);
   BOOL Create(CWnd* pParentWnd, UINT nIDTemplate, UINT nStyle, UINT nID);
   Первый параметр CWnd задает окно, для которого создается диалоговая панель управления. Обычно в качестве такого окна выступает главное окно приложения.
   Второй параметр метода Create указывает шаблон панели управления. В зависимости от того, как определена панель управления, в качестве второго параметра можно использовать либо идентификатор шаблона диалоговой панели nIDTemplate, либо его имя lpszTemplateName.
   Третий параметр nStyle определяет начальное положение диалоговой панели управления в окне приложения. Вы можете указать следующие флаги: CBRS_TOP, CBRS_BOTTOM, CBRS_LEFT и CBRS_RIGHT. Они позволяют установить панель управления соответственно у верхней, нижней, левой или правой границы окна.
   Форма диалоговой панели управления зависит от шаблона диалоговой панели и ее расположения в окне приложения. В случае если диалоговая панель управления отображается в верхней или нижней части окна (параметр nStyle равен CBRS_TOP или CBRS_BOTTOM), то ширина панели управления соответствует ширине окна CWnd, а высота — высоте шаблона диалоговой панели. Если же диалоговая панель управления отображается с левой или правой части окна (параметр nStyle равен CBRS_LEFT или CBRS_RIGHT), то ширина панели управления соответствует ширине шаблона диалоговой панели, а высота - высоте окна CWnd.
   Последний параметр nID определяет идентификатор диалоговой панели управления.
   В случае успешного создания диалоговой панели управления метод Create возвращает ненулевое значение. Если при создании панели управления обнаружены ошибки, например, вы указали несуществующий шаблон диалоговой панели, тогда метод Create возвращает нулевое значение.

   Как и в случае разработки обычных диалоговый панелей, сначала следует подготовить шаблон диалоговой панели, которая будет использоваться в качестве панели управления. Для этого можно воспользоваться редактором ресурсов Microsoft Visual C++.
   В шаблоне диалоговой панели следует установить только один стиль – WS_CHILD. Диалоговая панель управления будет выступать в качестве дочернего окна и не должна иметь ни заголовка ни рамки.
   Готовый шаблон следует сохранить в файле ресурсов проекта. На этом подготовка шаблона диалоговой панели управления считается законченной и надо приступить к написанию программного кода для работы с нею.
   В состав класса окна, в котором будет отображаться диалоговая панель управления, надо включить элемент данных класса CDialogBar. Этот элемент данных будет представлять диалоговую панель управления. Если диалоговая панель управления достаточно сложна и имеет много органов управления, то можно создать для нее отдельный класс на основе базового класса CDialogBar. Этот класс следует дополнить методами, обрабатывающими сообщения от органов управления панели. Таким образом вы сможете разгрузить таблицу сообщений главного окна приложения.
   Затем надо переопределить метод OnCreate класса окна и добавить в нем вызов метода Create класса CDialogBar для объекта представляющего диалоговую панель управления.
   Если вы добавляете диалоговую панель управления к приложению, созданному с использованием средств MFC AppWizard, то в нем уже определен метод OnCreate и вам только остается добавить в него соответствующий вызов метода Create.
   Органы управления диалоговой панели передают сообщения непосредственно своему родительскому окну. Добавьте в таблицу сообщений класса окна соответствующие макрокоманды для получения сообщений и включите в класс окна методы для их обработки.
   В следующем разделе мы реализуем только что описанный алгоритм создания диалоговой панели управления на примере приложения DialogBar.

   Создайте новый проект под названием DialogBar. В качестве типа приложения выберите из списка Type строку Application. Настройте проект DialogBar, точно также как вы настраивали проекты Bar и MultiBar: укажите, что приложение будет работать с библиотекой классов MFC.
   Наберите в редакторе исходный текст приложения и сохраните его в файле DialogBar.cpp (листинг 3.10). Чтобы ускорить набор исходного текста приложения, за основу вы можете взять файл Bar.cpp приложения Bar. Готовый файл DialogBar.cpp включите в проект.

Листинг 3.10. Файл DialogBar.cpp

   //============================================================
   // Приложение DialogBar
   // (c) Frolov G.V., 1996
   // E-mail: frolov@glas.apc.org
   //============================================================
   // Исключаем редко используемые определения из
   // включаемых файлов
   #define VC_EXTRALEAN
 
   // Включаемый файл для MFC
   #include <afxwin.h>
   #include <afxext.h>
   #include <afxcmn.h>
 
   // Включаемый файл для ресурсов приложения
   #include "resource.h"
 
   //============================================================
   // Класс CDlgBarApp – главный класс приложения
   //============================================================
   class CDlgBarApp : public CWinApp {
   public:
    // Мы будем переопределять метод InitInstance
    virtual BOOL InitInstance();
   };
 
   // Создаем объект приложение класса CDlgBarApp
   CDlgBarApp DlgBarApp;
 
   //============================================================
   // Класс CDlgBarWindow – представляет главное окно
   //============================================================
   class CDlgBarWindow : public CFrameWnd {
    // Определяем панель управления
   protected:
    // Панель управления на основе класса CDialogBar
    CDialogBar m_wndDialogBar;
 
   protected:
    / Метод OnCreate используется для создания диалоговой
    // панели управления
    afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
 
   public:
    // Объявляем конструктор класса CDlgBarWindow
    CDlgBarWindow();
 
    // Объявляем методы для обработки команд от диалоговой
    // панелей управления
    afx_msg BOOL DlgBarCommand(UINT nID);
    afx_msg void DlgBarCombo();
 
    // Макрокоманда необходима, так как класс
    // CDlgBarWindow обрабатывает сообщения
    DECLARE_MESSAGE_MAP()   
   };
 
   //============================================================
   // Метод BarCommand
   // Обрабатывает команды, выводит на экран сообщение
   //============================================================
   BOOL CDlgBarWindow::DlgBarCommand(UINT nID) {
    CString szCommandAbout;
 
    // Загружаем текстовую строку с идентификатором,
    // соответствующим идентификатору поступившего командного
    // сообщения и выводим ее на экран
    if (szCommandAbout.LoadString(nID)) MessageBox(szCommandAbout);
    else {
     // Ошибка при загрузке строкового ресурса
     TRACE0("Failed to load string\n");
     return -1;     
    }
 
    return TRUE;
   }
 
   //============================================================
   // Метод DlgBarCombo
   // Обрабатывает команды, выводит на экран сообщение
   //============================================================
   void CDlgBarWindow::DlgBarCombo() {
    // Отображаем сообщение о том, что сделан выбор из списка
    MessageBox("Combo-box selection changed");
   }
 
   //============================================================
   // Таблица сообщений класса CDlgBarWindow
   //============================================================
   BEGIN_MESSAGE_MAP(CDlgBarWindow, CFrameWnd)
 
    // Макрокоманда вызывает метод OnCreate
    ON_WM_CREATE()
 
    //============================================================
    // Обработчики команд от диалоговой панели управления
    // Командные сообщения от кнопок Set и Clear
    ON_COMMAND_EX(IDC_BUTTON_SET, DlgBarCommand)
    ON_COMMAND_EX(IDC_BUTTON_CLEAR, DlgBarCommand)
    ON_COMMAND_EX(IDC_CHECK1, DlgBarCommand)
 
    // Командные сообщения от переключателя Alighn
    ON_COMMAND_EX(IDC_RADIO_LEFT, DlgBarCommand)
    ON_COMMAND_EX(IDC_RADIO_CENTER, DlgBarCommand)
    ON_COMMAND_EX(IDC_RADIO_RIGHT, DlgBarCommand)
 
    // Командные сообщения от списка combo-box
    ON_CBN_SELCHANGE(IDC_COMBO_COLOUR, DlgBarCombo)
 
   END_MESSAGE_MAP()
 
   //============================================================
   // Метод InitInstance класса CDlgBarApp
   // Создает главное окно приложения и отображает его на экране
   //============================================================
   BOOL CDlgBarApp::InitInstance() {
    m_pMainWnd = new CDlgBarWindow();
    m_pMainWnd->ShowWindow(m_nCmdShow);
    m_pMainWnd->UpdateWindow();
 
    return TRUE;
   }
 
   //============================================================
   // Конструктор класса CDlgBarWindow
   //============================================================
   CDlgBarWindow::CDlgBarWindow() {
    // Создаем окно приложения, соответствующее
    // данному объекту класса CDlgBarWindow
    Create(NULL, "Dialog Bar", WS_OVERLAPPEDWINDOW, rectDefault, NULL);
   }
 
   //============================================================
   // Метод OnCreate класса CDlgBarWindow
   // Используется для создания панелей управления
   //============================================================
   int CDlgBarWindow::OnCreate(LPCREATESTRUCT lpCreateStruct) {
    // Вызываем метод OnCreate базового класса
    if (CFrameWnd::OnCreate(lpCreateStruct) == -1) return -1;
 
    //============================================================
    // Создаем диалоговую панель управления
    if (!m_wndDialogBar.Create(this, IDD_DIALOG_BAR, CBRS_TOP, DD_DIALOG_BAR)) {
     // Ошибка при создании диалоговой панели управления
     TRACE0("Failed to create dialog bar\n");
     return -1;
    }
    return 0;
   }
   Создайте новый файл ресурсов и включите его в проект под именем DialogBar.rc. Создайте шаблон диалоговой панели, которая будет использоваться в качестве диалоговой панели управления.
   Откройте панель свойств редактируемой панели управления Dialog Properties. Откройте страницу General и присвойте диалоговой панели идентификатор IDD_DIALOG_BAR. Затем откройте страницу Styles. Выберите из списка Style стиль диалоговой панели Child. Укажите, что диалоговая панель не имеет рамки — из списка Border надо выбрать строку None. Все остальные переключатели из страницы Styles и из страниц More Styles и Extended Styles должны быть отключены.
   Чтобы диалоговая панель управления не заняла у вас большую половину окна приложения, постарайтесь сделать ее как можно более узкой.
   Разместите в шаблоне диалоговой панели несколько органов управления. Для нашего примера вам надо создать две кнопки Set и Clear с идентификаторами IDC_BUTTON_SET и IDC_BUTTON_CLEAR, три переключателя Left, Center и Right с зависимой фиксацией, имеющие идентификаторы IDC_RADIO_LEFT, IDC_RADIO_CENTER и IDC_RADIO_RIGHT, а также список combo-box с идентификатором IDC_COMBO_COLOUR. В список IDC_COMBO_COLOUR внесите несколько начальных значений. Мы записали в него названия различных цветов — Red, Blue, Green, Yellow, Black и White. Эти строки будут содержаться в списке сразу после отображения на экране диалоговой панели.
   Добавьте в файл ресурсов строковые ресурсы, описывающие органы управления диалоговой панели. Они должны иметь идентификаторы, соответствующие идентификаторам органов управления.
   Мы привели файл ресурсов, который у вас должен получиться в листинге 3.11.

Листинг 3.11. Файл DialogBar.rc

   //Microsoft Developer Studio generated resource script.
   //
   #include "resource.h"
   #define APSTUDIO_READONLY_SYMBOLS
   //////////////////////////////////////////////////////////////
   //
   // Generated from the TEXTINCLUDE 2 resource.
   //
   #include "afxres.h"
 
   //////////////////////////////////////////////////////////////
   #undef APSTUDIO_READONLY_SYMBOLS
 
   //////////////////////////////////////////////////////////////
   //
   // Russian resources
 
   #if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_RUS)
   #ifdef _WIN32
   LANGUAGE LANG_RUSSIAN, SUBLANG_DEFAULT
   #pragma code_page(1251)
   #endif //_WIN32
 
   #ifdef APSTUDIO_INVOKED
   //////////////////////////////////////////////////////////////
   //
   // TEXTINCLUDE
   //
 
   1 TEXTINCLUDE DISCARDABLE
   BEGIN
    "resource.h\0"
   END
 
   2 TEXTINCLUDE DISCARDABLE
   BEGIN
    "#include ""afxres.h""\r\n"
    "\0"
   END
 
   3 TEXTINCLUDE DISCARDABLE
   BEGIN
    "\r\n"
    "\0"
   END
 
   #endif // APSTUDIO_INVOKED
 
   //////////////////////////////////////////////////////////////
   //
   // Dialog
   //
 
   IDD_DIALOG_BAR DIALOG DISCARDABLE 0, 0, 227, 50
   STYLE WS_CHILD
   FONT 8, "MS Sans Serif"
   BEGIN
    CONTROL "Left", IDC_RADIO_LEFT, "Button", BS_AUTORADIOBUTTON, 95, 10, 40, 10
    CONTROL "Center", IDC_RADIO_CENTER, "Button", BS_AUTORADIOBUTTON, 95, 19, 45, 11
    CONTROL "Right", IDC_RADIO_RIGHT, "Button", BS_AUTORADIOBUTTON, 95, 30, 40, 9
    GROUPBOX "Aligns", IDC_STATIC, 85, 0, 80, 45
    PUSHBUTTON "Set", IDC_BUTTON_SET, 175, 5, 45, 15
    PUSHBUTTON "Clear", IDC_BUTTON_CLEAR, 175, 30, 45, 15
    COMBOBOX IDC_COMBO_COLOUR, 5, 5, 70, 50, CBS_DROPDOWNLIST | CBS_SORT | WS_VSCROLL | WS_TABSTOP
   END
 
   //////////////////////////////////////////////////////////////
   //
   // DESIGNINFO
   //
 
   #ifdef APSTUDIO_INVOKED
   GUIDELINES DESIGNINFO DISCARDABLE
   BEGIN
    IDD_DIALOG_BAR, DIALOG
    BEGIN
     LEFTMARGIN, 7
     RIGHTMARGIN, 220
     TOPMARGIN, 7
     BOTTOMMARGIN, 43
    END
   END
   #endif // APSTUDIO_INVOKED
 
   //////////////////////////////////////////////////////////////
   //
   // Dialog Info
   //
 
   IDD_DIALOG_BAR DLGINIT
   BEGIN
    IDC_COMBO_COLOUR, 0x403, 4, 0, 0x6552, 0x0064,
    IDC_COMBO_COLOUR, 0x403, 5, 0, 0x6c42, 0x6575, "\000"
    IDC_COMBO_COLOUR, 0x403, 6, 0, 0x7247, 0x6565, 0x006e,
    IDC_COMBO_COLOUR, 0x403, 7, 0, 0x6559, 0x6c6c, 0x776f, "\000"
    IDC_COMBO_COLOUR, 0x403, 6, 0, 0x6c42, 0x6361, 0x006b,
    IDC_COMBO_COLOUR, 0x403, 6, 0, 0x6857, 0x7469, 0x0065, 0
   END
 
   //////////////////////////////////////////////////////////////
   //
   // String Table
   //
 
   STRINGTABLE DISCARDABLE
   BEGIN
    IDC_RADIO_LEFT   "Left radio box"
    IDC_RADIO_CENTER "Center radio box"
    IDC_RADIO_RIGHT  "Right radio box"
    IDC_BUTTON_SET   "Set button pressed"
   END
 
   STRINGTABLE DISCARDABLE
   BEGIN
    IDC_BUTTON_CLEAR "Clear button pressed"
   END
 
   #endif // Russian resources
   //////////////////////////////////////////////////////////////
 
   #ifndef APSTUDIO_INVOKED
   //////////////////////////////////////////////////////////////
   // Generated from the TEXTINCLUDE 3 resource.
   //
 
   //////////////////////////////////////////////////////////////
   #endif // not APSTUDIO_INVOKED
   Идентификаторы ресурсов приложения DialogBar и идентификаторы органов управления диалоговой панели IDD_DIALOG_BAR определены в файле resource.h. Этот файл создается автоматически редактором ресурсов Microsoft Visual C++. Исходный текст файла представлен в листинге 3.12.

Листинг 3.12. Файл resource.h

   //{{NO_DEPENDENCIES}}
   // Microsoft Developer Studio generated include file.
   // Used by DialogBar.rc
   //
   #define IDD_DIALOG_BAR   101
   #define IDC_RADIO_LEFT   1004
   #define IDC_RADIO_CENTER 1005
   #define IDC_RADIO_RIGHT  1006
   #define IDC_BUTTON_SET   1007
   #define IDC_BUTTON_CLEAR 1008
   #define IDC_COMBO_COLOUR 1012
 
   // Next default values for new objects
   //
   #ifdef APSTUDIO_INVOKED
   #ifndef APSTUDIO_READONLY_SYMBOLS
   #define _APS_NEXT_RESOURCE_VALUE 104
   #define _APS_NEXT_COMMAND_VALUE  40001
   #define _APS_NEXT_CONTROL_VALUE  1014
   #define _APS_NEXT_SYMED_VALUE    101
   #endif
   #endif
   Постройте приложение DialogBar и запустите его. На экране появится главное окно приложения, в верхней части которого отображается диалоговая панель управления (рис. 3.19).
   Рис. 3.19. Приложение DialogBar
 
   Поработайте с приложением DialogBar. Если вы будете нажимать на кнопки диалоговой панели управления, изменять положение переключателя или выбирать новые строки из списка combo-box, то на экране будут появляться короткие сообщения, описывающие выбранный орган управления.

Как работает приложение DialogBar

   В приложении DialogBar определены всего только два класса – это главный класс приложения CDlgBarApp и класс главного окна приложения CDlgBarWindow. Как и во многих других приложениях, посвященных использованию панелей управления, главное окно приложения по сути является его единственным окном. Однако мы сохранили за ним это почетное название, чтобы внести однообразие в описание приложений, созданных с использованием MFC AppWizard и без него.

Главный класс приложения CDlgBarApp

   Главный класс приложения CDlgBarApp наследуется от базового класса CWinApp. Объект DlgBarApp класса CDlgBarApp объявлен как глобальный и создается сразу после запуска приложения.
   В класс CDlgBarApp входит только метод InitInstance. Он создает главное окно приложения, представленное классом CDlgBarWindow, наследованным от класса CFrameWnd. Мы не станем подробно рассматривать этот метод, так как он фактически идентичен одноименному методу приложений Bar и MultiBar, представленных выше.

Класс главного окна приложения CDlgBarWindow

   Класс CDlgBarWindow управляет главным окном приложения, создает диалоговую панель управления, а также обрабатывает сообщения, поступающие от диалоговой панели управления:
   class CDlgBarWindow : public CFrameWnd {
   // Определяем панель управления
   protected:
   // Панель управления на основе класса CDialogBar
    CDialogBar m_wndDialogBar;
 
   protected:
    // Метод OnCreate используется для создания диалоговой
    // панели управления
    afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
 
   public:
    // Объявляем конструктор класса CDlgBarWindow
    CDlgBarWindow();
 
    // Объявляем методы для обработки команд от диалоговой
    // панелей управления
    afx_msg BOOL DlgBarCommand(UINT nID);
    afx_msg void DlgBarCombo();
 
    // Макрокоманда необходима, так как класс
    // CDlgBarWindow обрабатывает сообщения
    DECLARE_MESSAGE_MAP()
   };
   Кроме ряда методов, в класс CDlgBarWindow входит элемент m_wndDialogBar класса CDialogBar. Этот элемент представляет диалоговую панель управления, которая будет отображаться в главном окне приложения.
   Рассмотрим отдельные методы класса CDlgBarWindow более подробно.
   Сейчас для нас наиболее важен метод OnCreate, который собственно, и создает диалоговую панель управления приложения DialogBar. В таблице сообщений класса CDlgBarWindow, находится макрокоманда ON_WM_CREATE. Поэтому в процессе создания главного окна приложения вызывается метод OnCreate.

Конструктор класса CDlgBarWindow

   Конструктор класса CDlgBarWindow используется для создания главного окна приложения. Мы рассказывали о процедуре создания главного окна приложения в томе 24 серии “Библиотека системного программиста”, посвященном библиотеке MFC, поэтому сейчас не будем на нем останавливаться более подробно.

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

   Таблица сообщений класса CDlgBarWindow обрабатывает сообщения от диалоговой панели управления. В ней также располагается макрокоманда ON_WM_CREATE, которая вызывает метод OnCreate во время создания окна:
   ON_WM_CREATE()
   Когда пользователь работает с диалоговой панелью управления, в ее родительское окно поступают сообщения. От кнопок Set и Clear и переключателя Alighn поступают командные сообщения, которые обрабатываются при помощи макрокоманд ON_COMMAND_EX:
   // Командные сообщения от кнопок Set и Clear
   ON_COMMAND_EX(IDC_BUTTON_SET, DlgBarCommand)
   ON_COMMAND_EX(IDC_BUTTON_CLEAR, DlgBarCommand)
   ON_COMMAND_EX(IDC_CHECK1, DlgBarCommand)
 
   // Командные сообщения от переключателя Alighn
   ON_COMMAND_EX(IDC_RADIO_LEFT, DlgBarCommand)
   ON_COMMAND_EX(IDC_RADIO_CENTER, DlgBarCommand)
   ON_COMMAND_EX(IDC_RADIO_RIGHT, DlgBarCommand)
   Для обработки всех этих командных сообщений вызывается один и тот же метод DlgBarCommand, которому передается идентификатор кнопки или переключателя, вызвавшего сообщение.
   От списка combo-box, расположенного в диалоговой панели управления, мы обрабатываем только одно сообщение с кодом извещения CBN_SELCHANGE. Это сообщение передается, когда пользователь выбирает из списка новую строку:
   // Командные сообщения от списка combo-box
   ON_CBN_SELCHANGE( IDC_COMBO_COLOUR, DlgBarCombo)

Метод OnCreate класса CDlgBarWindow

   Метод OnCreate класса CDlgBarWindow сначала вызывает метод OnCreate базового класса CFrameWnd:
   if (CFrameWnd::OnCreate(lpCreateStruct) == –1) return –1;
 
   Затем мы создаем диалоговую панель управления. Для этого вызываем метод Create для объекта m_wndDialogBar, входящего в класс CDlgBarWindow, и представляющего панель управления:
    if (!m_wndDialogBar.Create(this, IDD_DIALOG_BAR, CBRS_TOP|CBRS_TOOLTIPS, IDD_DIALOG_BAR)) {
     TRACE0("Failed to create dialog bar\n");
     return -1;     
    }
    return 0;
   }
   В качестве родительского окна для диалоговой панели управления мы указываем главное окно приложения. Ключевое слово this представляет указатель на текущий объект, то есть, в данном случае, окно CDlgBarWindow.
   Второй параметр метода указывает идентификатор шаблона диалоговой панели, которая будет отображаться как диалоговая панель управления приложения. Мы указали идентификатор шаблона диалоговой панели IDD_DIALOG_BAR.
   В качестве третьего параметра метода Create мы привели стиль CBRS_TOP. Стиль CBRS_TOP устанавливает расположение диалоговой панели управления в верхней части окна приложения.

Метод DlgBarCombo класса CDlgBarWindow

   Когда пользователь выбирает строку из списка combo-box в диалоговой панели управления, в ее родительское окно, которое в нашем случае является главным окном приложения, поступает сообщение. Для его обработки вызывается метод DlgBarCombo класса CDlgBarWindow.
   Метод DlgBarCombo выводит на экран сообщение о том, что пользователь сделал выбор из списка combo-box:
   void CDlgBarWindow::DlgBarCombo() {
    // Отображаем сообщение о том, что сделан выбор из списка
    MessageBox("Combo-box selection changed");
   }

Метод BarCommand класса CDlgBarWindow

   Командные сообщения от кнопок Set, Clear, и переключателя Alighn обрабатываются методом BarCommand класса CDlgBarWindow. В качестве параметра nID методу BarCommand передается идентификатор вызвавшего его органа управления:
   BOOL CDlgBarWindow::DlgBarCommand(UINT nID) {
    //…
   }
   В приложении мы определили для кнопок Set, Clear, и переключателей группы Alighn, описывающие их строковые ресурсы, которые имеют точно такие же идентификаторы. Поэтому когда вызывается метод DlgBarCommand и ему передается идентификатор кнопки или переключателя, мы загружаем строковый ресурс, который имеет точно такой же идентификатор и отображаем его на экране:
   if (szCommandAbout.LoadString(nID)) MessageBox(szCommandAbout);
   else {
    // Ошибка при загрузке строкового ресурса
    TRACE0("Failed to load string\n");
    return –1;
   }

   Если вам надо добавить панель управления к приложению, созданному с использованием средств MFC AppWizard, вы должны выполнить точно такие же действия, какие были нами описаны в предыдущих разделах. Сначала надо создать шаблон диалоговой панели, затем добавить к классу окна, в котором будет отображаться диалоговая панель управления, элемент класса CDialogBar, и наконец, создать диалоговую панель управления, вызвав соответствующий метод Create.
   Наибольший интерес представляет использование ClassWizard для добавления обработчиков сообщений от диалоговой панели управления. Откройте в редакторе ресурсов шаблон диалоговой панели управления и запустите ClassWizard.
   ClassWizard обнаружит новый ресурс и предложит создать или выбрать для него управляющий класс (рис. 3.20). Сообщения от диалоговой панели управления передаются для обработки в ее родительское окно. Поэтому в качестве управляющего класса надо выбрать класс этого окна. Так как в большинстве случаев в качестве родительского окна для панелей управления, в том числе и для диалоговой панели управления, выступает главное окно приложения, надо выбрать класс CMainFrame.
   Рис. 3.20. Диалоговая панель Adding a Class
 
   Переведите переключатель диалоговой панели Adding a Class в положение Select an existing class и нажмите на кнопку OK. На экране появится диалоговая панель Select Class, содержащая список классов, определенных в приложении (рис. 3.21).
   Рис. 3.21. Диалоговая панель Select Class
 
   Выберите из списка Class list класс главного окна приложения CMainFrame и нажмите на кнопку Select. ClassWizard сообщит о том, что выбранный класс CMainFrame не относится к классам, которые предназначены для управления диалоговыми панелями (рис. 3.22). Для продолжения нажмите на кнопку Yes.
   Рис. 3.22. Предупреждение
 
   Теперь на экране появится окно ClassWizard, в котором вы можете назначить обработчики сообщений от диалоговой панели управления, также просто как для меню или панели управления toolbar.

   Во всех примерах, которые мы привели выше, для создания панели управления мы вызывали метод Create класса CToolBar во время создания окна приложения. В принципе, панель управления можно создать и позже, когда окно уже отображается на экране.
   Возьмите приложение Bar. Добавьте к нему меню Tools, состоящее из одной строки Show Bar. Определите метод OnShowBar, который будет вызываться для обработки команд от этой строки меню. Не забудьте вставить в таблицу сообщений класса окна соответствующую макрокоманду.
   Перенесите код для создания панели управления из метода OnCreate в метод OnShowBar. Теперь панель управления будет создаваться только после того, как вы выберите из меню Tools строку Show Bar.
   Постройте проект и запустите приложение. Вы заметите, что панель управления почему-то возникает не сразу после выбора строки Show Bar. Чтобы панель управления появилась, необходимо еще изменить размер окна приложения.
   Оказывается, метод Create класса CToolBar устанавливает нулевой размер окна панели управления. Настоящий размер панели управления выбирается позже, в зависимости от ее характеристик, а также размеров и характеристик родительского окна.
   Чтобы установить правильные размеры и расположение панели управления следует вызвать метод RecalcLayout . Метод RecalcLayout входит в класс CFrameWnd и вызывается автоматически, если вы используете методы CFrameWnd::ShowControlBar, CFrameWnd::OnIdleUpdateCmdUI, CFrameWnd::OnSize, CFrameWnd::FloatControlBar, CMDIChildWnd::Create, а также некоторые другие.

   В нижней части большинства современных приложений Windows находится строка состояния программы, которая называется панелью состояния. В ней обычно выводится краткая контекстная подсказка для пользователя, содержание которой зависит от того, с каким элементом окна работает пользователь. В панели состояния также может отображаться описание текущего режима приложения, текущее время, объем свободного пространства на диске и т. д.
   Когда вы разрабатываете приложение с оконным интерфейсом при помощи средств MFC AppWizard, вы можете указать, будет ли приложение иметь панель состояния. Этой возможностью управляет переключатель Initial status bar на одной из панелей создания приложения AppWizard. Внешний вид этой панели представлен на рисунке 3.3.
   По умолчанию переключатель Initial status bar установлен, и все оконные приложения, построенные с использованием средств MFC AppWizard, имеют панель состояния. В ней отображается текущее состояние приложения или краткая подсказка для выбранных строк меню, а также текущее положение клавиш <Caps Lock>, <Scroll Lock> и <Num Lock>.

   К сожалению, нет специальных ресурсов, предназначенных для разработки панелей состояния. Редактор ресурсов вам не поможет – панель состояния создается “вручную”. Каждый элемент панели состояния должен быть описан в специальном массиве.

   Для управления панелями состояния в состав библиотеки MFC включен класс CStatusBar. Как и классы CToolBar и CDialogBar, предназначенные для работы с панелями управления, класс CStatusBar также наследуется от базового класса CControlBar:
   CStatusBar←CControlBar←CWnd←CCmdTarget←CObject

   Процесс создания панели состояния во многом схож с процессом создания панелей управления.
   Сначала надо создать объект для управления панелью состояния. Обычно для этого включают объект класса CStatusBar непосредственно в класс окна приложения, в котором будет размещена панель состояния.
   Конструктор класса CStatusBar не имеет параметров и выглядит так:
   CStatusBar();
   В некоторых случаях, вместо использования класса CStatusBar, от него предварительно наследуют дополнительный класс. В этом случае, для создания панели состояния используют именно этот класс.
   Следующим шагом является создание самой панели состояния. Панель состояния создается вызовом метода Create класса CStatusBar:
   BOOL Create(CWnd* pParentWnd, DWORD dwStyle = WS_CHILD | WS_VISIBLE | CBRS_BOTTOM, UINT nID = AFX_IDW_STATUS_BAR);
   Через первый параметр метода pParentWnd вы должны указать окно, для которого создается панель состояния.
   Второй параметр dwStyle позволяет задать характеристики панели состояния, в том числе ее расположение внутри окна. Панель состояния является дочерним окном, поэтому в параметре dwStyle надо указать атрибут WS_CHILD. Если вы не укажите атрибут WS_CHILD, ничего страшного тоже не случится — этот атрибут установится автоматически во время вызова метода Create. А вот атрибут WS_VISIBLE более важен. Если его опустить, то панель состояния хотя и будет создана, но на экране не появится.
   Вы можете разместить панель состояния либо в верху, либо внизу окна. По умолчанию панель состояния размещается в нижней части окна (используется атрибут CBRS_BOTTOM). Чтобы панель состояния была размещена вверху окна, укажите в качестве параметра dwStyle атрибут CBRS_TOP. Если вы используете параметр dwStyle, надо обязательно указать либо атрибут CBRS_BOTTOM, либо атрибут CBRS_TOP.
   Последний параметр метода nID определяет идентификатор дочернего окна панели состояния. По умолчанию используется идентификатор AFX_IDW_STATUS_BAR.

   Приложения, созданные MFC AppWizard, имеют меню View, содержащее строки Toolbar и Status bar. Строка Status bar с идентификатором ID_VIEW_STATUS_BAR позволяет закрывать и снова открывать панель состояния. Обработка стандартного командного сообщения ID_VIEW_STATUS_BAR выполняется методом OnUpdateControlBarMenu класса CFrameWnd. Метод OnUpdateControlBarMenu может управлять отображением панели управления только в том случае, если она имеет идентификатор AFX_IDW_STATUS_BAR. Более подробно о методе OnUpdateControlBarMenu можно прочитать в разделе “Недокументированные возможности класса CMainFrame”.

   В случае успешного создания панели состояния метод Create возвращает ненулевое значение. Если в ходе создания панели состояния обнаружены ошибки, тогда метод Create возвращает нулевое значение.
   После того как панель состояния создана, необходимо определить ее внешний вид. Для достижения этой цели вызывают метод SetIndicators и ему передают массив идентификаторов, представляющих индикаторы панели состояния. Каждый элемент панели состояния (индикатор) должен иметь отдельный идентификатор.
   Метод SetIndicators загружает строковые ресурсы, соответствующие идентификаторам индикаторов, и размещает их на панели состояния:
   BOOL SetIndicators(const UINT* lpIDArray, int nIDCount);
   Через параметр lpIDArray, методу SetIndicators, надо передать указатель на массив идентификаторов панели состояния. Общее количество индикаторов панели состояния, определенных в массиве lpIDArray, задается параметром nIDCount.
   Обычно для определения количества элементов массива используют следующий код:
   nIDCount = sizeof(indicators)/sizeof(UINT);
   Переменная indicators представляет массив идентификаторов панели состояния.
   В случае успешного завершения метод SetIndicators возвращает ненулевое значение. Если же будут обнаружены ошибки, тогда метод SetIndicators возвращает нулевое значение.
   Когда индикаторы созданы, вы можете изменить некоторые их характеристики, воспользовавшись методом SetPaneInfo:
   void SetPaneInfo(int nIndex, UINT nID, UINT nStyle, int cxWidth);
   Параметр nIndex определяет порядковый номер индикатора в панели состояния или, другими словами, его индекс. Характеристики этого индикатора будут меняться.
   Метод SetPaneInfo позволяет изменить расположение индикаторов на панели, или даже заменить существующий индикатор новым индикатором. Для этого можно указать новый идентификатор через параметр nID. Если вы не знаете идентификатор индикатора, тогда можете определить его с помощью метода GetItemID. Метод GetItemID возвращает идентификатор индикатора с индексом nIndex:
   UINT GetItemID(int nIndex) const;
   Обратная операция выполняется при помощи метода CommandToIndex. Метод CommandToIndex возвращает индекс индикатора, имеющего идентификатор nIDFind. Если идентификатор указан неверно, возвращается значение -1:
   int CommandToIndex(UINT nIDFind) const;
   После короткого отступления вернемся к рассказу о параметрах метода SetPaneInfo.
   Внешний вид идентификатора, заданного параметрами nIndex и nID, определяется параметрами nStyle и cxWidth. В качестве nStyle можно указать один или несколько атрибутов, объединенных логической операцией ИЛИ.

Атрибут	Описание
SBPS_NOBORDERS	Убрать трехмерную рамку вокруг индикатора
SBPS_POPOUT	Обычная рамка вокруг индикатора создает впечатление, что индикатор расположен в углублении. Если указать атрибут SBPS_POPOUT, рамка изменяется таким образом, что индикатор будет располагается выше общего уровня панели состояния
SBPS_DISABLED	Если указать этот атрибут, то в индикаторе не будет отображаться текст из соответствующего строкового ресурса
SBPS_STRETCH	Один из индикаторов панели состояния может менять свой размер в зависимости от размера окна. Атрибут SBPS_STRETCH предназначен для выбора этого индикатора
SBPS_NORMAL	Стандартный индикатор

   Параметр cxWidth определяет ширину индикатора. Когда вы создаете панель состояния и устанавливаете индикаторы, вызывая метод SetIndicators, размер индикаторов определяется автоматически исходя из ширины текста индикатора.
   Если первый элемент массива идентификаторов, переданного методу SetIndicators, содержит константу ID_SEPARATOR, то для первого индикатора панели состояния по умолчанию устанавливаются атрибуты SBPS_NOBORDERS и SBPS_STRETCH.
   Узнать текущие характеристики индикатора можно при помощи метода GetPaneInfo. Он позволяет определить идентификатор, стиль и ширину индикатора с индексом nIndex:
   void GetPaneInfo(int nIndex, UINT& nID, UINT& nStyle, int& cxWidth) const;
   Идентификатор записывается в переменную, ссылка на которую передается через параметр nID, набор атрибутов, определяющих внешний вид индикатора – в переменную nStyle, а ширина – в переменную cxWidth.
   Если вам требуется определить или установить только стиль индикатора в панели управления, то вместо методов GetPaneInfo и SetPaneInfo лучше использовать два других метода класса CStatusBar – метод GetPaneStyle и метод SetPaneStyle.

   Для изменения текста в самом первом индикаторе панели состояния, который имеет идентификатор ID_SEPARATOR, можно воспользоваться методом SetWindowText. Этот метод определен в классе CWnd и вы можете его использовать, так как класс панели состояния наследуется от класса CWnd. Строку, которую надо вывести в панели состояния, следует передать через параметр lpszString:
   void SetWindowText(LPCTSTR lpszString);
   Метод SetWindowText изменяет текст в панели состояния, передавая ему сообщение WM_SETTEXT. Самый первый индикатор панели состояния, который имеет идентификатор ID_SEPARATOR, отличается от остальных индикаторов панели состояния. В нем отображаются подсказки для выбранных строк меню, кнопок панели управления и в некоторых других случаях. Фактически, этот индикатор используется различными объектами библиотеки MFC для отображения своего состояния или кратких подсказок.
   Объекты MFC устанавливают текст первого идентификатора, непосредственно передавая окну панели состояния сообщение WM_SETTEXT. Отсюда, кстати, следует не очень утешительный вывод: текст, который вы выводите методом SetWindowText, может быть изменен в любой момент без вашего ведома. Чтобы исправить такое положение вещей, можно наследовать от класса CStatusBar собственный класс, в котором определить обработчик для сообщения WM_SETTEXT. Этот обработчик, например, может полностью игнорировать сообщения WM_SETTEXT или обрабатывать их только в особых случаях.
   Если вам надо изменить текст не только в самом первом индикаторе, но и в других индикаторах панели состояния, можно воспользоваться методом SetPaneText, который определен в классе CStatusBar:
   BOOL SetPaneText(int nIndex, LPCTSTR lpszNewText, BOOL bUpdate = TRUE);
   Метод SetPaneText выводит в индикаторе с индексом nIndex текст, указанный в параметре lpszNewText. Параметр bUpdate позволяет сразу обновить данный индикатор. Если bUpdate содержит значение TRUE, то индикатор будет перерисован.
   Текст, который отображается в индикаторе в данный момент, можно определить при помощи метода GetPaneText, также входящего в класс CStatusBar.
   Еще один метод изменения индикаторов панели состояния основан на обработке сообщения ON_UPDATE_COMMAND_UI. Во время, когда приложение простаивает, сообщение ON_UPDATE_COMMAND_UI передается приложению для всех индикаторов панели состояния. Напомним, что сообщение ON_UPDATE_COMMAND_UI также рассылается для всех строк меню и всех кнопок панелей управления приложения.
   Имена для методов обработчиков сообщения ON_UPDATE_COMMAND_UI обычно составляются из строки OnUpdate и имени объекта, сообщения которого обрабатываются. Формат этих методов следующий:
   afx_msg void OnUpdateCtrlName(CCmdUI* pCmdUI);
   Обработчику сообщения ON_UPDATE_COMMAND_UI через параметр pCmdUI передается указатель на объект класса CCmdUI. Полученный объект класса CCmdUI представляет индикатор панели состояния.

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

   Во время обработки сообщения ON_UPDATE_COMMAND_UI вы можете изменить текст в данном индикаторе, вызвав метод SetText класса CCmdUI. Новый текст для индикатора надо указать в качестве параметра lpszText метода SetText:
   virtual void SetText(LPCTSTR lpszText);
   Метод SetText не выполняет автоматическое изменение размера индикатора. Поэтому, вы должны сами следить за шириной отображаемого текста и в случае необходимости корректировать размер индикатора при помощи метода SetPaneInfo.
   Во время обработки сообщения ON_UPDATE_COMMAND_UI можно не только изменить текст в индикаторе, можно полностью заблокировать индикатор. В заблокированном индикаторе текст не отображается. Чтобы выполнить блокировку индикатора, при обработке , при обработке соответствующего сообщения надо вызвать метод Enable.
   Метод Enable, также как метод SetText, определен в классе CCmdUI и имеет следующий прототип:
   virtual void Enable(BOOL bOn = TRUE);
   Единственный параметр метода bOn выбирает новое состояние индикатора. Если в качестве параметра bOn указать значение TRUE или вызвать метод Enable без параметра, индикатор переходит в нормальное состояние – текст внутри индикатора отображается. Если через параметр bOn передать значение FALSE, тогда выполняется блокировка индикатора.

   Если во время работы приложения выполняется какой-либо длительный процесс, например загрузка или сохранение документа, тогда в панели состояния можно вывести линейный индикатор progress bar. С ее помощью вы легко сможете показать ход данного процесса.
   Многие офисные приложения, и сама среда Microsoft Visual C++, использует панель состояния подобным образом. Так, например, когда вы сохраняете документ в текстовом процессоре Microsoft Word, то в панели состояния отображается линейный индикатор progress bar, отражающий процесс сохранения документа.
   Методика размещения полосы progress bar на панели состояния достаточно проста. В тот момент, когда потребуется вывести полосу progress bar, просто создайте ее, указав в качестве родительского окна панель состояния. Координаты линейного индикатора progress bar желательно выбрать таким образом, чтобы он отображался на месте одного из индикаторов. Предварительно вы можете убрать рамку с этого индикатора и заблокировать его так, чтобы в нем не отображался текст.

   Создайте новый проект под названием Status. В качестве типа приложения выберите из списка Type строку Application. Настройте проект Status, указав, что приложение будет работать с библиотекой классов MFC.
   Наберите в редакторе исходный текст приложения и сохраните его в файле Status.cpp (листинг 3.13). Включите готовый файл DialogBar.cpp в проект.

Листинг 3.13. Файл Status.cpp

   //============================================================
   // Приложение Status
   // (c) Frolov G.V., 1996
   // E-mail: frolov@glas.apc.org
   //============================================================
 
   // Включаемые файлы для MFC
   #include <afxwin.h>
   #include <afxext.h>
   #include <afxcmn.h>
 
   // Включаемый файл для ресурсов приложения и идентификаторов
   #include "resource.h"
 
   //============================================================
   // Класс CStateApp – главный класс приложения
   //============================================================
   class CStateApp : public CWinApp {
   public:
    // Мы будем переопределять метод InitInstance,
    // предназначенный для инициализации приложения
    virtual BOOL InitInstance();
   };
 
   // Создаем объект приложение класса CStateApp
   CStateApp StateApp;
 
   //============================================================
   // Класс CStateWindow – представляет главное окно
   //============================================================
   class CStateWindow : public CFrameWnd {
 
   protected:
    CStatusBar  m_wndStatusBar; // Панель состояния
    BOOL  bIndicatorTEXT;       // Флаг для управления
                                // индикатором
                                // ID_INDICATOR_TEXT
 
   protected:
    // Метод для создания окна приложения и панели состояния
    afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
 
   public:
    // Объявляем конструктор класса CStateWindow
    CStateWindow();
 
    // Объявляем методы для обработки команд меню
    afx_msg BOOL OnMenuDirectADD_SUB(UINT nID);
    afx_msg void OnMenuProcessBar();
    afx_msg void OnMenuDisableADD_SUB();
    afx_msg void OnMenuSwitchTEXT();
    afx_msg void OnMenuExit();
 
    // Метод для обработки команды ON_UPDATE_COMMAND_UI
    // от индикатора ID_INDICATOR_TEXT
    afx_msg void OnUpdateTEXT(CCmdUI* pCmdUI);
 
    // Макрокоманда необходима, так как класс
    // CStateWindow обрабатывает сообщения
    DECLARE_MESSAGE_MAP()   
   };
 
   //============================================================
   // Таблица сообщений класса CStateWindow
   //============================================================
   BEGIN_MESSAGE_MAP(CStateWindow, CFrameWnd)
 
    // Макрокоманда вызывает метод OnCreate
    ON_WM_CREATE()
 
    // Обработчик сообщения ON_UPDATE_COMMAND_UI
    ON_UPDATE_COMMAND_UI(ID_INDICATOR_TEXT, OnUpdateTEXT)
 
    // Обработчики команд меню Work
    ON_COMMAND(ID_WORK_PROCESS, OnMenuProcessBar)
    ON_COMMAND(ID_WORK_DISABLE_ADDSUB, OnMenuDisableADD_SUB)
    ON_COMMAND(ID_WORK_ON_SWITCH_TEXT, OnMenuSwitchTEXT)  
    ON_COMMAND_EX(ID_WORK_DIRECT_ADD, OnMenuDirectADD_SUB)
    ON_COMMAND_EX(ID_WORK_DIRECT_SUB, OnMenuDirectADD_SUB) 
    ON_COMMAND(ID_WORK_EXIT, OnMenuExit)
 
   END_MESSAGE_MAP()
 
   //============================================================
   // Индикаторы панели управления. Порядок идентификаторов
   // соответствует порядку индикаторов в панели состояния
   // (до тех пор, пока он не изменен методом SetPaneInfo)
   //============================================================
   static UINT indicators[] = {
    ID_SEPARATOR,          // Самый первый индикатор
    ID_INDICATOR_OVR,      // Индикатор OVR
    ID_INDICATOR_PROGRESS, // Резервирование места для
                           // progress bar
    ID_INDICATOR_CAPS,     // Индикатор клавиши <Caps Lock>
    ID_INDICATOR_NUM,      // Индикатор клавиши <Num Lock>
    ID_INDICATOR_SCRL,     // Индикатор клавиши <Scroll Lock>
    ID_INDICATOR_TEXT,     // Индикатор TEXT/PIC
    ID_INDICATOR_ADD,      // Индикатор ADD/SUB (начальное
                           // состояние START)
   };
 
   //============================================================
   // Метод InitInstance класса CStateApp
   // Создает главное окно приложения и отображает его на экране
   //============================================================
   BOOL CStateApp::InitInstance() {
    m_pMainWnd = new CStateWindow();
    m_pMainWnd->ShowWindow(m_nCmdShow);
    m_pMainWnd->UpdateWindow();
    return TRUE;
   }
 
   //============================================================
   // Конструктор класса CStateWindow
   //============================================================
   CStateWindow::CStateWindow() {
    // Создаем окно приложения, соответствующее
    // данному объекту класса CStateWindow
    Create(NULL, "Status Bar Sample", WS_OVERLAPPEDWINDOW, rectDefault, NULL, MAKEINTRESOURCE(IDR_MENU));
 
    // Устанавливаем значение флага bIndicatorTEXT
    bIndicatorTEXT = TRUE;
   }
 
   //============================================================
   // Метод OnMenuProcessBar класса CStateWindow
   //============================================================
   void CStateWindow::OnMenuProcessBar() {
    // Определяем координаты индикатора ID_INDICATOR_PROGRESS
    RECT rectProgress;
    m_wndStatusBar.GetItemRect(m_wndStatusBar.CommandToIndex(ID_INDICATOR_PROGRESS), &rectProgress);
 
    // Создаем полосу progress bar. Размещаем ее
    // на месте индикатора ID_INDICATOR_PROGRESS
    CProgressCtrl ctrlProgressBar;
 
    if (!ctrlProgressBar.Create(WS_CHILD | WS_VISIBLE, rectProgress, &m_wndStatusBar, 1)) {
     // Ошибка при создании progress bar
     TRACE0("Failed to create progress bar\n");
     return;
    }
 
    // Устанавливаем границы для progress bar
    ctrlProgressBar.SetRange(0, 100);
 
    // Устанавливаем шаг приращения для progress bar
    ctrlProgressBar.SetStep(1);
 
    // Плавно увеличиваем положение progress bar
    for (int i=0; i<100; i++) {
     // Выполняем короткую задержку
     Sleep(10);
 
     // Выполняем шаг приращения progress bar
     ctrlProgressBar.StepIt();
    }
 
    // По завершении, отображаем текст в самом первом
    // индикаторе панели состояния
    m_wndStatusBar.SetWindowText("Process completed");
   }
 
   //============================================================
   // Метод OnMenuDirectADD_SUB класса CStateWindow
   //============================================================
   BOOL CStateWindow::OnMenuDirectADD_SUB(UINT nID) {
    // Определяем индекс индикатора ID_INDICATOR_ADD
    int nIndex = m_wndStatusBar.CommandToIndex(ID_INDICATOR_ADD);
 
    // Устанавливаем нормальный режим отображения индикатора
    m_wndStatusBar.SetPaneStyle(nIndex, SBPS_NORMAL);
 
    // Из меню Work выбрана строка Direct set ADD
    if (nID == ID_WORK_DIRECT_ADD) {
     // Выводим текст ADD
     m_wndStatusBar.SetPaneText(nIndex, "ADD");
    }
 
    // Из меню Work выбрана строка Direct set SUB
    else if(nID == ID_WORK_DIRECT_SUB)   {
     // Изменяем внешний вид индикатора
     m_wndStatusBar.SetPaneStyle(nIndex, SBPS_POPOUT);
 
     // Выводим текст SUB
     m_wndStatusBar.SetPaneText(nIndex, "SUB");
    }
 
    return TRUE;
   }
 
   //============================================================
   // Метод OnMenuDisableADD_SUB класса OnMenuDisableADD_SUB
   //============================================================
   void CStateWindow::OnMenuDisableADD_SUB() {
    // Определяем индекс индикатора ID_INDICATOR_ADD
    int nIndex = m_wndStatusBar.CommandToIndex(ID_INDICATOR_ADD);
 
    // Блокируем индикатор
    m_wndStatusBar.SetPaneStyle(nIndex, SBPS_DISABLED);
   }
 
   //============================================================
   // Метод OnUpdateTEXT класса CStateWindow
   //============================================================
   void CStateWindow::OnMenuSwitchTEXT() {
    // Изменяем состояние флага bIndicatorTEXT,
    // который используется методом OnUpdateTEXT
    bIndicatorTEXT = !bIndicatorTEXT;
   }
 
   //============================================================
   // Метод OnMenuExit класса CStateWindow
   //============================================================
   void CStateWindow::OnMenuExit() {
    // Завершаем приложение
    DestroyWindow();
    return;
   }
 
   //============================================================
   // Метод OnCreate класса CStateWindow
   // Вызывается во время создания окна приложения
   //============================================================
   int CStateWindow::OnCreate(LPCREATESTRUCT lpCreateStruct) {
    // Вызываем метод OnCreate базового класса
    if (CFrameWnd::OnCreate(lpCreateStruct) == -1) return -1;
 
    // Создаем панель состояния
    if (!m_wndStatusBar.Create(this)) {
     // Ошибка при создании панели состояния
     TRACE0("Failed to create status bar\n");
     return -1;  
    }
 
    // Отображаем индикаторы панели состояния
    if (!m_wndStatusBar.SetIndicators(indicators, sizeof(indicators)/sizeof(UINT))) {
     // Ошибка при установке индикаторов
     TRACE0("Failed to set indicators\n");
     return -1;  
    }
 
    // Устанавливаем характеристики индикатора
    // ID_INDICATOR_PROGRESS
    m_wndStatusBar.SetPaneInfo(m_wndStatusBar.CommandToIndex(ID_INDICATOR_PROGRESS), ID_INDICATOR_PROGRESS,
   SBPS_DISABLED | // Текст не отображается
     SBPS_NOBORDERS, // Рамка вокруг индикатора отсутствует
     150);           // Ширина индикатора 150 пикселов
 
    return 0;
   }
 
   //============================================================
   // Метод OnUpdateTEXT класса CStateWindow
   // Обрабатывает сообщение ON_UPDATE_COMMAND_UI
   // от индикатора ID_INDICATOR_TEXT
   //============================================================
   void CStateWindow::OnUpdateTEXT(CCmdUI* pCmdUI) {
    // В зависимости от состояния флага bIndicatorTEXT
    // отображаем в индикаторе ID_INDICATOR_TEXT
    // строку TEXT или PIC
    if (bIndicatorTEXT) pCmdUI->SetText("TEXT"); // отображаем строку TEXT
    else pCmdUI->SetText("PIC"); // отображаем строку PIC
 
    // Разрешаем отображение текста в индикаторе
    pCmdUI->Enable();
   }
   Создайте новый файл ресурсов и включите его в проект под именем Status.rc. Включите в него меню, присвоив ему идентификатор IDR_MENU. Введите строки меню IDR_MENU в соответствии с представленным нами файлом ресурсов (листинг 3.14). Для всех строк меню введите их описания. Они будут записаны в файл ресурсов как строковые ресурсы, имеющие одинаковые идентификаторы со строками меню.
   Добавьте в файл ресурсов строку Ready, выбрав для нее идентификатор AFX_IDS_IDLEMESSAGE. Эта строка будет отображаться в панели состояния во время “бездействия” приложения.
   Добавьте в файл ресурсов строки, представляющие индикаторы панели состояния: ID_INDICATOR_ADD, ID_INDICATOR_PROGRESS и ID_INDICATOR_TEXT.

Листинг 3.14. Файл Status.rc

   //Microsoft Developer Studio generated resource script.
   //
   #include "resource.h"
 
   #define APSTUDIO_READONLY_SYMBOLS
   //////////////////////////////////////////////////////////////
   //
   // Generated from the TEXTINCLUDE 2 resource.
   //
   #include "afxres.h"
 
   //////////////////////////////////////////////////////////////
   #undef APSTUDIO_READONLY_SYMBOLS
 
   //////////////////////////////////////////////////////////////
   // Russian resources
 
   #if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_RUS)
   #ifdef _WIN32
   LANGUAGE LANG_RUSSIAN, SUBLANG_DEFAULT
   #pragma code_page(1251)
   #endif //_WIN32
 
   #ifdef APSTUDIO_INVOKED
   //////////////////////////////////////////////////////////////
   //
   // TEXTINCLUDE
   //
 
   1 TEXTINCLUDE DISCARDABLE
   BEGIN
    "resource.h\0"
   END
 
   2 TEXTINCLUDE DISCARDABLE
   BEGIN
    "#include ""afxres.h""\r\n"
    "\0"
   END
 
   3 TEXTINCLUDE DISCARDABLE
   BEGIN
    "\r\n"
    "\0"
   END
 
   #endif // APSTUDIO_INVOKED
 
   //////////////////////////////////////////////////////////////
   //
   // Menu
   //
 
   IDR_MENU MENU DISCARDABLE
   BEGIN
    POPUP "Work"
    BEGIN
     MENUITEM "Process",         ID_WORK_PROCESS
     MENUITEM "Direct set ADD",  ID_WORK_DIRECT_ADD
     MENUITEM "Direct set SUB",  ID_WORK_DIRECT_SUB
     MENUITEM "Disable ADD SUB", ID_WORK_DISABLE_ADDSUB
     MENUITEM "Switch TEXT",     ID_WORK_ON_SWITCH_TEXT
     MENUITEM SEPARATOR
     MENUITEM "Exit",            ID_WORK_EXIT
    END
   END
 
   //////////////////////////////////////////////////////////////
   //
   // String Table
   //
 
   STRINGTABLE DISCARDABLE
   BEGIN
    ID_INDICATOR_ADD "START"
   END
 
   STRINGTABLE DISCARDABLE
   BEGIN
    ID_INDICATOR_PROGRESS "neve display"
    ID_INDICATOR_TEXT     "TEXT"
   END
 
   STRINGTABLE DISCARDABLE
   BEGIN
    ID_WORK_PROCESS        "Display and play progress bar"
    ID_WORK_DIRECT_ADD     "Set indicator ID_INDICATOR_ADD to ADD"
    ID_WORK_ON_SWITCH_TEXT "Switch text in indicator ID_INDICATOR_TEXT"
    ID_WORK_DIRECT_SUB     "Set indicator ID_INDICATOR_ADD to SUB"
    ID_WORK_DISABLE_ADDSUB "Disable indicator ID_INDICATOR_ADD"
    ID_WORK_EXIT           "Exit application"
   END
 
   STRINGTABLE DISCARDABLE
   BEGIN
    AFX_IDS_IDLEMESSAGE "Ready"
   END
 
   #endif // Russian resources
   //////////////////////////////////////////////////////////////
 
   #ifndef APSTUDIO_INVOKED
   //////////////////////////////////////////////////////////////
   //
   // Generated from the TEXTINCLUDE 3 resource.
   //
 
   //////////////////////////////////////////////////////////////
   #endif // not APSTUDIO_INVOKED
   Идентификаторы ресурсов приложения Status определены в файле resource.h. Этот файл создается автоматически редактором ресурсов Microsoft Visual C++. Исходный текст файла resource.h представлен в листинге 3.15.

Листинг 3.15. Файл resource.h

   //{{NO_DEPENDENCIES}}
   // Microsoft Developer Studio generated include file.
   // Used by Status.rc
   //
   #define ID_INDICATOR_ADD       1
   #define IDR_MENU               101
   #define ID_INDICATOR_PROGRESS  102
   #define ID_INDICATOR_TEXT      103
   #define ID_WORK_PROCESS        40001
   #define ID_WORK_DIRECT_ADD     40006
   #define ID_WORK_ON_SWITCH_TEXT 40007
   #define ID_WORK_DIRECT_SUB     40008
   #define ID_WORK_DISABLE_ADDSUB 40009
   #define ID_WORK_EXIT           40010
   #define ID_TIMER_CHECK         0xE001
 
   // Next default values for new objects
   //
   #ifdef APSTUDIO_INVOKED
   #ifndef APSTUDIO_READONLY_SYMBOLS
   #define _APS_NEXT_RESOURCE_VALUE 106
   #define _APS_NEXT_COMMAND_VALUE  40011
   #define _APS_NEXT_CONTROL_VALUE  1000
   #define _APS_NEXT_SYMED_VALUE    104
   #endif
   #endif
   Постройте приложение Status и запустите его. На экране появится главное окно приложения, в нижней части которого отображается панель состояния (рис. 3.23).
   Рис. 3.23. Приложение Status
 
   В панели состояния расположены несколько индикаторов. Самый первый индикатор, размер которого зависит от размера окна приложения, отображает подсказку о выбранной строке меню приложения или системного меню, а если приложение “бездействует” в нем отображается строка Ready.
   Следующий индикатор OVR. В нашем приложении он не действует. Вы сами можете разработать программный код для управления этим индикатором.
   Вслед за идентификатором OVR следует свободное пространство, занятое индикатором. Этот индикатор не отображается на панели и предназначен только для резервирования места под линейный индикатор progress bar.
   Если вы выберите из меню Work строку Process, то на этом месте появится линейный индикатор, плавно меняющий свое значение. Мы используем линейный индикатор, чтобы отображать ход какого-нибудь длительного процесса.
   После того, как линейный индикатор покажет окончание процесса, он будет удален с панели состояния, а в самом первом индикаторе появится надпись Process completed.
   Затем в панели состояния следуют три стандартных индикатора CAP, NUM и SCRL, которые отображают текущее состояние клавиш <Caps Lock>, <Num Lock> и <Scroll Lock>.
   Следующий индикатор, который мы рассмотрим, называется TEXT. Если вы выберите из меню Work строку Switch TEXT, то надпись TEXT в индикаторе заменится на PIC. Повторный выбор данной строки меню восстановит предыдущее состояние индикатора.
   Последний индикатор в панели состояния START. Этот индикатор управляет тремя строками меню Work. При выборе строки Direct set ADD в индикаторе отображается строка ADD, а при выборе строки Direct set SUB – SUB. Во втором случае также меняется оформление индикатора. Если вы выберите из меню Work строку Disable ADD SUB, то индикатор будет заблокирован.

Как работает приложение Status

   В приложении Status определены два класса – главный класс приложения CStateApp и класс главного окна приложения CStateWindow.

Главный класс приложения CDlgBarApp

   Главный класс приложения CStateApp наследуется от базового класса CWinApp. Объект StateApp класса CStateApp объявлен как глобальный и создается сразу после запуска приложения.
   В класс CStateApp входит только метод InitInstance. Он создает главное окно приложения, представленное классом CStateWindow, наследованным от класса CFrameWnd.

Класс главного окна приложения CStateWindow

   Класс CStateWindow управляет главным окном приложения, создает панель состояния, а также обрабатывает сообщения.
   Кроме ряда методов, в класс CStateWindow входит флаг bIndicatorTEXT, используемый для управления индикатором ID_INDICATOR_TEXT, и объект m_wndStatusBar класса CStatusBar, предназначенный для создания и отображения полосы progress bar.
   Рассмотрим отдельные методы класса CStateWindow более подробно.

Конструктор класса CStateWindow

   Конструктор класса CStateWindow используется для создания главного окна приложения. Для этого вызывается метод Create класса CFrameWnd. Обратите внимание, что метод Create создает окно с меню, которое имеет идентификатор IDR_MENU:
   Create(NULL, "Status Bar Sample", WS_OVERLAPPEDWINDOW, rectDefault, NULL, MAKEINTRESOURCE(IDR_MENU));
   В конструкторе класса CStateWindow также устанавливается начальное состояние флага bIndicatorTEXT:
   bIndicatorTEXT = TRUE;

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

   Таблица сообщений класса CStateWindow обрабатывает командные сообщения от меню Work, а также содержит макрокоманды ON_UPDATE_COMMAND_UI и ON_WM_CREATE.
   Макрокоманда ON_UPDATE_COMMAND_UI вызывает метод OnUpdateTEXT для обновления состояния индикатора ID_INDICATOR_TEXT панели состояния:
   ON_UPDATE_COMMAND_UI(ID_INDICATOR_TEXT, OnUpdateTEXT)
   Макрокоманда ON_WM_CREATE вызывает метод OnCreate во время создания окна:
   ON_WM_CREATE()
   Для обработки командных сообщений от меню Work в таблицу сообщений класса CStateWindow включены несколько макрокоманд ON_COMMAND и ON_COMMAND_EX. Они вызывают обработчики OnMenuProcessBar, OnMenuDisableADD_SUB, OnMenuSwitchTEXT, OnMenuDirectADD_SUB и OnMenuExit:
   ON_COMMAND(ID_WORK_PROCESS, OnMenuProcessBar)
   ON_COMMAND(ID_WORK_DISABLE_ADDSUB, OnMenuDisableADD_SUB)
   ON_COMMAND(ID_WORK_ON_SWITCH_TEXT, OnMenuSwitchTEXT)
   ON_COMMAND(ID_WORK_EXIT, OnMenuExit)
   ON_COMMAND_EX(ID_WORK_DIRECT_ADD, OnMenuDirectADD_SUB)
   ON_COMMAND_EX(ID_WORK_DIRECT_SUB, OnMenuDirectADD_SUB)

Метод OnCreate класса CStateWindow

   Метод OnCreate класса CStateWindow сначала вызывает метод OnCreate базового класса CFrameWnd:
   if (CFrameWnd::OnCreate(lpCreateStruct) == –1) return –1;
   Затем мы создаем панель состояния, указывая в качестве ее родительского окна главное окно приложения:
   if (!m_wndStatusBar.Create(this)) {
    // Ошибка при создании панели состояния
    TRACE0("Failed to create status bar\n");
    return -1;  
   }
   После того, как панель состояния создана, вызываем метод SetIndicators, чтобы установить индикаторы:
   if (!m_wndStatusBar.SetIndicators(indicators, sizeof(indicators)/sizeof(UINT))) {
    // Ошибка при установке индикаторов
    TRACE0("Failed to set indicators\n");
    return -1;  
   }
   Массив, содержащий идентификаторы индикаторов indicators определен в приложении следующим образом:
   static UINT indicators[] = {
    ID_SEPARATOR,          // Самый первый индикатор
    ID_INDICATOR_OVR,      // Индикатор OVR
    ID_INDICATOR_PROGRESS, // Резервирование места для
                           // progress bar
    ID_INDICATOR_CAPS,     // Индикатор клавиши <Caps Lock>
    ID_INDICATOR_NUM,      // Индикатор клавиши <Num Lock>
    ID_INDICATOR_SCRL,     // Индикатор клавиши <Scroll Lock>
    ID_INDICATOR_TEXT,     // Индикатор TEXT/PIC
    ID_INDICATOR_ADD,      // Индикатор ADD/SUB (начальное
                           // состояние START)
   };
   Порядок идентификаторов в массиве indicators соответствует порядку в котором индикаторы будут отображаться в панели состояния. Размер всех индикаторов, кроме первого, выбирается автоматически, так чтобы текст индикатора полностью в нем поместился. Текст индикатора, который отображается в нем по умолчанию, берется из соответствующих строковых ресурсов приложения. Так, например, в последнем индикаторе панели состояния, который имеет идентификатор ID_INDICATOR_ADD будет отображаться строка START, имеющая тот же идентификатор и определенная в ресурсах приложения следующим образом:
   STRINGTABLE DISCARDABLE
   BEGIN
    ID_INDICATOR_ADD "START"
   END
   Все индикаторы панели состояния, кроме индикатора ID_INDICATOR_PROGRESS, отображаются стандартным образом. Стиль индикатора ID_INDICATOR_PROGRESS устанавливается отдельно:
   m_wndStatusBar.SetPaneInfo(m_wndStatusBar.CommandToIndex(ID_INDICATOR_PROGRESS), ID_INDICATOR_PROGRESS,
    SBPS_DISABLED | // текст не отображается
    SBPS_NOBORDERS, // рамка вокруг индикатора отсутствует
    150);           // ширина индикатора 150 пикселов
   Метод SetPaneInfo запрещает отображение текста внутри индикатора и убирает выделяющую рамку. Кроме того, метод SetPaneInfo устанавливает размер индикатора 150 пикселов.

Метод OnMenuProcessBar класса CStateWindow

   Когда пользователь выбирает из меню Work строку Process, на месте индикатора ID_INDICATOR_PROGRESS создается линейный индикатор progress bar, плавно меняющий свое состояние. Обработка командного сообщения от строки Process меню Work осуществляется методом OnMenuProcessBar класса CStateWindow.
   Метод OnMenuProcessBar определяет координаты индикатора ID_INDICATOR_PROGRESS и записывает их во временную переменную rectProgress:
   RECT rectProgress;
   m_wndStatusBar.GetItemRect(m_wndStatusBar.CommandToIndex(ID_INDICATOR_PROGRESS), &rectProgress);
   Затем на месте этого индикатора создается линейный индикатор progress bar. Орган управления progress bar представлен объектом ctrlProgressBar класса CProgressCtrl:
   CProgressCtrl ctrlProgressBar;
   Непосредственно для создания progress bar используется метод Create класса CProgressCtrl. В качестве параметров этому методу указываются атрибуты WS_CHILD и WS_VISIBLE, координаты rectProgress, объект m_wndStatusBar и идентификатор 1:
   if (!ctrlProgressBar.Create(WS_CHILD | WS_VISIBLE, rectProgress, &m_wndStatusBar, 1)) {
    // Ошибка при создании progress bar
    TRACE0("Failed to create progress bar\n");
    return;
   }
   После создания полосы progress bar устанавливаем границы (от 0 до 100), в которых можно менять его значение:
   ctrlProgressBar.SetRange(0, 100);
   Выбираем шаг приращения для progress bar, равный единице:
   ctrlProgressBar.SetStep(1);
   Затем начинаем в цикле изменять значение линейного индикатора progress bar. Чтобы замедлить ход заполнения линейного индикатора, делаем короткую задержку, вызывая функцию Sleep:
   for (int i=0; i<100; i++) {
    Sleep(10);
    ctrlProgressBar.StepIt();
   }
   Когда линейный индикатор progress bar окажется заполнен, вызываем метод SetWindowText, который отображает сообщение Process completed в самом первом индикаторе панели состояния:
   m_wndStatusBar.SetWindowText("Process completed");
   После завершения метода OnMenuProcessBar объект ctrlProgressBar, представляющий линейный индикатор progress bar, уничтожается и одновременно его изображение исчезает с панели состояния.

Метод OnMenuDirectADD_SUB класса CStateWindow

   Когда пользователь выбирает из меню Work строку Process, на месте индикатора ID_INDICATOR_PROGRESS создается линейный индикатор progress bar, плавно меняющий свое состояние. Обработка командного сообщения от строки Process меню Work осуществляется методом OnMenuProcessBar класса CStateWindow.
   Метод OnMenuProcessBar определяет координаты индикатора ID_INDICATOR_PROGRESS и записывает их во временную переменную rectProgress:
   RECT rectProgress;
   m_wndStatusBar.GetItemRect(m_wndStatusBar.CommandToIndex(ID_INDICATOR_PROGRESS), &rectProgress);
   Затем на месте этого индикатора создается линейный индикатор progress bar. Орган управления progress bar представлен объектом ctrlProgressBar класса CProgressCtrl:
   CProgressCtrl ctrlProgressBar;
   Непосредственно для создания progress bar используется метод Create класса CProgressCtrl. В качестве параметров этому методу указываются атрибуты WS_CHILD и WS_VISIBLE, координаты rectProgress, объект m_wndStatusBar и идентификатор 1:
   if (!ctrlProgressBar.Create(WS_CHILD | WS_VISIBLE, rectProgress, &m_wndStatusBar, 1)) {
    // Ошибка при создании progress bar
    TRACE0("Failed to create progress bar\n");
    return;
   }
   После создания полосы progress bar устанавливаем границы (от 0 до 100), в которых можно менять его значение:
   ctrlProgressBar.SetRange(0, 100);
   Выбираем шаг приращения для progress bar, равный единице:
   ctrlProgressBar.SetStep(1);
   Затем начинаем в цикле изменять значение линейного индикатора progress bar. Чтобы замедлить ход заполнения линейного индикатора, делаем короткую задержку, вызывая функцию Sleep:
   for (int i=0; i<100; i++) {
    Sleep(10);
    ctrlProgressBar.StepIt();
   }
   Когда линейный индикатор progress bar окажется заполнен, вызываем метод SetWindowText, который отображает сообщение Process completed в самом первом индикаторе панели состояния:
   m_wndStatusBar.SetWindowText("Process completed");

Метод OnMenuDirectADD_SUB класса CStateWindow

   Метод OnMenuDirectADD_SUB класса CStateWindow вызывается для обработки командного сообщения с идентификатором ID_WORK_DISABLE_ADDSUB, передаваемым при выборе из меню Work строки Disable ADD SUB.
   Метод OnMenuDisableADD_SUB определяет индекс индикатора ID_INDICATOR_ADD, а затем блокирует его.
   Чтобы узнать индекс индикатора ID_INDICATOR_ADD, мы вызываем метод CommandToIndex:
   int nIndex = m_wndStatusBar.CommandToIndex(ID_INDICATOR_ADD);
   Для блокировки индикатора вызываем метод SetPaneStyle, которому указываем индекс индикатора и атрибут SBPS_DISABLED:
   m_wndStatusBar.SetPaneStyle(nIndex, SBPS_DISABLED);

Методы OnMenuSwitchTEXT и OnUpdateTEXT класса CStateWindow

   Методы OnMenuSwitchTEXT и OnUpdateTEXT используются в приложении совместно для управления состоянием индикатора ID_INDICATOR_TEXT.
   Метод OnMenuSwitchTEXT вызывается для обработки командного сообщения с идентификатором ID_WORK_ON_SWITCH_TEXT. Это сообщение поступает в случае выбора из меню Work строки Switch TEXT:
   ON_COMMAND(ID_WORK_ON_SWITCH_TEXT, OnMenuSwitchTEXT)
   Единственная задача метода OnMenuSwitchTEXT заключается в изменении состояния флага bIndicatorTEXT. Если флаг bIndicatorTEXT имеет значение TRUE, тогда метод OnMenuSwitchTEXT меняет его на FALSE и наоборот:
   void CStateWindow::OnMenuSwitchTEXT() {
    bIndicatorTEXT = !bIndicatorTEXT;
   }
   Метод OnUpdateTEXT класса CStateWindow, вызывается макрокомандой ON_UPDATE_COMMAND_UI из таблицы сообщений класса CStateWindow:
   ON_UPDATE_COMMAND_UI(ID_INDICATOR_TEXT, OnUpdateTEXT)
   Мы используем этот метод, чтобы изменить текст, отображаемый в индикаторе ID_INDICATOR_TEXT. В зависимости от состояния флага bIndicatorTEXT, установленного методом OnMenuSwitchTEXT, метод OnUpdateTEXT отображает в индикаторе либо строку TEXT, либо строку PIC:
   void CStateWindow::OnUpdateTEXT(CCmdUI* pCmdUI) {
    // В зависимости от состояния флага bIndicatorTEXT
    // отображаем в индикаторе ID_INDICATOR_TEXT
    // строку TEXT или PIC
    if (bIndicatorTEXT) pCmdUI->SetText("TEXT"); // отображаем строку TEXT
    else pCmdUI->SetText("PIC");  // отображаем строку PIC
 
    // Разрешаем отображение текста в индикаторе
    pCmdUI->Enable();
   }
   В качестве параметра pCmdUI методу OnUpdateTEXT передается указатель на объект класса CCmdUI. Этот объект представляет объект интерфейса приложения (строку меню, кнопку панели управления или индикатор панели состояния). В контексте данного конкретного метода этот объект представляет индикатор панели состояния, имеющий идентификатор ID_INDICATOR_TEXT.
   Для управления индикатором мы используем методы SetText и Enable класса CCmdUI. Эти методы устанавливают текст индикатора и снимают с него блокировку (если блокировка ранее была установлена).

Метод OnMenuExit класса CStateWindow

   Пользователь может завершить приложение, выбрав из меню Work строку Exit. В этом случае приложению передается командное сообщение с идентификатором ID_WORK_EXIT. Соответствующая макрокоманда ON_COMMAND из таблицы сообщений класса CStateWindow вызывает для обработки этого сообщения метод OnMenuExit:
   ON_COMMAND(ID_WORK_EXIT, OnMenuExit)
   Метод OnMenuExit завершает работу приложения, для чего вызывает метод DestroyWindow, определенный в классе CWnd для главного окна приложения:
   DestroyWindow();

   Чтобы отобразить на экране стандартную диалоговую панель выбора цвета , надо создать объект класса CColorDialog, а затем вызвать метод DoModal. При создании объекта класса CColorDialog используйте следующий конструктор:
   CColorDialog(COLORREF clrInit = 0, DWORD dwFlags = 0, CWnd* pParentWnd = NULL);
   Все параметры конструктора необязательные, вы можете их опустить, однако в некоторых случаях, использование этих параметров может вам помочь.
   Первый параметр clrInit позволяет указать цвет, выбранный по умолчанию сразу после открытия диалоговой панели. Если параметр не будет указан, в качестве цвета, выбранного по умолчанию будет использоваться черный цвет.
   Параметр dwFlags содержит набор флагов, управляющих диалоговой панелью выбора цвета. Подробно про эти флаги вы можете прочитать в 14 томе “Библиотеки системного программиста”, в разделе, описывающем структуру CHOOSECOLOR.
   Последний параметр pParentWnd можно использовать, чтобы указать родительское окно диалоговой панели.
   Если при создании объекта CColorDialog вы не укажите параметр dwFlags, вы, тем не менее, можете выполнить настройку диалоговой панели, обратившись непосредственно к элементу m_cc данного класса. Параметр dwFlags, указанный в конструкторе, используется для инициализации m_cc. Изменения в элемент m_cc должны быть внесены до того, как панель будет отображена на экране.

   Чтобы вывести диалоговую панель выбора цвета на экран, вы должны использовать метод DoModal:
   virtual int DoModal();
   После отображения панели на экране пользователь может выбрать из нее цвет и нажать кнопку OK или Cancel для подтверждения выбора цвета или отказа от него. Когда диалоговая панель закрывается, метод DoModal возвращает значение IDOK или IDCANCEL, в зависимости от того, какую кнопку нажал пользователь:
   CColorDialog dlgColor;
   int iResult;
   iResult = dlgColor.DoModal();
   На экране появится стандартная диалоговая панель выбора цвета Color (рис. 4.2). В верхней половине диалоговой панели, ниже надписи Basic colors, рассположены 48 прямоугольников, имеющих различные цвета. Они представляют так называемые основные цвета. Вы можете выбрать любой из этих цветов, и нажать кнопку OK.
   Рис. 4.2. Стандартная диалоговая панель Color
 
   После того как диалоговая панель закрыта, вы можете воспользоваться методами класса CColorDialog, чтобы узнать цвета, выбранные пользователем.
   Для определения цвета, выбранного пользователем можно обратиться к методу GetColor класса CColorDialog:
   COLORREF GetColor() const;
   Данный метод возвращает значение COLORREF, соответствующее выбранному цвету. Если вам недостаточно основных цветов, представленных в диалоговой панели Color, вы можете выбрать до 16 дополнительных цветов. Чтобы выбрать дополнительные цвета, нажмите кнопку Define Custom Colors. Диалоговая панель Color изменит свой внешний вид (рис. 4.3).
   Рис. 4.3. Выбор дополнительных цветов
 
   С правой стороны появятся дополнительные органы управления, позволяющие выбрать любой из 16777216 цветов. Когда цвет выбран, нажмите кнопку Add Custom Colors. Выбранный вами цвет будет добавлен к дополнительным цветам. С левой стороны панели, под надписью Custom colors, один из свободных прямоугольников окрасится соответствующим цветом.
   Вы можете определить дополнительные цвета, выбранные пользователем в диалоговой панели Color, при помощи метода GetSavedCustomColors класса CColorDialog:
   static COLORREF* GetSavedCustomColors();
   Метод GetSavedCustomColors возвращает указатель на массив из 16 элементов типа COLORREF . Каждый элемент массива описывает один дополнительный цвет.
   Когда диалоговая панель Color отображается приложением первый раз, все прямоугольники, отображающие дополнительные цвета, имеют белый цвет. Соответствующие элементы массива, полученного методом GetSavedCustomColors, будут иметь значение RGB(255,255,255). Дополнительные цвета, выбранные пользователем, сохраняются во время работы приложения. После перезапуска приложения дополнительные цвета сбрасываются.

   Среди стандартных диалоговых панелей , для которых в библиотеке MFC создан специальный класс, есть панели для работы с файловой системой – Open и Save As (рис. 4.4). Диалоговая панель Open позволяет выбрать один или несколько файлов, расположенных на дисках компьютера, и открыть их для дальнейшего использования. Диалоговая панель Save As позволяет выбрать имя файла для записи в него документа.
   Для управления диалоговыми панелями Open и Save As предназначен один единственный класс – CFileDialog . Рассмотрим конструктор класса CFileDialog более подробно:
   CFileDialog(BOOL bOpenFileDialog, LPCTSTR lpszDefExt = NULL, LPCTSTR lpszFileName = NULL, DWORD dwFlags = OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT, LPCTSTR lpszFilter = NULL, CWnd* pParentWnd = NULL);
   Объекты класса CFileDialog представляют диалоговую панель Open или Save As в зависимости от параметра bOpenFileDialog. Если параметр bOpenFileDialog содержит значение TRUE, тогда создается объект, управляющий диалоговой панелью Open, а если FALSE – диалоговой панелью Save As.
   Параметр bOpenFileDialog является единственным параметром, который вы должны указать. Остольные параметры конструктора класса CFileDialog задают различные режимы работы панели и могут не указываться.
   Так, чтобы создать объект класса CFileDialog, представляющий стандартную диалоговую панель для открытия файлов (mFileOpen), и объект, представляющий стандартную диалоговую панель для сохранения файлов (mFileSaveAs), можно воспользоваться следующими вызовами конструктора класса:
   // Объект mFileOpen представляет стандартную
   // диалоговую панель Open
   CFileDialog mFileOpen(TRUE);
   // Объект mFileOpen представляет диалоговую
   // панель SaveAs
   CFileDialog mFileSaveAs(TRUE);
   Во многих случаях файлы, которые вы открываете или закрываете в вашем приложении, имеют определенное расширение. Параметр lpszDefExt позволяет задать расширение файлов, используемое по умолчанию. Если пользователь не укажет расширение файла явным образом, ему автоматически присваивается расширение, принятое по умолчанию. В случае если параметр lpszDefExt не указан или содержит значение NULL, то расширение файлов должно задаваться явно.
   В некоторых случаях требуется, чтобы диалоговые панели для открытия или сохранения файлов отображались с уже выбранным именем файла. Пользователь может согласиться с предложенным именем или выбрать другое. Чтобы указать имя файла, используемое по умолчанию, воспользуйтесь параметром lpszFileName. Если параметр lpszFileName имеет значение NULL, данная возможность не реализуется.
   Вы можете изменить внешний вид и некоторые другие характеристики стандартных диалоговых панелей для открытия и сохранения файлов с помощью параметра dwFlags. В него записывается комбинация флагов, управляющих различными характеристиками этих панелей. Назначение данного параметра соответствует полю Flags структуры OPENFILENAME. Описание структуры OPENFILENAME вы можете найти в 13 томе “Библиотеки системного программиста”.
   Диалоговые панели для открытия и сохранения файлов обычно имеют список так называемых фильтров, включающих названия типа файлов и расширения имен файлов данного типа. Выбрав фильтр, пользователь указывает, что он желает работать только с файлами определенного типа, имеющими соответствующие расширения. Файлы с другими расширениями в диалоговых панелях не отображаются.
   Вы можете указать список фильтров для диалоговых панелей Open и Save As через параметр lpszFilter. Одновременно можно указать несколько фильтров. Каждый фильтр задается двумя строками – строкой, содержащей имя фильтра, и строкой, в которой паречислены соответствующие ему расширения имен файлов. Если одному типу файлов соответствуют несколько расширений, они разделяются символом ;. Строка, содержашая имя фильтра, отделяется от строки с расширениями файлов символом |. Если используются несколько фильтров, то они также отделяются друг от друга символом |.
   Диалоговые панели, представленные объектами класса CFileDialog, могут иметь или не иметь родительского окна. Чтобы указать родительское окно, передайте конструктору CFileDialog указатель на него через параметр pParentWnd.
   Рис. 4.4. Стандартная диалоговая панель Save As

   Создание объекта класса CFileDialog еще не вызывает отображения соответствующей диалоговой панели. Для этого необходимо воспользоваться специальным методом DoModal класса CFileDialog.
   Виртуальный метод DoModal , первоначально определенный в классе CDialog, переопределен в классе CFileDialog:
   virtual int DoModal();
   При вызове метода DoModal для ранее созданного объекта класса CFileDialog на экране открывается соответствующая диалоговая панель. После того, как вы закончите работать с диалоговой панелью и закроете ее, метод DoModal вернет значения IDOK или IDCANCEL в случае успешного завершения и 0 – в случае возникновения ошибок.
   Если вы выберите имя файла и нажмете кнопку Open (для панели Open) или кнопку Save (для панели Save As), метод DoModal вернет значение IDOK. Если вы решите отменить выбор файла и нажмете кнопку Cancel или выберите из меню диалоговой панели строку Close, метод DoModal вернет значение IDCANCEL.
   После того, как вы закроете диалоговую панель и метод DoModal вернет управление, можно воспользоваться другими методами класса CFileDialog, чтобы определить имена выбранных файлов.

Метод	Описание
GetPathName	Определяет полный путь выбранного файла
GetFileName	Определяет имя выбранного файла
GetFileExt	Определяет расширение имени выбранного файла
GetFileTitle	Позволяет определить заголовок выбранного файла
GetNextPathName	Если диалоговая панель позволяет выбрать сразу несколько файлов, то метод GetNextPathName можно использовать для определения полного пути следующего из выбранных файлов
GetReadOnlyPref	Позволяет узнать состояние атрибута “только читаемый” (read-only) выбранного файла
GetStartPosition	Возвращает положение первого элемента из списка имен файлов

   Наиболее важный метод из представленных в таблице – GetPathName. Он получает полный путь файла, выбранного из диалоговых панелей Open или Save As:
   CString GetPathName() const;
   Как мы уже говорили, диалоговые панели Open и Save As можно использовать для выбора нескольких файлов. Для этого, в поле Flags структуры m_ofn должен быть установлен флаг OFN_ALLOWMULTISELECT. Тогда метод GetPathName возвращает массив строк, состоящий из нескольких строк, заканчивающихся двоичным нулем. Первая из данных строк содержит путь к каталогу, в котором расположены выбранные файлы, остальные строки содержат имена выбранных файлов. Естественно, с тем чтобы выделить путь к каталогу проблем не возникает, а чтобы получить имена выбранных файлов, вы должны использовать методы GetStartPosition и GetNextPathName.
   Метод GetStartPosition возвращает значение типа POSITION. Оно предназначено для передачи методу GetNextPathName и получения очередного имени выбранного файла. Если пользователь не выбрал ни одного файла, метод GetStartPosition возвращает значение NULL:
   POSITION GetStartPosition() const;
   Значение, полученное методом GetStartPosition, следует записать во временную переменную типа POSITION и передать ссылку на нее методу GetNextPathName:
   CString GetNextPathName(POSITION& pos) const;
   Метод GetNextPathName вернет полный путь первого, из выбранных в диалоговой панели файлов, и изменит значение переменной pos, переданной методу по ссылке. Новое значение переменной pos можно использовать для последующих вызовов метода GetNextPathName и получения полных путей всех остальных выбранных файлов. Когда метод GetNextPathName вернет имена всех выбранных файлов, в переменную pos записывается значение NULL.
   В отличие от метода GetPathName, метод GetFileName позволяет определить только имя выбранного файла, без пути и расширения:
   CString GetFileName() const;
   Метод GetFileExt возвращает только расширение файла, выбранного в диалоговой панели:
   CString GetFileExt() const;
   Метод GetFileTitle позволяет получить полное имя файла, включая его расширение:
   CString GetFileTitle() const;
   В стандартных диалоговоых панелях Open и Save As имеется переключатель Read Only. Заметим, что по умолчанию этот переключатель не отображается. Если вы желаете воспользоваться этим переключателем, флаг OFN_HIDEREADONLY должен быть сброшен.
   Метод GetReadOnlyPref позволяет определить положение переключателя Read Only. Если переключатель включен, то метод GetReadOnlyPref возвращает ненулевое значение. В противном случае GetReadOnlyPref возвращает нуль:
   BOOL GetReadOnlyPref() const;

   Создайте новый проект, присвоив ему имя FileDlg. В качестве типа приложения выберите из списка Type строку Application. Наберите в редакторе исходный текст приложения и сохраните его в файле FileDlg.cpp (листинг 4.1). Включите набранный файл в проект.
   Выберите из меню Build строку Settings. На экране появится диалоговая панель Project Settings, предназначенная для настройки различных характеристик проекта. Откройте в этой диалоговой панели страницу General и выберите из списка Microsoft Foundation Classes строку Use MFC in a Shared Dll.

Листинг 4.1. Файл FileDlg.cpp

   //============================================================
   // Приложение FileDlg
   // (c) Frolov G.V., 1996
   // E-mail: frolov@glas.apc.org
   //============================================================
   // Включаемый файл для библиотеки MFC
   #include <afxwin.h>
 
   // Включаемый файл для стандартных диалоговых панелей
   #include <afxdlgs.h>
 
   //============================================================
   // Класс CFileDlgApp
   // Наследуем от базового класса CWinApp главный
   // класс приложения CFileDlgApp
   //============================================================
   class CFileDlgApp : public CWinApp {
   public:
    // Мы будем переопределять метод InitInstance,
    // предназначенный для инициализации приложения
    virtual BOOL InitInstance();
   };
 
   // Создаем объект приложение класса CFileDlgApp
   CFileDlgApp FileDlgApp;
 
   //============================================================
   // Метод InitInstance класса CFileDlgApp
   // Переопределяем виртуальный метод InitInstance
   // класса CWinApp. Он вызывается каждый раз при запуске
   // приложения
   //============================================================
   BOOL CFileDlgApp::InitInstance() {
    // Определяем объект класса CFileDialog, представляющий
    // стандартную диалоговую панель Open
    CFileDialog mFileOpen(TRUE);
 
    // Переменная pos будет использоваться для получения
    // полных имен файлов, выбранных в панели Open
    POSITION pos;
 
    // В строку msg будут записываться названия файлов
    CString msg;
 
    // Устанавливаем флаг OFN_ALLOWMULTISELECT, который
    // разрешает одновременно выбирать несколько файлов
    mFileOpen.m_ofn.Flags |= OFN_ALLOWMULTISELECT;
    // Отображаем диалоговую панель Open и позволяем
    // пользователю выбрать с помощью нее один или
    // несколько файлов
    int result = mFileOpen.DoModal();
 
    // Проверяем как была закрыта диалоговая панель Open –
    // по нажатию кнопки OK или Cancel
    if (result == IDCANCEL) {
     // Если пользователь отказался от выбора файлов и
     // нажал кнопку Cancel отображаем соответствующее
     // сообщение
     AfxMessageBox("File not selected");
    } else if(result == IDOK) {
     // Если пользователь нажал кнопку OK, определяем
     // начальную позицию для метода GetNextPathName
     pos = mFileOpen.GetStartPosition();
 
     // В цикле получаем имена файлов, выбранных в
     // диалоговой панели Open. После получения всех
     // имен, завершаем приложение
     while (pos != NULL ) {
      // Получаем имя очередного файла
      msg = mFileOpen.GetNextPathName(pos);
 
      // Отображаем имена файлов
      AfxMessageBox("Selected File – " + msg);
     }
    }
 
    return TRUE;
   }
   Постройте проект и запустите полученное приложение, выбрав из меню Build строку Execute FileDlg.exe. На экране появится стандартная диалоговая панель Open (рис. 4.5).
   Рис. 4.5. Стандартная диалоговая панель Open
 
   С помощью нее вы можете выбрать несколько файлов из любого каталога компьютера. После того, как вы выберите интересующие вас файлы, нажмите кнопку Open. Диалоговая панель Open закроется, и на экране последовательно будут отображаться сообщения, содержащие полные имена выбранных файлов (рис. 4.6).
   Рис. 4.6. Стандартная диалоговая панель Open
 
   Кроме файла afxwin.h, в котором определены классы, методы, константы и другие структуры библиотеки классов MFC, в исходный текст приложения включен файл afxdlgs.h. В этом файле содержатся определения классов, предназначенных для управления стандартными диалоговыми панелями, а также определены еще два класса CPropertySheet и CPropertyPage, предназначенные для построения блокнотов, включающих несколько диалоговых панелей.
   В нашем проекте определен только один класс CFileDlgApp. В класс CFileDlgApp входит метод InitInstance. Кроме того, определен глобальный объект FileDlgApp класса CFileDlgApp. Мы не будем подробно останавливаться на том, как устроено приложение FileDlg. Соответствующую информацию вы можете получить в 24 томе из серии “Библиотека системного программиста”, который служит введением в язык программирования Си++ и библиотеку классов MFC.
   Метод InitInstance главного класса приложения CFileDlgApp вызывается автоматически при запуске приложения. Мы используем метод InitInstance чтобы продемонстрировать вам работу стандартной диалоговой панели Open.
   Сначала создается объект mFileOpen класса CFileDialog. В качестве параметра конструктора CFileDialog указывается значение TRUE, которое указывает, что данный объект класса будет управлять стандартной диалоговой панелью Open:
   CFileDialog mFileOpen(TRUE);
   Определение объекта класса CFileDialog не вызывает автоматического отображаеия на экране соответствующей диалоговой панели. Для этого вызывается метод DoModal. Непосредственно перед обращением к методу DoModal мы устанавливаем флаг OFN_ALLOWMULTISELECT в поле Flags элемента данных m_ofn класса CFileDialog. Если данный флаг установлен, то в диалоговой панели можно будет выбрать сразу несколько файлов. В противном случае, из панели можно будет выбрать только один файл:
   mFileOpen.m_ofn.Flags |= OFN_ALLOWMULTISELECT;
   Метод DoModal класса CFileDialog отображает на экране соответствующую диалоговую панель (в нашем случае диалоговую панель Open) и позволяет пользователю выбрать из нее один или несколько файлов. Результат работы метода DoModal записывается в переменную result:
   int result = mFileOpen.DoModal();
   Если пользователь отказался от выбора файлов и нажал кнопку Cancel, тогда метод DoModal возвращает значение IDCANCEL. В этом случае приложение отображает сообщение File not selected и завершает свою работу:
   AfxMessageBox("File not selected");
   Если пользователь выбрал из диалоговой панели Open один или несколько файлов и нажал кнопку Open, тогда метод DoModal возвращает значение IDOK. В этом случае вызывается метод GetStartPosition, который записывает в переменную pos типа POSITION значение, необходимое методу GetNextPathName для получения всех имен выбранных файлов:
   POSITION pos;
   pos = mFileOpen.GetStartPosition();
   Переменная pos передается методу GetNextPathName. Этот метод получает очередное имя выбранного файла и изменяет значение переменной pos. До тех пор, пока значение pos не станет равно NULL, метод GetNextPathName вызывается в цикле и получает очередное имя файла:
   while (pos != NULL) {
    // Получаем имя очередного файла
    msg = mFileOpen.GetNextPathName(pos);
 
    // Отображаем имена файлов
    AfxMessageBox("Selected File – " + msg);
   }
   Полученные имена файлов отображаются на экране с помощью функции AfxMessageBox. Обратите внимание, что в качестве параметра этой функции передается результат операции конкатенации строки Selected File и объекта класса CString.

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

Метод	Описание
OnShareViolation	Вызывается в случае нарушения прав доступа к файлу
OnFileNameOK	Вызывается для проверки имени файла, введенного в диалоговой панели
OnLBSelChangedNotify	Вызывается при изменении выделения в списке файлов диалоговой панели
OnInitDone	Вызывается для обработки сообщения WM_NOTIFY CDN_INITDONE
OnFileNameChange	Вызывается для обработки сообщения WM_NOTIFY CDN_SELCHANGE
OnFolderChange	Вызывается для обработки сообщения WM_NOTIFY CDN_FOLDERCHANGE
OnTypeChange	Вызывается для обработки сообщения WM_NOTIFY CDN_TYPECHANGE

   Прототипы перечисленных выше виртуальных методов вы можете найти в справочной системе Microsoft Visual C++.

   Стандартная диалоговая панель Font предназначена для выбора шрифта. Диалоговая панель Font отображает список шрифтов, установленных в системе, и позволяет выбрать название шрифта, его начертание, кегль, выделение, цвет, набор национальных символов (рис. 4.7).
   Для управления диалоговой панелью Font в библиотеку классов MFC включен класс CFontDialog. Методы этого класса можно использовать для отображения панели Font и определения характеристик шрифта, выбранного пользователем.
   Рис. 4.7. Стандартная диалоговая панель Font
 
   Конструктор класса CFontDialog:
   CFontDialog(LPLOGFONT lplfInitial = NULL, DWORD dwFlags = CF_EFFECTS | CF_SCREENFONTS, CDC* pdcPrinter = NULL, CWnd* pParentWnd = NULL);
   Все параметры конструктора CFontDialog являются необязательными. Первое время, когда вы изучаете класс CFontDialog, вы можете не задавать ни одного параметра. Настройка стандартной панели выбора шрифта, которая выполняется конструктором класса CFontDialog по умолчанию, удовлетворит большинство потребностей.
   Мы не станем подробно описывать параметры конструктора, вы найдете это описание в документации Microsoft Visual C++. Сейчас мы приведем только краткий обзор этих параметров. Дополнительную информацию по использованию стандартных панелей выбора шрифта вы можете получить в 14 томе “Библиотеки системного программиста”.
   Параметр lplfInitial является указателем на структуру типа LOGFONT, описывающую логический шрифт. Если используете этот параметр, то в диалоговой панели Font по умолчанию будет выбран шрифт наиболее полно соответствующий шрифту, описанному в структуре LOGFONT. По умолчанию данная возможность не используется.
   Параметр dwFlags задает набор флагов, управляющих различными режимами работы панели Font.
   Через параметр pdcPrinter можно передать конструктору контекст отображения принтера, шрифты которого будут представлены в диалоговой панели Font. Данный параметр используется только в том случае, если в параметре dwFlags указан флаг CF_PRINTERFONTS или CF_BOTH.
   Через параметр pParentWnd можно указать родительское окно для далоговой панели Font.

   Для отображения диалоговой панели Font предназначен виртуальный метод DoModal:
   virtual int DoModal();
   Если пользователь выбрал шрифт и нажал на кнопку OK, метод DoModal возвращает идентификатор IDOK, если пользователь отменил выбор шрифта, метод DoModal возвращает идентификатор IDCANCEL.
   Остальные методы класса предназначены для определения характеристик выбранного пользователем шрифта. Полное описание этих методов содержится в документации, поставляемой с Visual C++.
   Метод GetCurrentFont позволяет сразу определить все характеристики выбранного щрифта, записав их в структуру LOGFONT. Вы можете найти описание структуры LOGFONT в документации SDK.
   Остальные методы класса позволяют определить только отдельные характеристики выбранного шрифта. Перечислим названия этих методов.

Метод	Описание
GetFaceName	Возвращает имя выбранного шрифта
GetStyleName	Возвращает имя стиля выбранного шрифта
GetSize	Возвращает кегль выбранного шрифта
GetColor	Возвращает цвет выбранного шрифта
GetWeight	Возвращает плотность выбранного шрифта
IsStrikeOut	Определяет является ли шрифт выделеным перечеркнутой линией
IsUnderline	Определяет является ли шрифт выделеным подчеркиванием
IsBold	Определяет является ли шрифт жирным
IsItalic	Определяет является ли шрифт наклонным

   Самый короткий путь для разработки приложений, работающих с базами данных заключается в использовании MFC AppWizard. С помощью MFC AppWizard вы можете быстро создать приложение, позволяющее просматривать записи базы данных. В дальнейшем вы можете совершенствовать шаблон приложения, подготовленный MFC AppWizard, с помощью средств MFC ClassWizard и добавить другие операции по работе с базой данных, такие как добавление новых записей в таблицу, поиск нужных записей и т. д.
   Создайте новый проект, присвоив ему имя Dater. Используйте для создания проекта средства MFC AppWizard. AppWizard предложит вам заполнить ряд панелей, перечислив в них свойства и характеристики создаваемого приложения.
   Чтобы упростить приложние, на первом шаге определения свойств приложения выберите для него однооконный интерфейс. На втором шаге MFC AppWizard запросит у вас разрешения, чтобы включить поддержку баз данных. Соответствующая диалоговая панель MFC AppWizard представлена нами на рисунке 5.6.
   Рис. 5.6. Диалоговая панель MFC AppWizard – Step 2 of 6
 
   Переключатель с зависимой фиксацией, расположенный в панели MFC AppWizard – Step 2 of 6, определяет на каком уровне в приложении будет обеспечена поддержка баз данных. Следующая таблица кратко описывает этот переключатель.

Положение переключателя	Описание
None	Работа с базами данных не предусматривается
Header files only	К файлаам проекта подключаются файлы заголовков, необходимые для использования средств доступа к базам данных
Database view without file support	Обеспечивается работа с базами данных. Полученное приложение позволяет просматривать базу данных в окне просмотра. Приложения не работает с файлами документов. Меню File такого приложения содержит только строки, не имеющие отношения к работе с файлами, например строку Exit. Строки Open и Save (и некоторых других) в меню File отсутствуют
Database view with file support	Обеспечивается работа с базами данных. Полученное приложение позволяет просматривать базу данных в окне просмотра. Поддерживается работа приложения с файлами документов. Приложение имеет полное меню File

   Мы выбрали для нашего приложения режим работы с базами данных без поддержки файлов. Переключатель надо перевести в положение Database view without file support.
   Теперь надо указать MFC AppWizard какую базу данных и какую таблиицу из нее мы желаем просматривать в нашем приложении. Для этого мы должны нажать кнопку Data Source, также рассположенную в диаалоговой панели MFC AppWizard – Step 2 of 6.
   На экране появится диалоговая панель Database Options (рис. 5.7). В ней находится ряд органов управления, разделенных на три группы – Datasource, Recordset type и Advanced.
   Рис. 5.7. Диалоговая панель Database Options
 
   Группа Datasource предназначена для выбора базы данных (источника данных). Вы можете использовать для доступа к базе данных либо драйверы ODBC, либо средства DAO. В этой книге мы рассмотрим использование только драйверов ODBC. Переведите переключатель Datasource в положение ODBC. Из списка, расположенного справой стороны от переключателя ODBC выберите имя источника данных. В нашем случае вы должны выбрать строку Address Pad.
   В группе Recordset type отображается переключатель с зависимой фиксацией. Он может принимать одно из трех положений Snapshot, Dynaset или Table. Используйте этот переключатель, чтобы определить метод работы приложения с базой данных.

Переключатель Recordset type	Описание
Snapshot	Используется для представления статических данных, которые не изменяются во время работы приложения
Dynaset	Подразумевается, что база данных, представленная источником данных, может изменяться во время работы приложения. Такое изменение может выполнять другое приложение, если база данных используется в многопользовательском режиме

   Для нашего приложения Dater мы используем самый простой метод доступа к записям базы данных, поэтому переведите переключатель Recordset type в положение Snapshot.
   В последную группу Advanced входит только один переключатель Detect dirty columns. Этот переключатель используется средствами DAO и в этой книге не рассматривается.
   Когда панель Database Options заполнена, нажмите кнопку OK. На экране появится диалоговая панель Select Database Tables (рис. 5.8). Из нее вы должны выбрать имя таблицы базы данных, с которой будет работать приложение. Информация именно из этой таблицы будет отображаться нашим приложением. В нашем случае база данных (или источник данных) содержить только одну таблицу, поэтому выбор таблицы не составит труда. Просто щелкните мышью по строку TEXTBASE.TXT и нажмите кнопку OK.
   Рис. 5.8. Диалоговая панель Select Database Tables
 
   Если ваша база данных содержит несколько таблиц и приложение должно работать с ними со всеми, то уже после создания приложения средствами MFC AppWizard, вы можете воспользоваться ClassWizard, чтобы подключить остальные таблицы базы данных. Приложения, работающие одновременно с несколькими таблицами базы данных мы рассмотрим в одной из следующих книг серии “Библиотека системного программиста”.
   После выбора источника данных, вы можете завершить создание приложения и нажать кнопку Finish. Вы также можете продолжить заполнять диалоговые панели MFC AppWizard. В этом случае заполните панели MFC AppWizard, оставляя все предложения по умолчанию. Единственное, что вы можете изменить для упрощения приложения, это отменить все особенности приложения, связанные с печатью. Для этого отключите переключатель Print and print preview в диалоговой панели MFC AppWizard – Step 4 of 6.
   Когда вы дойдете до последней панели MFC AppWizard – Step 6 of 6 (рис. 5.9) вы можете просмотреть, какие классы составляют приложение Dater.
   Рис. 5.9. Диалоговая панель MFC AppWizard – Step 6 of 6
   Оказывается, в отличае от проектов, которые мы изучали ранее, класс окна просмотра приложения Dater наследуется от базового класса CRecordView, и в проект входит класс представляющий записи базы данных, который не имеет аналогов среди других изученных нами приложений. Этот класс наследуется от базового класса CRecordset.

   Взгляните на ресурсы приложения Dater. Для этого откройте страницу ResourceView в окне Project Workspace.
   Обратите внимание на шаблон диалоговой панели IDD_DATER_FORM (рис. 5.10). Этот шаблон используется окном просмотра, созданным на основе класса CRecordView. Окно просмотра содержит в себе органы управления, определенные в шаблоне диалоговой панели.
   Рис. 5.10. Шаблон диалоговой панели IDD_DATER_FORM
 
   Сразу после того, как MFC AppWizard создаст проект, в этом шаблоне будет размещен одна только текстовая строка TODO: Place form controls on this dialog, предлагающая вам разместить на ней органы управления.
   Удалите с шаблона эту строку, а затем создайте на ней четыре текстовых редактора, по одному для каждого поля таблицы базы данных Address Pad. Присвойте им идентификаторы IDC_NAME, IDC_ADDRESS, IDC_PHONE и IDC_PRIORITY. Около текстовых редакторов поместите краткие строки описания — Name, e-Mail, Phone и Priority. Сохраните изменения в файле ресурсов. Доработанный шаблон диалоговой панели представлен на рисунке 5.11.
   Теперь вы можете выполнить наиболее интересную операцию в создании приложения Dater — привязать при помощи MFC ClassWizard к полям шаблона диалоговой панели IDD_DATER_FORM переменные, представляющие различные поля таблицы базы данных.
   Рис. 5.11. Доработанный шаблон диалоговой панели IDD_DATER_FORM
 
   Запустите MFC ClassWizard. В окне MFC ClassWizard выберите из списка ClassName имя класса окна просмотра - CDaterView и откройте страницу Member Variables. На этой странице вы увидите список идентификаторов полей редактирования шаблона диалоговой панели IDD_DATER_FORM.
   Выбериете один из идентификаторов и нажмите на кнопку Add Variable. На экране появится диалоговая панель Add Member Variable (рис. 5.12). В этой панели вы должны определить переменную, которая будет отображаться в поле с данным идентификатором. В списке Category отображается категория органа управления к которому вы добавляете переменную. Для полей редактирования из этого списка будет выбрана строка Value. В списске Variable type отображается тип переменной, выбранной в поле Member variable name. Нажмите кнопку OK.
   Рис. 5.12. Диалоговая панель Add Member Variable
 
   В нашем случае список Member variable name содержит строки, представляющие различные поля записи таблицы базы данных Address Pad. Выбирая остальные идентификаторы шаблона диалоговой панели IDD_DATER_FORM поставьте им в соответствие поля базы данных, как это показано на рисунке 5.13.
   Рис. 5.13. Диалоговая панель MFC ClassWizard
 
   Если у вас возникли проблемы во время добавления переменных к полям диалоговых панелей (список идентификаторов в панели MFC ClassWizard пуст), возможно вам надо будет изменить язык для диалоговой панели IDD_DATER_FORM.
   Так например, если ваш компьютер настроен на работу с русским языком, диалоговая панель IDD_DATER_FORM также должна быть русской. Чтобы поменять язык, вызовите панель свойств для диалоговой панели IDD_DATER_FORM и выберите из списка Language строку Russian (рис. 5.14). Дополнительные сведения о выборе языка смотрите в разделе “Национальные ресурсы”.
   Рис. 5.14. Свойства диалоговой панели IDD_DATER_FORM
 
   Откройте для редактирования метод GetDefaultSQL класса CDaterSet:
   CString CDaterSet::GetDefaultSQL() {
    return _T("[TextBase].[txt]");
   }
   MFC AppWizard не совсем правильно работает с текстовым драйвером и этот метод содержит ошибку. Вы должны убрать из него две лишние квадратные скобки. Исправленный метод будет выглядеть следующим образом:
   CString CDaterSet::GetDefaultSQL() {
    return _T("[TextBase.txt]");
   }
   Все! Теперь можно построить проект и запустить полученное приложение. На экране откроется главное окно приложения Dater (рис. 5.15). В окне просмотра отображаются поля базы данных Address Pad. Вы можете просмотреть все записи базы, используя меню Record и панель управления приложения.
   Рис. 5.15. Приложение Dater

   Список всех классов, входящих в проект Dater, а также их методов можно просмотреть в окне Project Workspace на странице ClassView (рис. 5.16).
   Рис. 5.16. Окно Project Workspace, страница ClassView
 
   В приложение Dater входят следующие классы.

Класс	Базовый класс	Назначение
CAboutDlg	CDialog	Управляет информационной диалоговой панелью About
CDaterApp	CWinApp	Главный класс приложения
CDaterDoc	CDocument	Представлляет документ приложения
CDaterSet	CRecordset	Представлляет запись таблицы базы данных
CDaterView	CRecordView	Управляет окном просмотра приложения. В этом окне отображаются записи таблицы базы данных
CMainFrame	CFrameWnd	Главное окно приложения

Главный класс приложения – CDaterApp

   Класс CDaterApp приложения Dater не содержит в себе ничего особенного и практически не отличается от соответствующего класса однооконного приложения Single, созданного MFC AppWizard и не работающего с базами данных:
   //////////////////////////////////////////////////////////////
   // Класс CDaterApp
   //
   class CDaterApp : public CWinApp {
   public:
   CDaterApp();
 
   // Overrides
    //{{AFX_VIRTUAL(CDaterApp)
   public:
    virtual BOOL InitInstance();
    //}}AFX_VIRTUAL
 
   // Implementation
    //{{AFX_MSG(CDaterApp)
    afx_msg void OnAppAbout();
    //}}AFX_MSG
    DECLARE_MESSAGE_MAP()
   };
   Класс CDaterApp содержит конструктор, а также методы InitInstance и OnAppAbout.

Конструктор класса CDaterApp

   Конструктор класса CSingleApp не выполняет никаких действий и состоит из пустого блока:
   CDaterApp::CDaterApp() {
    // TODO:
   }

Метод OnAppAbout класса CDaterApp

   Метод OnAppAbout класса CDaterApp вызывается для обработки командного сообщения с идентификатором ID_APP_ABOUT, которое посылается при выборе из меню Help строки About. Этот метод совместно с классом CAboutDlg предназначен для отображения информационной диалоговой панели About (в файле ресурсов она имеет идентификатор IDD_ABOUTBOX). Мы не будем рассматривать этот метод и класс CAboutDlg, так как они не используются для взаимодействия с базой данных.

Метод InitInstance класса CDaterApp

   Наибольший интерес представляет метод InitInstance класса CDaterApp, который создает шаблон документа приложения и добавляет его к списку шаблонов приложения. Кроме того, метод InitInstance разбирает командную строку приложения, загружает поддержку трехмерных органов упрпавления и выполняет еще некоторые действия:
   BOOL CDaterApp::InitInstance() {
   #ifdef _AFXDLL
    Enable3dControls();
   #else
    Enable3dControlsStatic();
   #endif
 
    LoadStdProfileSettings();
 
    CSingleDocTemplate* pDocTemplate;
    pDocTemplate = new CSingleDocTemplate(IDR_MAINFRAME, RUNTIME_CLASS(CDaterDoc), RUNTIME_CLASS(CMainFrame), RUNTIME_CLASS(CDaterView));
    AddDocTemplate(pDocTemplate);
 
    CCommandLineInfo cmdInfo;
    ParseCommandLine(cmdInfo);
 
    if (!ProcessShellCommand(cmdInfo)) return FALSE;
 
    return TRUE;
   }
   При создании шаблона документа указывается идентификатор типа документа IDR_MAINFRAME, класс документа приложения CDaterDoc, класс главного окна приложения CMainFrame и класс окна просмотра CDaterView.
   В приложении определен целый ряд ресурсов с этим идентификатором – меню, панель управления, таблица акселераторов, пиктограмма и строковый ресурс. Наиболее интересны для нас сейчас меню и панель управления, так как они содержат строки и кнопки, управляющие просмотром записей базы данных.
   Подробное описание метода InitInstance главного класса однооконного приложения можно получить в 24 томе серии “Библиотека системного программиста”.

Класс главного окна приложения – CMainFrame

   Класс CMainFrame предназначен для управления главным окном приложения. Для этого класса определены конструктор, деструктор, методы PreCreateWindow, OnCreate, AssertValid и Dump. В него также входят два элемента данных m_wndToolBar и m_wndStatusBar, представляющие панель управления и панель состояния:
   class CMainFrame : public CFrameWnd {
   protected:
    CMainFrame();
    DECLARE_DYNCREATE(CMainFrame)
 
   // Attributes
   public:
 
   // Operations
   public:
 
   // Overrides
    //{{AFX_VIRTUAL(CMainFrame)
    virtual BOOL PreCreateWindow(CREATESTRUCT& cs);
    //}}AFX_VIRTUAL
 
   // Implementation
   public:
    virtual ~CMainFrame();
   #ifdef _DEBUG
    virtual void AssertValid() const;
    virtual void Dump(CDumpContext& dc) const;
   #endif
 
   protected: 
    CStatusBar m_wndStatusBar;
    CToolBar   m_wndToolBar;
 
   protected:
    //{{AFX_MSG(CMainFrame)
    afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
    //}}AFX_MSG
    DECLARE_MESSAGE_MAP()
   };
   Мы не стали приводить исходные тексты методов класса CMainFrame, так как они практически не отличаются от методов класса CMainFrame любого другого однооконного приложения созданного MFC AppWizard.

Конструктор и деструктор класса CMainFrame

   Конструктор и деструктор класса CMainFrame не содержат программного кода.

Метод PreCreateWindow класса CMainFrame

   Метод PreCreateWindow вызывает метод PreCreateWindow базового класса CFrameWnd и выполняет обработку по умолчанию.

Метод OnCreate класса CMainFrame

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

Методы AssertValid и Dump класса CMainFrame

   Методы AssertValid и Dump класса CMainFrame могут использоваться при отладке приложения.

Класс документа приложения – CDaterDoc

   Класс документа приложения CDaterDoc представляет документ, с которым работает приложение. В него входит элемент m_daterSet класса CDaterSet, также определенного в нашем приложении, который представляет запись базы данных.
   Кроме этого элемента в классе CDaterDoc определены конструктор, деструктор, метод OnNewDocument, а также методы AssertValid и Dump:
   class CDaterDoc : public CDocument {
   protected:
    CDaterDoc();
    DECLARE_DYNCREATE(CDaterDoc)
 
   // Attributes
   public:
    CDaterSet m_daterSet;
 
   // Operations
   public:
 
   // Overrides
    //{{AFX_VIRTUAL(CDaterDoc)
   public:
    virtual BOOL OnNewDocument();
    //}}AFX_VIRTUAL
 
   // Implementation
   public:
    virtual ~CDaterDoc();
   #ifdef _DEBUG
    virtual void AssertValid() const;
    virtual void Dump(CDumpContext& dc) const;
   #endif
 
   protected:
    //{{AFX_MSG(CDaterDoc)
    //}}AFX_MSG
    DECLARE_MESSAGE_MAP()
   };

Конструктор и деструктор класса CDaterDoc

   Конструктор и деструктор класса CMainFrame не содержжат программного кода.

Метод PreCreateWindow класса CDaterDoc

   Метод OnNewDocument вызывается, когда надо создать новый документ для приложения. Метод OnNewDocument приложения Dater вызывает метод OnNewDocument базового класса CDocument:
   BOOL CDaterDoc::OnNewDocument() {
    if (!CDocument::OnNewDocument()) return FALSE;
    // TODO:
    return TRUE;
   }

Методы AssertValid и Dump класса CDaterDoc

   Методы AssertValid и Dump класса CMainFrame могут использоваться при отладке приложения.

Класс окна просмотра приложения – CDaterView

   Большой интерес представляет класс окна просмотра приложения CDaterView. В нем содержится указатель m_pSet на объект класса CDaterSet, который представляет запись базы данных. Обратите внимание, что определение указателя находится внутри комментариев вида //{{AFX_DATA. Эти комментарии используются MFC ClassWizard:
   class CDaterView : public CRecordView {
   protected:
    CDaterView();
    DECLARE_DYNCREATE(CDaterView)
 
   public:
    //{{AFX_DATA(CDaterView)
    enum { IDD = IDD_DATER_FORM };
    CDaterSet* m_pSet;
    //}}AFX_DATA
 
   // Attributes
   public:
    CDaterDoc* GetDocument();
 
   // Operations
   public:
 
   // Overrides
    //{{AFX_VIRTUAL(CDaterView)
   public:
    virtual CRecordset* OnGetRecordset();
    virtual BOOL PreCreateWindow(CREATESTRUCT& cs);
   protected:
    virtual void DoDataExchange(CDataExchange* pDX);
    virtual void OnInitialUpdate();
    //}}AFX_VIRTUAL
 
   // Implementation
   public:
    virtual ~CDaterView();
   #ifdef _DEBUG
    virtual void AssertValid() const;
    virtual void Dump(CDumpContext& dc) const;
   #endif
 
   protected:
    //{{AFX_MSG(CDaterView)
    //}}AFX_MSG
    DECLARE_MESSAGE_MAP()
   };
   Помимо конструктора и деструктора в классе CDaterView определен целый ряд методов – PreCreateWindow, GetDocument, OnGetRecordset, DoDataExchange, OnInitialUpdate, а также AssertValid и Dump. Опишем наиболее важные из этих методов более подробно.

Конструктор и деструктор класса CDaterView

   Конструктор класса CMainFrame вызывает конструктор базового класса CRecordView и передает ему в качестве параметра символ IDD, определенный как идентификатор шаблона диалоговой панели IDD_DATER_FORM, используемого окном просмотра.
   Конструктор CMainFrame также приваивает указателю m_pSet значение NULL:
   CDaterView::CDaterView() : CRecordView(CDaterView::IDD) {
    //{{AFX_DATA_INIT(CDaterView)
    m_pSet = NULL;
    //}}AFX_DATA_INIT
    // TODO:
   }
   Деструктор класса CMainFrame не содержит программного кода:
   CDaterView::~CDaterView() {}

Метод PreCreateWindow класса CDaterView

   Метод PreCreateWindow вызывает метод PreCreateWindow базового класса CRecordView и выполняет обработку по умолчанию:
   BOOL CDaterView::PreCreateWindow(CREATESTRUCT& cs) {
    // TODO:
    return CRecordView::PreCreateWindow(cs);
   }

Метод GetDocument класса CDaterView

   Метод GetDocument возвращает указатель на документ, связанный с данным окном просмотра. Если окно просмотра не связано ни с каким документом, метод возвращает значение NULL.
   Метод GetDocument имеет две реализации. Одна используется для отладочной версии приложения, а другая для окончательной.
   Окончательная версия GetDocument определена непосредственно после самого класса окна просмотра CDaterView как встраиваемый (inline) метод. Когда вы используете страницу ClassView окна Project Workspace, чтобы просмотреть определение метода GetDocument, вы увидите именно этот код:
   // Окончательная версия приложения
   #ifndef _DEBUG 
   inline CDaterDoc* CDaterView::GetDocument() {
    return (CDaterDoc*)m_pDocument;
   }
   #endif
   Отладочная версия GetDocument расположена в файле реализации класса окна просмотра DaterView.cpp. Откройте этот файл вручную, выбрав его название из страницы FileView окна Project Workspace:
   // Отладочная версия приложения
   #ifdef _DEBUG
   CDaterDoc* CDaterView::GetDocument() {
    ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CDaterDoc)));
    return (CDaterDoc*)m_pDocument;
   }
   #endif //_DEBUG
   Макрокоманда RUNTIME_CLASS возвращает указатель на структуру CRuntimeClass, содержащую информацию о классе CDaterDoc. Метод IsKindOf, определенный в классе CObject, проверяет, принадлежит ли объект, на который указывает m_pDocument, к классу CDaterDoc или классу наследованному от CDaterDoc. Если в приложении есть ошибка и m_pDocument не указывает на документ приложения, макрокоманда ASSERT отображает соответствующее сообщение и прерывает работу приложения.

Метод OnGetRecordset класса CDaterView

   Метод OnGetRecordset класса CDaterView возвращает указатель m_pSet на запись базы данных:
   //////////////////////////////////////////////////////////////
   // Метод OnGetRecordset класса CDaterView
   CRecordset* CDaterView::OnGetRecordset() {
    return m_pSet;
   }

Метод OnInitialUpdate класса CDaterView

   Метод OnInitialUpdate класса окна просмотра CDaterView первоначально определен в базовом классе CView. Этот метод вызывается MFC перед отображением окна просмотра на экране:
   //////////////////////////////////////////////////////////////
   // Метод OnInitialUpdate класса CDaterView
   void CDaterView::OnInitialUpdate() {
    m_pSet = &GetDocument()->m_daterSet;
    CRecordView::OnInitialUpdate();
   }
   В момент вызова метода OnInitialUpdate окно просмотра уже связано с объектом документа приложения, поэтому можно использовать метод GetDocument.
   В нашем случае метод GetDocument используется, чтобы записать в переменную m_pSet (входящую в класс CDaterView) укзатель на объект m_daterSet класса CDaterSet, представляющий записи базы данных и входящий в класс документа приложения — класс CDaterDoc.
   Затем вызывается метод OnInitialUpdate базового класса CRecordView.

Метод DoDataExchange класса CDaterView

   Виртуальный метод DoDataExchange класса CDaterView, первоначально определен в классе CWnd. Он служит для реализации механизмов автоматического обмена данными – Dialog Data Exchange (DDX) и автоматической проверки данных – Dialog Data Validation (DDV). Мы рассматривали этот механизм в 24 томе серии “Библиотека системного программиста”:
   //////////////////////////////////////////////////////////////
   // Метод DoDataExchange класса CDaterView
   void CDaterView::DoDataExchange(CDataExchange* pDX) {
   CRecordView::DoDataExchange(pDX);
    //{{AFX_DATA_MAP(CDaterView)
    DDX_FieldText(pDX,IDC_ADDRESS, m_pSet->m_ADDRESS, m_pSet);
    DDX_FieldText(pDX,IDC_NAME, m_pSet->m_NAME, m_pSet);
    DDX_FieldText(pDX,IDC_PHONE, m_pSet->m_PHONE, m_pSet);
    DDX_FieldText(pDX,IDC_PRIORITY, m_pSet->m_PRIORITY,m_pSet);
    //}}AFX_DATA_MAP
   }
   Механизм автоматического обмена данными привязывает к органам управления диалоговой панели переменные или элементы данных класса диалоговой панели. Так как окно просмотра построено на основе диалоговой панели, механизм автоматического обмена данными позволяет нам выполнять обмен данными между органами управления, размещенными в окне просмотра, и элементами класса окна просмотра. Обмен данными работает в обоих направлениях.
   Обмен выполняется при помощи функций DDX_FieldText. Могут также использоваться и другие функции, например, DDX_FieldRadio, DDX_FieldCheck, DDX_FieldScroll. Практически каждый тип органов управления диалоговой панели имеет собственную функцию для выполнения процедуры обмена данными.
   Всем функциям DDX_FieldText, вызываевым в методе DoDataExchange класса CDaterView передаются четыре параметра.
   Первый параметр содержит указатель на объект класса CDataExchange. Этот объект определяет параметры обмена, в том числе направление, в котором надо выполнить обмен данными.
   Второй параметр определяет идентификатор органа управления окна просмотра, с которым выполняется обмен данными (окно просмотра доолжно быть представлено классом CRecordView). В нашем случае это идентификаторы полей IDC_ADDRESS, IDC_NAME, IDC_PHONE и IDC_PRIORITY, котоорые принадлежат шаблону диалоговой панели используемому окном просмотра.
   Третий параметр содержит ссылку на элемент данных класса CDaterSet, представляющий соответствующее поле базы данных. В нашем методе в качестве этого парамтера фигурируют m_pSet->m_ADDRESS, m_pSet->m_NAME, m_pSet->m_PHONE и m_pSet->m_PRIORITY.
   Четвертый параметр содержит указатель на объект класса CDaterSet, с которым выполняется обмен данными. В нашем случае для всех методов в качестве этого параметра используется указатель m_pSet.

Методы AssertValid и Dump класса CDaterView

   Методы AssertValid и Dump класса CDaterView могут использоваться при отладке приложения.

Класс записи базы данных – CDaterDoc

   Центральным классом приложений, которые взаимодействуют с базами данных через драйвера ODBC, является класс, наследованный от базового класса CRecordset. В нашем приложении в качестве этого класса выступает класс CDaterSet:
   class CDaterSet : public CRecordset {
   public:
    CDaterSet(CDatabase* pDatabase = NULL);
    DECLARE_DYNAMIC(CDaterSet)
 
   // Field/Param Data
    //{{AFX_FIELD(CDaterSet, CRecordset)
    CString m_NAME;
    CString m_ADDRESS;
    long m_PRIORITY;
    CString m_PHONE;
    //}}AFX_FIELD
 
   // Overrides
    //{{AFX_VIRTUAL(CDaterSet)
   public:
    virtual CString GetDefaultConnect();
    virtual CString GetDefaultSQL();
    virtual void DoFieldExchange(CFieldExchange* pFX);
    //}}AFX_VIRTUAL
 
   // Implementation
   #ifdef _DEBUG
    virtual void AssertValid() const;
    virtual void Dump(CDumpContext& dc) const;
   #endif
 
   };
   Класс CDaterSet содержит в себе переменные, представляющие поля записи базы данных. Эти переменные размещаются внутри комментариев вида //{{AFX_FIELD.
   В нашем случае эти переменные называются m_NAME, m_ADDRESS, m_PRIORITY и m_PHONE. Они представляют поля NAME, ADDRESS, PRIORITY и PHONE соответственно.
   В классе CDaterSet также определены конструктор класса и несколько методов – GetDefaultConnect, GetDefaultSQL, DoFieldExchange, а также AssertValid и Dump.

Конструктор класса CDaterSet

   Конструктор класса CDaterSet вызывает конструктор базового класса CRecordset. В качестве параметра конструктору CDaterSet и конструктору базового класса передается указатель pdb на объект класса CDatabase, представляющий источник данных.
   В приложении Dater конструктору CDaterSet параметр pdb не передается (см. класс CDaterDoc). Посмотрите описание конструктора класса CRecordset в документации Microsoft Visual C++. Если он вызывается без параметра или с параметром NULL, то конструктор автоматически создает объект класса CDatabase. С Этим объектом связывается источник данных, определенный в методе GetDefaultConnect:
   CDaterSet::CDaterSet(CDatabase* pdb) : CRecordset(pdb) {
    DECLARE_DYNAMIC(CDaterSet)
 
   // Field/Param Data
    //{{AFX_FIELD(CDaterSet, CRecordset)
    CString m_NAME;
    CString m_ADDRESS;
    long m_PRIORITY;
    CString m_PHONE;
    //}}AFX_FIELD
 
   // Overrides
    //{{AFX_VIRTUAL(CDaterSet)
    public:
    virtual CString GetDefaultConnect();
    virtual CString GetDefaultSQL();
    virtual void DoFieldExchange(CFieldExchange* pFX);
    //}}AFX_VIRTUAL
 
   // Implementation
   #ifdef _DEBUG
    virtual void AssertValid() const;
    virtual void Dump(CDumpContext& dc) const;
   #endif
 
   };
   Класс CDaterSet содержит в себе переменные, представляющие поля записи базы данных. Эти переменные размещаются внутри комментариев вида //{{AFX_FIELD.
   В нашем случае эти переменные называются m_NAME, m_ADDRESS, m_PRIORITY и m_PHONE. Они представляют поля NAME, ADDRESS, PRIORITY и PHONE соответственно.

Метод GetDefaultConnect класса CDaterSet

   Метод GetDefaultConnect возвращает текстовую строку, которая определяет источник данных, который будет связан с объектом CDaterSet. Эта строка формируется MFC AppWizard, при выборе вами источника данных:
   CString CDaterSet::GetDefaultConnect() {
    return _T("ODBC;DSN=Address Pad");
   }

Метод GetDefaultSQL класса CDaterSet

   Метод GetDefaultSQL возвращает текстовую строку, которая должна содержать имя таблицы источника данных или выражение SELECT языка SQL. На основе этой таблицы или результата запроса SELECT будет сформирован набор записей для объекта CDaterSet:
   CString CDaterSet::GetDefaultSQL() {
    return _T("[TextBase.txt]");
   }

Метод DoFieldExchange класса CDaterSet

   Метод DoFieldExchange выполняет обмен данными между элементами класса CDaterSet, представляющими поля набора записей, и источником данных:
   void CDaterSet::DoFieldExchange(CFieldExchange* pFX) {
    //{{AFX_FIELD_MAP(CDaterSet)
    pFX->SetFieldType(CFieldExchange::outputColumn);
    RFX_Text(pFX, _T("[NAME]"), m_NAME);
    RFX_Text(pFX, _T("[ADDRESS]"), m_ADDRESS);
    RFX_Long(pFX, _T("[PRIORITY]"), m_PRIORITY);
    RFX_Text(pFX, _T("[PHONE]"), m_PHONE);
    //}}AFX_FIELD_MAP
   }
   Метод DoFieldExchange содержит блок из комментариев //{{AFX_FIELD_MAP, в котором расположены несколько методов RFX_Text, которые выполняют обмен данными между полями источника данных (в нашем случае это поля NAME,  ADDRESS, PRIORITY, PHONE) и соответствующими элементами класса CDaterSet (m_NAME, m_ADDRESS, m_PRIORITY, m_PHONE).
   Вы не должны вручную исправлять программный код в блоке AFX_FIELD_MAP. Для этого надо использовать MFC ClassWizard (рис. 5.17).
   Рис. 5.17. Диалоговая панель MFC ClassWizard

Методы AssertValid и Dump класса CDaterSet

   Методы AssertValid и Dump класса CDaterSet могут использоваться при отладке приложения.

   В файле ресурсов приложения Dater определены меню, панель управления и таблица клавиш акселераторов IDR_MAINFRAME, шаблон диалоговой панели IDD_DATER_FORM, который используется окном просмотра и шаблон информационной панели IDD_ABOUTBOX. В файле ресурсов также расположены строковые ресурсы, описывающие строки меню, кнопки панелей управления и индикаторы панели состояния. Мы привели исходный текст файла Dater.rc в листинге 5.3.

Листинг 5.3. Файл Dater.rc

   //Microsoft Developer Studio generated resource script.
   //
   #include "resource.h"
 
   #define APSTUDIO_READONLY_SYMBOLS
   //////////////////////////////////////////////////////////////
   //
   // Generated from the TEXTINCLUDE 2 resource.
   //
   #include "afxres.h"
 
   //////////////////////////////////////////////////////////////
   #undef APSTUDIO_READONLY_SYMBOLS
 
   //////////////////////////////////////////////////////////////
   // English (U.S.) resources
 
   //#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
   //#ifdef _WIN32
   //LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
   //#pragma code_page(1252)
   //#endif //_WIN32
 
   #ifdef APSTUDIO_INVOKED
   //////////////////////////////////////////////////////////////
   //
   // TEXTINCLUDE
   //
 
   1 TEXTINCLUDE DISCARDABLE
   BEGIN
    "resource.h\0"
   END
 
   2 TEXTINCLUDE DISCARDABLE
   BEGIN
    "#include ""afxres.h""\r\n"
    "\0"
   END
 
   3 TEXTINCLUDE DISCARDABLE
   BEGIN
    "#define _AFX_NO_SPLITTER_RESOURCES\r\n"
    "#define _AFX_NO_OLE_RESOURCES\r\n"
    "#define _AFX_NO_TRACKER_RESOURCES\r\n"
    "#define _AFX_NO_PROPERTY_RESOURCES\r\n"
    "\r\n"
    "#if !defined(AFX_RESOURCE_DLL)||defined(AFX_TARG_ENU)\r\n"
    "#ifdef _WIN32\r\n"
    "LANGUAGE 9, 1\r\n"
    "#pragma code_page(1252)\r\n"
    "#endif\r\n"
    "#include ""res\\Dater.rc2""  // non-Microsoft Visual C++
                                  // edited resources\r\n"
    "#include ""afxres.rc""       // Standard components\r\n"
    "#include ""afxdb.rc""        // Database resources\r\n"
    "#endif\0"
   END
 
   #endif // APSTUDIO_INVOKED
 
   //////////////////////////////////////////////////////////////
   //
   // Icon
   //
 
   IDR_MAINFRAME ICON DISCARDABLE "res\\Dater.ico"
   IDR_DATERTYPE ICON DISCARDABLE "res\\DaterDoc.ico"
 
   //////////////////////////////////////////////////////////////
   //
   // Bitmap
   //
 
   IDR_MAINFRAME   BITMAP  MOVEABLE PURE   "res\\Toolbar.bmp"
 
   //////////////////////////////////////////////////////////////
   //
   // Toolbar
   //
 
   IDR_MAINFRAME TOOLBAR DISCARDABLE 16, 15
   BEGIN
    BUTTON ID_EDIT_CUT
    BUTTON ID_EDIT_COPY
    BUTTON ID_EDIT_PASTE
    SEPARATOR
    BUTTON ID_FILE_PRINT
    SEPARATOR
    BUTTON ID_RECORD_FIRST
    BUTTON ID_RECORD_PREV
    BUTTON ID_RECORD_NEXT
    BUTTON ID_RECORD_LAST
    SEPARATOR
    BUTTON ID_APP_ABOUT
   END
 
   //////////////////////////////////////////////////////////////
   //
   // Menu
   //
 
   IDR_MAINFRAME MENU PRELOAD DISCARDABLE
   BEGIN
    POPUP "&File"
    BEGIN
     MENUITEM "E&xit", ID_APP_EXIT
    END
    POPUP "&Edit"
    BEGIN
     MENUITEM "&Undo\tCtrl+Z", ID_EDIT_UNDO
     MENUITEM SEPARATOR
     MENUITEM "Cu&t\tCtrl+X", ID_EDIT_CUT
     MENUITEM "&Copy\tCtrl+C", ID_EDIT_COPY
     MENUITEM "&Paste\tCtrl+V", ID_EDIT_PASTE
    END
    POPUP "&Record"
    BEGIN
     MENUITEM "&First Record",    ID_RECORD_FIRST
     MENUITEM "&Previous Record", ID_RECORD_PREV
     MENUITEM "&Next Record",     ID_RECORD_NEXT
     MENUITEM "&Last Record",     ID_RECORD_LAST
    END
    POPUP "&View"
    BEGIN
     MENUITEM "&Toolbar",    ID_VIEW_TOOLBAR
     MENUITEM "&Status Bar", ID_VIEW_STATUS_BAR
    END
    POPUP "&Help"
    BEGIN
     MENUITEM "&About Dater...", ID_APP_ABOUT
    END
   END
 
   //////////////////////////////////////////////////////////////
   //
   // Accelerator
   //
 
   IDR_MAINFRAME ACCELERATORS PRELOAD MOVEABLE PURE
   BEGIN
    "Z",       ID_EDIT_UNDO,  VIRTKEY, CONTROL
    "X",       ID_EDIT_CUT,   VIRTKEY, CONTROL
    "C",       ID_EDIT_COPY,  VIRTKEY, CONTROL
    "V",       ID_EDIT_PASTE, VIRTKEY, CONTROL
    VK_BACK,   ID_EDIT_UNDO,  VIRTKEY, ALT
    VK_DELETE, ID_EDIT_CUT,   VIRTKEY, SHIFT
    VK_INSERT, ID_EDIT_COPY,  VIRTKEY, CONTROL
    VK_INSERT, ID_EDIT_PASTE, VIRTKEY, SHIFT
    VK_F6,     ID_NEXT_PANE,  VIRTKEY
    VK_F6,     ID_PREV_PANE,  VIRTKEY, SHIFT
   END
 
   //////////////////////////////////////////////////////////////
   //
   // Dialog
   //
 
   IDD_ABOUTBOX DIALOG DISCARDABLE  0, 0, 217, 55
   STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
   CAPTION "About Dater"
   FONT 8, "MS Sans Serif"
   BEGIN
    ICON          IDR_MAINFRAME,IDC_STATIC,11,17,20,20
    LTEXT         "Dater Version 1.0", IDC_STATIC, 40, 10, 119, 8, SS_NOPREFIX
    LTEXT         "Copyright © 1996", IDC_STATIC, 40, 25, 119, 8
    DEFPUSHBUTTON "OK",IDOK,178,7,32,14,WS_GROUP
   END
 
   IDD_DATER_FORM DIALOG DISCARDABLE  0, 0, 201, 101
   STYLE WS_CHILD
   FONT 8, "MS Sans Serif"
   BEGIN
    LTEXT    "E-Mail",IDC_STATIC,5,35,20,8
    LTEXT    "Priority",IDC_STATIC,5,86,22,8
    EDITTEXT IDC_NAME,35,5,160,15,ES_AUTOHSCROLL
    LTEXT    "Name",IDC_STATIC,5,10,20,8
    EDITTEXT IDC_ADDRESS,35,30,160,15,ES_AUTOHSCROLL
    EDITTEXT IDC_PRIORITY,35,80,80,15,ES_AUTOHSCROLL
    LTEXT    "Phone",IDC_STATIC,5,60,22,8
    EDITTEXT IDC_PHONE,35,55,80,15,ES_AUTOHSCROLL
   END
 
   #ifndef _MAC
   //////////////////////////////////////////////////////////////
   //
   // Version
   //
 
   VS_VERSION_INFO VERSIONINFO
    FILEVERSION 1,0,0,1
    PRODUCTVERSION 1,0,0,1
    FILEFLAGSMASK 0x3fL
   #ifdef _DEBUG
    FILEFLAGS 0x1L
   #else
    FILEFLAGS 0x0L
   #endif
    FILEOS 0x4L
    FILETYPE 0x1L
    FILESUBTYPE 0x0L
   BEGIN
    BLOCK "StringFileInfo"
    BEGIN
     BLOCK "040904B0"
     BEGIN
      VALUE "CompanyName", "\0"
      VALUE "FileDescription", "DATER MFC Application\0"
      VALUE "FileVersion", "1, 0, 0, 1\0"
      VALUE "InternalName", "DATER\0"
      VALUE "LegalCopyright", "Copyright © 1996\0"
      VALUE "LegalTrademarks", "\0"
      VALUE "OriginalFilename", "DATER.EXE\0"
      VALUE "ProductName", "DATER Application\0"
      VALUE "ProductVersion", "1, 0, 0, 1\0"
     END
    END
    BLOCK "VarFileInfo"
    BEGIN
     VALUE "Translation", 0x409, 1200
    END
   END
 
   #endif // !_MAC
 
   //////////////////////////////////////////////////////////////
   //
   // DESIGNINFO
   //
 
   #ifdef APSTUDIO_INVOKED
   GUIDELINES DESIGNINFO DISCARDABLE
   BEGIN
    IDD_ABOUTBOX, DIALOG
    BEGIN
     LEFTMARGIN, 7
     RIGHTMARGIN, 210
     TOPMARGIN, 7
     BOTTOMMARGIN, 48
    END
 
    IDD_DATER_FORM, DIALOG
    BEGIN
     LEFTMARGIN, 7
     RIGHTMARGIN, 194
     TOPMARGIN, 7
     BOTTOMMARGIN, 94
    END
   END
   #endif // APSTUDIO_INVOKED
 
   //////////////////////////////////////////////////////////////
   //
   // String Table
   //
 
   STRINGTABLE DISCARDABLE
   BEGIN
    IDP_FAILED_OPEN_DATABASE "Cannot open database."
   END
 
   STRINGTABLE PRELOAD DISCARDABLE
   BEGIN
    IDR_MAINFRAME "Dater\n\nDater\n\n\nDater.Document\nDater Document"
   END
 
   STRINGTABLE PRELOAD DISCARDABLE
   BEGIN
    AFX_IDS_APP_TITLE   "Dater"
    AFX_IDS_IDLEMESSAGE "Ready"
   END
 
   STRINGTABLE DISCARDABLE
   BEGIN
    ID_INDICATOR_EXT  "EXT"
    ID_INDICATOR_CAPS "CAP"
    ID_INDICATOR_NUM  "NUM"
    ID_INDICATOR_SCRL "SCRL"
    ID_INDICATOR_OVR  "OVR"
    ID_INDICATOR_REC  "REC"
   END
 
   STRINGTABLE DISCARDABLE
   BEGIN
    ID_APP_ABOUT "Display program information, version number and copyright\nAbout"
    ID_APP_EXIT  "Quit the application; prompts to save documents\nExit"
   END
 
   STRINGTABLE DISCARDABLE
   BEGIN
    ID_FILE_MRU_FILE1  "Open this document"
    ID_FILE_MRU_FILE2  "Open this document"
    //...
    ID_FILE_MRU_FILE16 "Open this document"
   END
 
   STRINGTABLE DISCARDABLE
   BEGIN
    ID_NEXT_PANE "Switch to the next window pane\nNext Pane"
    ID_PREV_PANE "Switch back to the previous window pane\n Previous Pane"
   END
 
   STRINGTABLE DISCARDABLE
   BEGIN
    ID_WINDOW_SPLIT "Split the active window into panes\nSplit"
   END
 
   STRINGTABLE DISCARDABLE
   BEGIN
    ID_EDIT_CLEAR      "Erase the selection\nErase"
    ID_EDIT_CLEAR_ALL  "Erase everything\nErase All"
    ID_EDIT_COPY       "Copy the selection and put it on the Clipboard\nCopy"
    ID_EDIT_CUT        "Cut the selection and put it on the Clipboard\nCut"
    ID_EDIT_FIND       "Find the specified text\nFind"
    ID_EDIT_PASTE      "Insert Clipboard contents\nPaste"
    ID_EDIT_REPEAT     "Repeat the last action\nRepeat"
    ID_EDIT_REPLACE    "Replace specific text with different text\nReplace"
    ID_EDIT_SELECT_ALL "Select the entire document\nSelect All"
    ID_EDIT_UNDO      "Undo the last action\nUndo"
    ID_EDIT_REDO      "Redo the previously undone action\nRedo"
   END
 
   STRINGTABLE DISCARDABLE
   BEGIN
    ID_VIEW_TOOLBAR    "Show or hide the toolbar\nToggle ToolBar"
    ID_VIEW_STATUS_BAR "Show or hide the status bar\nToggle StatusBar"
   END
 
   STRINGTABLE DISCARDABLE
   BEGIN
    ID_RECORD_FIRST "Move to first record\nFirst Record"
    ID_RECORD_LAST  "Move to final record\nLast Record"
    ID_RECORD_NEXT  "Move to next record\nNext Record"
    ID_RECORD_PREV  "Move to previous record\nPrevious Record"
   END
 
   STRINGTABLE DISCARDABLE
   BEGIN
    AFX_IDS_SCSIZE       "Change the window size"
    AFX_IDS_SCMOVE       "Change the window position"
    AFX_IDS_SCMINIMIZE   "Reduce the window to an icon"
    AFX_IDS_SCMAXIMIZE   "Enlarge the window to full size"
    AFX_IDS_SCNEXTWINDOW "Switch to the next document window"
    AFX_IDS_SCPREVWINDOW "Switch to the previous document window"
    AFX_IDS_SCCLOSE      "Close the active window and prompts to save the documents"
   END
 
   STRINGTABLE DISCARDABLE
   BEGIN
    AFX_IDS_SCRESTORE  "Restore the window to normal size"
    AFX_IDS_SCTASKLIST "Activate Task List"
   END
 
   //#endif    // English (U.S.) resources
   //////////////////////////////////////////////////////////////
 
   #ifndef APSTUDIO_INVOKED
   //////////////////////////////////////////////////////////////
   //
   // Generated from the TEXTINCLUDE 3 resource.
   //
   #define _AFX_NO_SPLITTER_RESOURCES
   #define _AFX_NO_OLE_RESOURCES
   #define _AFX_NO_TRACKER_RESOURCES
   #define _AFX_NO_PROPERTY_RESOURCES
 
   #if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
   #ifdef _WIN32
   LANGUAGE 9, 1
   #pragma code_page(1252)
   #endif
   #include "res\Dater.rc2" // non-Microsoft Visual C++ edited resources
   #include "afxres.rc"     // Standard components
   #include "afxdb.rc"      // Database resources
   #endif
   //////////////////////////////////////////////////////////////
   #endif // not APSTUDIO_INVOKED
   Идентификаторы ресурсов приложения Dater определены в файле resource.h. Этот файл создается автоматически редактором ресурсов Microsoft Visual C++. Исходный текст файла resource.h представлен в листинге 3.15.

Листинг 5.4. Файл resource.h

   //{{NO_DEPENDENCIES}}
   // Microsoft Developer Studio generated include file.
   // Used by Dater.rc
   //
   #define IDD_ABOUTBOX             100
   #define IDD_DATER_FORM           101
   #define IDP_FAILED_OPEN_DATABASE 103
   #define IDR_MAINFRAME            128
   #define IDR_DATERTYPE            129
   #define IDC_NAME                 1000
   #define IDC_ADDRESS              1001
   #define IDC_PRIORITY             1002
   #define IDC_PHONE                1003
 
   // Next default values for new objects
   //
   #ifdef APSTUDIO_INVOKED
   #ifndef APSTUDIO_READONLY_SYMBOLS
   #define _APS_3D_CONTROLS         1
   #define _APS_NEXT_RESOURCE_VALUE 130
   #define _APS_NEXT_COMMAND_VALUE  32771
   #define _APS_NEXT_CONTROL_VALUE  1004
   #define _APS_NEXT_SYMED_VALUE    101
   #endif
   #endif
   Наибольший интерес в файле ресурсов приложения Dater представляют строки меню Record и соответствующие им кнопки панели управления. Эти строки и кнопки позволяют просматривать в окне приложения все записи базы данных.

Строка меню Record	Идентификатор	Описание
First Record	ID_RECORD_FIRST	Перейти к первой записи
Previous Record	ID_RECORD_PREV	Перейти к предыдущей записи
Next Record	ID_RECORD_NEXT	Перейти к следующей записи
Last Record	ID_RECORD_LAST	Перейти к последней записи

   Командные сообщения с идентификаторами ID_RECORD_FIRST, ID_RECORD_PREV, ID_RECORD_NEXT и ID_RECORD_LAST обрабатываются виртуальным методом OnMove класса окна просмотра CRecordView.
   По умолчанию, метод OnMove считывает соответствующую запись из базы данных и отображает значения полей этой записи в окне просмотра.