Внутри модуля функции могут быть определены и ссылаться друг на друга в произвольном порядке. Если данный модуль ссылается на другие формы и модули, следует с помощью директивы препроцессора #include включить в него соответствующий h-файл с помощью пункта меню File/Include Unit Hdr.... После этого интерфейсные элементы другого модуля будут доступны в данном модуле.
Файл формы
Форма является одним из важнейших элементов приложения C++ Builder. Процесс редактирования формы происходит при добавлении к форме компонентов, изменении их свойств, создании обработчиков событий.
Рис. 4. Структура файла формы
Когда к проекту добавляется новая форма, создаются три отдельных файла:
Файл модуля (.cpp) - cодержит исходный код, связанный с формой.
h-файл(.h) - cодержит описание класса формы, то есть описания содержащихся на форме компонентов и обработчиков событий.
Файл формы (.dfm) - двоичный файл, содержащий сведения об опубликованных (то есть доступных в инспекторе объектов) свойствах компонентов, содержащихся в форме. Двоичный файл формы содержит информацию, используемую для конструирования формы из компонентов, расположенных на ней. При добавлении компонента к форме и заголовочный файл, и двоичный файл формы модифицируются. При редактировании свойств компонента в инспекторе объектов эти изменения сохраняются в двоичном файле формы.
Хотя в C++ Builder файл.dfm сохраняется в двоичном формате, его содержание можно просмотреть с помощью редактора кода. Для этого нужно нажать правую клавишу мыши над формой и из контекстного меню формы выбрать пункт View as Text.
Отметим, что при изъятии какого-либо компонента с формы в буфер обмена в последнем реально оказывается часть тестового представления файла формы, содержащая описание данного компонента. В этом можно убедиться, выполнив затем операцию вставки из буфера обмена в любом текстовом редакторе. Модули Delphi 2.0
|
|
C++ Builder создан на основе визуальной библиотеки компонентов Borland Delphi, ставшей за последние два года весьма популярной среди разработчиков. По этой причине этот продукт имеет общую с Delphi библиотеку классов, часть из которых осталась написанной на Object Pascal. Из этого следует, что в приложениях можно использовать компоненты, созданные для Delphi 2.0.
Однако совместимость с Delphi этим не исчерпывается. В проектах C++ Builder можно использовать не только библиотеку компонентов Delphi, но и код, написанный на Object Pascal, а также формы и модули Delphi. Эти возможности появились благодаря включению в С++ Builder обоих компиляторов -- С++ и Object Pascal.
Рис. 5. Типы файлов, используемые в проектах С++ Builder
В соответствии с этим в качестве частей проекта могут быть использованы модули, написанные на Object Pascal. В этом можно убедиться, взяв формы какого-нибудь из примеров, созданных в Delphi 2.0 и включив их в проект С++ Builder. Возьмем в качестве такого примера приложение Graphex из набора примеров Delphi 2.0. Создадим новый проект, удалим из него созданную по умолчанию форму и добавим два модуля из приложения Graphex - Graphwin.pas и Bmpdlg.pas.
Рис. 6. Добавление модулей Delphi к проекту.
Скомпилируем проект. Можно убедиться в работоспособности полученного приложения, запустив и протестировав его.
В случае использования форм Delphi к проекту добавляются два файла - файл формы с расширением *.dfm и файл модуля с расширением *.pas. Описание класса формы содержится в самом модуле, следовательно, для этого не требуется отдельный файл заголовка.
|
|
Рассмотрим более подробно структуру модуля Delphi. В качестве простейшего примера приведем структуру модуля, связанного с формой, содержащей единственный интерфейсный элемент - кнопку закрытия окна: unit Unit1; interface uses Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs; type TForm1 = class(TForm) Button1: TButton; procedure Button1Click(Sender: TObject); private { Private declarations } public { Public declarations } end; var Form1: TForm1; implementation {$R *.DFM} procedure TForm1.Button1Click(Sender: TObject); begin close; end; end.
Основными элементами модуля являются:
· Заголовок модуля - предназначен для идентификации модуля и должен быть уникальным для данного проекта. Совпадает с именем файла с расширением *.pas.
· Секция интерфейса (начинается зарезервированным словом interface). Секция интерфейса является местом, где объявляются константы, типы, переменные, процедуры* и функции, которые доступны для использования другими программными модулями. При объявлении процедур и функций в секции интерфейса необходимыми являются только их заголовки. Тела, или реализации, этих процедур и функций располагаются в секции реализации.
· Секция реализации (начинается зарезервированным словом implementation) содержит процедуры и функции, включая обработчики событий. Объявления обработчиков событий должны присутствовать в секции интерфейса. Помимо этого, секция реализации может иметь дополнительные процедуры, функции и объявления констант, типов и переменных, упоминания о которых нет в секции интерфейса, но эти объявления видимы только в пределах данного модуля.
|
|
· Секции инициализации и завершения (начинаются с зарезервированных слов initialization и finalization) - необязательные секции для размещения операторов, выполняемых соответственно при запуске и завершении приложения. Предложение uses (необязательное) содержит имена других модулей, используемых данным модулем и может располагаться непосредственно за ключевым словом interface и за ключевым словом implementation. Предложение uses делает секцию интерфейса других модулей доступной в данном модуле.
Отметим, однако, что для создания новых модулей Delphi требуется наличие Delphi. В С++ Builder их можно только использовать. Возможности редактирования форм и модулей Delphi в С++ Builder существенно ограничены - допустимы только операции, не затрагивающие секцию интерфейса модуля. Например, возможно перемещение интерфейсных элементов в пределах содержащих их компонентов-контейнеров, изменение размеров, копирование в буфер обмена, но запрещено их добавление или удаление. Возможны изменения внутри кода процедур и функций, но запрещено добавление новых обработчиков событий.
Особенности программирования под Windows.
Язык программирования С++ создавался тогда когда, существовали две операционные системы Dos и Unix. Ни тодна из них не имела развитого графического интерфейса, поэтому, создавая программу программист был вынужден создавать интерфейс для пользователя, чтобы тот смог в дальнейшем работать с этой программой. Появление Windows в значительной степени упростило эту задачу. В самом деле, Windows имеет разветвленный графический интерфейс прикладного программирования (Application Programming Interface – API), позволяющий создавать окна, меню, кнопки, полосы прокрутки и т.п. API – это набор необходимых функций с помощью которых любое приложение может взаимодействовать с операционной системой. API – это своего рода связывающее звено между приложением и операционной системой. API для Win32 содержит более 2000 функций, несколько сотен сообщений, констант, макросов. Было бы нелепо создавать все это заново, вместо того, чтобы воспользоваться имеющимися разработками. Однако для того, чтобы это сделать нужно иметь некоторые представления о механизме работы ОС Windows. Рассмотрим лишь некоторые основные возможности этой операционной системы.
Язык программирования это набор правил, позволяющих писать инструкции для компьютера. В свою очередь компьютер это процессор и память. Все остальное – жесткий диск, дисководы, клавиатура, экран, принтер, и т.д. это устройства, которых компьютер может и не иметь. Иначе говоря, язык программировании предназначен для работы с процессором и памятью. Еще недавно использование такого подхода при создании программ было вполне оправдано. Операционная система, получив команду на выполнение программы, предоставляла последней компьютер в полное распоряжение, а та ипользовала его до своего заершения если оно было предусмотрено. Однако появление операционных систем Windows32 полность изменило технологию исполнения программ. Теперь выполнение прогаммы находится под постоянным контролем операционной системы.
В отличие от предшествующих операционных систем Win32 является многозадачной, т.е. имеет возможность одновременного выполнения нескольких задач. Впрочем, это только кажущаяся одновременность. На самом деле один процессор может только переключаться от выполнения одной задачи к другой, но операционная система сама решает какой программе предоставить в распоряжение процессор. Подобная организация позволяет, выполнять одновременного нескольких программ, и не допускает возможности полного захвата ресурсов компьютера одной задачей, защищая, таким образом, систему от "зависания" (хотя на практике это не всегда так).
Выполняемая задача, или как принято говорить в Win32 процесс, может быть разбита на несколько одновременно выполняющихся подзадач, которые называются потоками. При этом основной поток может продолжать общаться с пользователем, в то время как другие заняты выполнением возложенных на них функций.
Все потоки, принадлежащие одному процессу, выполняются в одном адресном пространство пространстве и имеют общие с этим процессом код, ресурсы и глобальные переменные. Для того чтобы несколько потоков слаженно решали поставленные задачи и не мешали друг другу при использовании каких-то общих ресурсов, применяется синхронизация потоков. Синхронизация может потребоваться, например, в случае, когда один из потоков должен дождаться завершения какой-то операции, выполняемой другим потоком, или когда потоки работают с ресурсом, способным одновременно обслуживать лишь один из них. Поскольку потоки выполняются в условиях вытесняющей многозадачности, функции их синхронизации берет на себя операционная система. Для управления потоками в Windows используются специальные флаги, на которых основано действие нескольких механизмов синхронизации.: семафоры (semaphores), исключающие (mutex) семафоры, события (event), критические секции (critical section).
Win 32 расчитана на оперативную память до 4Ггб. Для большинства персональных компюютеров это слишком большая память, поэтому вместо оперативной памяти программам предоставляется жесткий диск или иначе виртуальная оперативная память. Конечно быстродействие последней намного ниже. Один и тот же процесс может использовать частично оперативную память, а частичео виртуальную память. Операционная система следит как часто исполняемому процессу требуется оперативная память, и в зависимости от частоты обращения к ней соотношения между предоставляемой оперативной памятью и виртуальной памятью может быть изменено в любую сторону.
В Win32 каждый процесс имеет свое адресное пространство, поэтому одновременно выполняемые приложения не могут случайно повредить данные друг друга. Однако часто возникает необходимость в обмене информацией или процессами. Для этой цели в Win32 предусмотрены специальные способы, позволяющие приложениям получать совместный доступ к каким-либо данным.
Один из способов заключается в создании "Почтового ящика" (mailslot) — специальной структуры в памяти, имитирующей обычный файл на жестком диске. Приложения могут помещать данные в "ящик" и считывать их из него. Когда все приложения, работающие с ящиком, завершаются, "почтовый ящик и данные, находящиеся в нем, удаляются из памяти.
Другой способ заключается в организации коммуникационной магистрали -"канала" (pipe), соединяющего процессы. Приложение, имеющее доступ к каналу с одного его "конца", может связаться с приложением, имеющим доступ к каналу с другого его "конца", и передать ему данные. Канал может выделять приложениям односторонний или двусторонний доступ. При одностороннем доступе одно приложение может записывать данные в канал, а другое — считывать; при двустороннем — оба приложения могут выполнять операции чтения/записи. Существует возможность организовать канал, коммутирующий сразу несколько процессов.
Таким образом, особенностью операционной системы Win32 является непрерывный обмен сообщениями между потоками и системой. Поэтому создание программ под Windows имеет свои особенности, связанные именно с обработкой сообщений.
Создание окон.
Windows это программа написанная на языке С++. Причем обмен информацией системы с пользователем чаще всего осуществляется с помощью окон. Сразу возникает вопрос: как операционная система Windows в процессе работы создает окна к которым вынуждена сама обращаться? Ответ очень прост. Средствами языка С++. Существует базовый класс Frame от которого пораждаются объекты - окна. Только нужно иметь в виду, что имена этим объектам дает сама операционная система. Имена представляют собой целые числа. Использование таких имен вполне оправдано, т.к. следующий объект получает уникальное имя строящееся по простому правилу, к последнему имени нужно добавить единицу. И вообще большинство переменных в Windows это целые числа. Только нужно иметь в виду, что это не числа типа int. Такие имена объектов Windows называются дискрипторами.
В Win32 программах вместо стандартных для С и С++ типов данных (таких, как int или char) применяются типы данных, определенные в библиотечных файлах (например, в WINDOWS.Н). Часто используются следующие типы:
HANDLE — 32-разрядное целое предназначено для автоматического создания имен т.е. идентификатор какого-либо ресурса, например имя окна, диска и т.п;
HWND — 32- разрядное длинное целое для создания имен окон;
BYTE — 8-разрядное беззнаковое символьное значение;
WORD— 16-разрядное беззнаковое короткое целое;
DWORD, UINT — 32-разрядное беззнаковое длинное целое;
LONG — 32-разрядное длинное целое со знаком;
BOOL — целое, используется для обозначения истинности (1 — TRUE) или ложности (0 — FALSE);
LPSTR — 32-разрядный указатель на строку символов.
Кроме перечисленных, существует еще много других типов, обозначающих дескрипторы различных ресурсов, указатели, структуры и т. д. Различия многих из них заключаются лишь в том, что они обозначают. Понятно, что в большинстве случаев, эти типы на самом деле являются именами классов, которые осуществляют те или иные действия в операционной системе. В Windows программах можно также использовать и все традиционные типы данных.
Функция WinMain
Все программы, написанные на языках С или C++, начинают свое выполнение с функции main(). Корпорации Microsoft была вынуждена здесь внести изменение в принятые стандарты, т.к. параметры стандартной функции main не подходят для приложений Windows. Теперь каждая Windows-программа на С или C++ начинает свое выполнение с вызова функции WinMain(), Объявление этой функции в рамках Win32 API следующее:
int WINAPI WinMain(HINSTANCE hlnstance,
HINSTANCE hPrevlnstance,
LPSTR LpCmdLine,
int nCmdShow);
Здесь
hlnstance — дескриптор текущего приложения;
hPrevlnstance — дескриптор предыдущей запущенной копии приложения;
LpCmdLine — указатель на командную строку;
nCmdShow — режим начального отображения главного окна приложения.
Вот пример простейшей программы для Windows:
/*******************************************************
Модуль APIMain
Copyright (с) 1997 Мешков А., Тихомиров Ю.
*******************************************************/
#include <windows.h>
int WINAPI WinMain(
HINSTANCE hlnstance,
HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int nCmdShow) {
return (FALSE);
}
Код программы несколько больше, чем просто вызов функции main, за счет подключаемого файла WINDOWS.H, который включает в себя еще пару десятков заголовочных файлов, состоящих из десятков тысяч строк, поэтому время компиляции даже такой программы может занять несколько минут.
Значение параметра hPrevInstance позволяет определить наличие уже запущенных копий программы. В большинстве случаев это нужно для исключения повторного запуска одной и той же профаммы. В Win32 API этот параметр всегда равен NULL. Связано это с тем, что каждое 32-разрядное приложение запускается в своем адресном пространстве, в котором, естественно, нет никаких его копий или других приложений.
В документации Microsoft предлагает несколько путей для определения наличия предыдущей копии. Один из них заключается в использовании функции FindWindow. Функция FindWindow в случае обнаружения искомого окна возвращает его дескриптор. Один из параметров может быть равен NULL, в этом случае поиск будет производиться при помощи второго параметра.
HWND FindWindow(
LPCTSTR IpClassName,
LPCTSTR IpWindowName
);
Здесь
lpClassName — указатель на строку, содержащую имя оконного класса или специального вида идентификатор этого класса; lpWindowName — указатель на строку, содержащую заголовок искомого окна
Одно из требований Microsoft к приложениям для Windows состоит в исключении повторного запуска. Действительно, большинству программ это не нужно. Например, для многооконных редакторов повторный запуск вместо открытия дополнительного окна приведет только к лишней трате системных ресурсов. Для программ мониторинга или управления вообще бессмысленно держать две копии приложения в памяти, т. к. такие программы обычно работают с неразделяемыми ресурсами. Хорошей практикой является не только завершение повторной копии приложения сразу после загрузки, но и активизация этого приложения, ведь, скорее всего, повторный запуск был произведен из-за того, что оно понадобилось пользователю. Активизация в общем случае совершается в два этапа. Во-первых, главное окно искомого приложения восстанавливается в размере, если оно было свернуто в значок, и, во-вторых, происходит собственно активизация — перевод окна и, соответственно, приложения на передний план. На этом обычно повторная копия приложения должна быть завершена. Для этого используются функции IsIconic, ShowWindow, SetForegroundWindow.
hwnd = FindWindow (szClassName, szWindowTitle);
if (hwnd)
{ /* нашли копию приложения — восстановим его на экране и
активизируем его */
if (Islconic(hwnd))
ShowWindow(hwnd, SW_RESTORE);
SetForegroundWindow (hwnd);
/* данная копия должна быть завершена */ return (FALSE);
Программирование в среде Microsoft Visual C++ 6
Утилита Spy (в переводе шпион, или найти, обнаружить, разглядеть, увидеть) позволяет наблюдать за системными процессами в Windows. Запустить данную утилиту можно из главного меню Tools/Spy++. В результате Вы получите окно со списком всех окон в Windows. Примерно такое, как то, что мзображено ниже.
Окна представлены в виде дерева. Главным окном является DeskTop (рабочий стол), от него идут ветвления. В каждом окне есть еще окна, и так до элементов управления. Корень - рабочий стол. Ветви это запущенные программы или процессы, а более мелкие ветви это конечные окна или элементы управления. В ходе работы, как уже говорилось, между системой и окнами посылаются сообщения. Их можно просматривать. Для этого установите курсор на интересующее вас дискриптор окна, нажмите правую кнопку мыши и выберите Message.
Не будем больше задерживаться на сообщениях, а посмотрим как можно получить имя для окна к созданию окна. Сначала воспользуемся функцией GetDesktopWindow(), которая вернет HWND корневого окна, которым является рабочий стол. Далее двигаясь по ветвям дерева от текущего HWND можно получить HWND всех дочерних окон. Для этого воспользуемся функцией GetWindow(HWND hwnd, UINT ucmd).
Функция GetWindow() имеет два параметра. Первый это имя (дискриптор) окна, т.е.hwnd, второй определяет соотношение родства и может принимать только определенные значения. В частности, если в качестве второго параметра указать GW_CHILD, то это означает, что определяется имя дочернего окна. Дочерних окон может быть несколько, поэтому если в качестве второго параметра указать GW_HWNDNEXT то это значит, что нужно определить дискриптор следующего окна, находящегося на уровне дочернего.
Имея HWND окна можно получить его заголовок GetWindowText.
Вот код получения имен окон первого уровня. Пока программу, как и прежде выполним в консольном приложении.
/* GetWindow.cpp: Определение точки входа консольного приложенияDefines the entry point for the console application.*/// https://www.firststeps.ru#include "windows.h"#include "iostream.h" void main(){HWND hwnd; //создаем объект для определения имени окна char p[100]; /* массив для записи заголовков окон */ hwnd = GetDesktopWindow(); //определение имени корневого окна hwnd = GetWindow(hwnd, GW_CHILD); /*определение имени она следующего уровня*/ while (hwnd!=0){hwnd = GetWindow(hwnd, GW_HWNDNEXT); /*поиск окон первого уровня*/ GetWindowText(hwnd,p,100); /*записываем заголовоки окна */ if (strlen(p)>0) cout << p << endl; /*если заголовок найден – вывод на экран*/ }}Результат работы на моем компьютере
Вот такой список окон первого уровня. Это не значит, что все перечисленные окна открыты. Они готовы к тому, чтобы быть открытыми.
Работа Windows-программ основана на обработке сообщений, которые поступают от пользователя, операционной системы и других программ. Структур приложений обязательно включает в себя главную функцию WinMain(), одинаково устроенную для всех приложений. С нее начинается выполнение всех программ. WinMain() должна выполнить следующие сновные действия:
1. Определить и зарегистрировать класс окна в Windows.
2. Создать и отобразить окно, определяемое данным классом.
3. Запустить цикл обработки сообщений.
При определении класса окна указывается специальная функция окна, которая должна реагировать на поступающие окну сообщения. В каждом приложение имеется своя очередь сообщений. Эту очередь создает Windows и помещает туда все сообщения, адресованные окну приложения. После создания и отображения окна запускается основной цикл обработки сообщений, в котором сообщения проходят предварительную обработку и возвращаются Windows-ом обратно. Затем Windows вызывает функцию окна программы с очередным сообщением в качестве аргумента. Анализируя сообщение, функция окна инициирует соответствующие операции. Сообщения, обработка которых не усмотрена функцией окна, передаются Windows, который выполняет обработку "по умолчанию".
Теперь попробуем создать окно с помощью библиотеки MFC. В простейшем случае такая программа должна использовать два класса этой библиотеки. Первый это CFrameWnd, второй CWinApp. Слово Frame в переводе с английского означает - рама, каркас, основа. Поэтому понятно, что класс CFrameWnd является основой для создания окна (Window или сокращенно Wnd). Сокращение App происходит от английского Application, что, как известно, означает приложение, а для операционной системы Windows так называются все программы, которые работают под ее управлением. Поэтому класс CwinApp позволяет создать приложение (программу) для операционной системы Windows. В MFC всеклассы начинаются с буквы С, а все переменные с буквы m. Мы так же будем придерживаться такого правила.
Итак, вот эта программа:
//Программа «Мое первое окно»
#include <afxwin.h> /*Описание библиотек MFC*/
// Создадим окно для чего используем родительский
// класс CFrameWnd
class CMainWin: public CFrameWnd
{
public:
CMainWin(); //Это конструктор
/*К окну будут поступать сообщения, поэтому нужно создать
* обработчик этих сообщений, который называется картой
* сообщений*/
DECLARE_MESSAGE_MAP() //Макрос объявления карты сообщений
};
/*Описание класса закончилось. Далее идет описание функций */
CMainWin::CMainWin(){
Create(NULL, "Мое первое окно"); /*Функция создания окна
* унаследованная от родительского класса CFrameWnd */
}
//Карта сообщений приложения
BEGIN_MESSAGE_MAP(CMainWin, CFrameWnd) /*Начало обработки
* сообщений */
/*Здесь должны быть функции обработки сообщений,
* но т.к. их нет поступающие к окну сообщения
* не обрабатываются*/
END_MESSAGE_MAP() /*Конец обработки сообщений*/
//Начало выполнения приложения
//------------------------------------------------------
//Начинается описание второго класса
/*Создаем класс наследник от другого класса CWinApp */
class CApp: public CWinApp
{
public:
BOOL InitInstance();
};
/* В родительском классе CwinApp есть функция InitInstance
у которой возвращаемое значение отлично от нуля, если
инициализация успешна, иначе 0 */
BOOL CApp::InitInstance(){ //Перегрузка функции InitInstance
m_pMainWnd=new CMainWin;
m_pMainWnd->ShowWindow(m_nCmdShow);
return TRUE;
}
CApp theApp; //Создание объекта theApp
В данном примере пока многое непонятно. Кое-что можно пояснить сейчас. Так в начале подкючается файл afxwin.h,который содержит описание классов библиотеки MFC и подключает множество других файлов, втом числе WINDOWS.H.
Класс CFrameWnd обеспечивает функциональные возможности Windows на основе одиночного интерфейса документа (SDI) для всплывающих окон наряду с элементами для управления окном.
Чтобы создавать полезное рамочное окно для Вашей прикладной программы, получите класс из CFrameWnd. Добавьте поля к полученному классу, чтобы сохранить данные, специфические для Вашей прикладной программы. Примените сообщения и карту сообщения в полученном классе, чтобы определить то, что случается, когда сообщения полученные окном.
Имеются три способа создать рамочное окно:
Непосредственно создайте используя Create.
Непосредственно создайте используя LoadFrame.
Косвенно создайте используя шаблон документа.
Прежде, чем Вы вызываете Create или LoadFrame, Вы должны создать объект рамочного окна в "куче ", используя C++ new оператор. Прежде, чем вызывать Create, Вы можете также регистрировать класс окна глобальной функцией AfxRegisterWndClass, чтобы установить пиктограмму и стили класса для рамки.
Используйте Create функцию, чтобы передать параметры создания рамки как непосредственные параметры.
LoadFrame требует, меньшее количество параметров чем Create, и взамен восстанавливает большинство значений по умолчанию из ресурсов, включая заголовок рамки, пиктограмму, таблицу акселератора, и меню. Чтобы быть доступным LoadFrame, все эти ресурсы должны иметь тот же самый ресурс ID (например IDR_MAINFRAME).
Когда объект CFrameWnd содержит виды и документы, они созданы косвенно рамкой вместо непосредственного создания программистом. Объект CDocTemplate обеспечивает создание рамки, создание вида, и подключение видов к соответствующему документу. Параметры CDocTemplate конструктора определяют CRuntimeClass из трех включаемых классов (документ, рамка, вид). Объект CRuntimeClass используется рамкой, чтобы динамически создать новые рамки когда это определено пользователем (например, используя команду File New или в многодокументной среде (MDI) командой Window New).
Класс рамочного окна, полученный из CFrameWnd должен быть объявлен с DECLARE_DYNCREATE для вышеупомянутого RUNTIME_CLASS механизма, чтобы работать правильно.
CFrameWnd содержит заданные по умолчанию реализации чтобы выполнить следующие функции основного окна в типичной прикладной программе для Windows:
1. CFrameWnd рамочное окно следит за активным просмотром, который не зависит от активного окна Windows или текущего фокуса ввода. Когда рамка повторно активизирована, активному просмотру сообщается путем вызова вызывая CView::OnActivateView.