Структура OWL-программы

Программа 25-1 схожа по конечному результату с простейшим приложением Windows, рассмотрен­ным в гл. 6 (пример 6-1); в ней создается и выводится на экран главное окно приложения, для которого (в отличие от примера 6-1) задаются три дополнительных характеристики: местоположение окна на экране, его размер и цвет фона окна. Программа имеет типичную для OWL-приложений структуру и состоит из трех отчетливо выделенных частей: описания класса приложения и входящих в него функций, описания класса главного окна приложения с его функциями и, наконец, главной функции OwlMain(). Функции с таким именем передается управление при запуске приложения, и она, таким образом, должна обязатель­но присутствовать в любых OWL-приложениях, заменяя собой функцию WinMain() обычных приложе­ний Windows или функцию main() приложений MS-DOS.

Библиотека OWL, как и любая другая объектно-ориентированная библиотека для разработки прило­жений Windows, содержит описание классов для реализации практически всех основных средств Win­dows (окон, диалогов, органов управления, средств графического интерфейса GDI и т. д.). Составление приложения Windows, грубо говоря, заключается в подборе библиотечных классов, реализующих сред­ства, используемые в конкретном приложении, описании в программе прикладных классов, являющихся производными от библиотечных, и использовании затем наследуемых данных-членов и функций-членов этих классов. При необходимости библиотечные функции-члены модифицируются (путем их замещения прикладными функциями с теми же именами и сигнатурами) с целью придания им требуемых свойств, а данным-членам задаются требуемые значения. Во многих случаях библиотечные функции вполне удов­летворительно решают прикладную задачу и не нуждаются в модификации, и тогда используются не производные от библиотечных, а сами библиотечные классы: создаются их экземпляры (объекты) и вы­зываются необходимые функции-члены этих классов с передачей им конкретных параметров.

В рассматриваемом OWL-приложении используются только два библиотечных класса: класс прило­жения TApplication и класс главного окна TFrameWindow, который является производным от класса TWindow.

Класс TApplication, от которого мы создаем производный класс МуАрр (имя этого прикладного клас­са, разумеется, может быть любым) сам является производным от класса TModule, и, таким образом, эти три класса образуют иерархическую структуру, показанную на рис. 25.2.

дуля приложения (под модулем приложения понимают ту часть приложения, в которой сосредоточены его коды и ресурсы, в от­личие от экземпляра приложения, содержащего данные и очередь сообщений), в частности, организует загрузку и выгрузку дина­мических библиотек, а также предоставляет ряд информацион­ных функций, относящихся к модулю и приложению в целом. Так, в него входят функции-члены загрузки ресурсов LoadCur-sor(), Loadlcon(), LoadBitmap(), получения информации о свойст­вах модуля и приложения GetModuleFileName(), GetClassInfo(), Getlnstance(), обработки ошибок Error() и ряд других. В примере 25-1 функции базового класса TModule не используются.

Класс TApplication обеспечивает основные свойства приложения Windows. Функции этого класса, в частности, организуют создание главного окна (именно организуют; собственно создание окна возлага­ется на функции другого класса - TWindow), обрабатывают сообщения, поступающие в окно приложе­ния, обеспечивают загрузку динамических библиотек, позволяющих пользоваться органами управления в стиле Borland, и выполняют ряд других важных операций.

Всю работу по инициализации приложения, созданию и выводу на экран главного окна и организа­ции цикла обработки сообщений выполняет открытая функция-член Run(), входящая в класс TApplica­tion. Поэтому & простых случаях главная функция приложения OwlMain() может состоять всего из двух

224 Глава 25

строк: создания экземпляра класса TApplication или производного от него и вызова функции Run() для этого экземпляра. Именно так выглядит функций OwlMain() в рассматриваемом примере. С другой сто­роны, для задания характеристик и свойств окна приложения приходится вмешиваться в работу этой функции, изменяя используемый по умолчанию алгоритм ее выполнения, что требует понимания этого алгоритма и возможностей его изменения. Рассмотрим процедуру выполнения функции Run() более де­тально.

Основной задачей функции Run() можно считать последовательный вызов ряда других функций OWL, принадлежащих как классу TApplication, так и классу TWindow, что в итоге приводит к нормаль­ному функционированию приложения. Последовательность этих вызовов с указанием классов, которым принадлежат вызываемые функции, приведена на рис. 25.3.

Как видно из рис. 25.3, функция Run() последовательно вызывает три другие функции того же класса TApplication: InitApplication(), InitInstance() и MessageLoop().

Функция

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

Функция InitInstance() вызывается как для первого, так и для всех остальных экземпляров приложе­ния и выполняет целый ряд весьма важных действий. Прежде всего она вызывает функцию InitMainWin-dow(), которая создает объект класса TFrameWindow, определяющий характеристики главного окна, и вызывает функцию SetMainWindow(), которая объявляет новое окно главным. Именно на этом этапе можно изменить, например, расположение, размеры или стиль окна.

После создания объекта класса TFrameWindow, характеризующего новое окно, можно обращаться к функциям-членам этого класса. Функция InitInstance() это и делает, вызывая последовательно функции класса TWindow Create() и ShowWindow(), выполняющие создание и показ нового окна. Эти действия реализуются путем вызова знакомых нам по части II этой книги функций "классического" интерфейса (API) Windows (CreateWindow() и ShowWindow().

Образовав и выведя на экран главное окно приложения, функция Run() вызовом функции Message-LoopO входит в цикл обработки сообщений, в котором приложение и находится до своего завершения.

Для того, чтобы можно было изменять характеристики и свойства главного окна, надо создать собст­венный класс главного окна (в примере 25-1 ему дано произвольное имя MyWindow), производный от библиотечного класса TFrameWindow. Класс TFrameWindow сам является производным от класса TWin­dow, и, таким образом, эти три класса образуют иерархическую структуру, показанную на рис. 25.4.

Класс TWindow является родоначальником ряда классов, описывающих функционирование разного рода окон (диалогов, органов управления и других), которые, естественно, наследуют возможности своего базового класса TWindow. Среди этих про­изводных классов есть и класс окон с рамками TFrameWindow.

В класс TWindow входит большое число (около 300!) функ­ций-членов, обеспечивающих общие черты поведения окон, на­значение многих из которых нам знакомо по части II этой кни­ги: Create(), ShowWindow(), MoveWindow(), GetClientRect(), In-validate(), SendMessage(), SetBkgndColor(), SetWindowWord() и т. д. В примере 25-1 использовалась функция SetBkgndColor(), устанавливающая цвет фона окна.

Помимо функций, в класс TWindow входит ряд данных-членов, из которых нас пока будет интересо­вать только структура типа TWindowAttr, которая представлена в классе TWindow данным-членом Attr. Элементы этой структуры определяют атрибуты окна, устанавливаемые во время его создания: стиль, координаты, размеры и др. В примере 25-1 с помощью элементов этой структуры устанавливаются коор­динаты и размеры окна.

Простейшее OWL-приложение Windows 225

Создав в программе производный от TApplication класс МуАрр, мы получили возможность переоп­ределить в нем функцию класса TApplication InitMainWindow(). Зачем это нужно? Как видно из рис. 25.3, в этой функции вызовом функции SetMainWindow() создается безымянный экземпляр класса TFrameWindow, к которому и обратиться-то нельзя. Нам нужно заменить его экземпляром производного от него класса My Window, с функциями и данными которого мы сможем работать. В замещенной функ­ции InitMainWindow() выполняется в сущности то же, что было предусмотрено в исходной функции, но в нужном нам варианте:

/* Замещенная функция InitMainWindow()*/

void МуАрр::InitMainWindow(void){

MyWindow* myWin=new MyWindow(0,"Программа 25-1");/ /Создаем объект класса MyWindow

SetMainWindow(myWin); //Объявляем новое окно главным

}

Сначала создается экземпляр прикладного класса MyWindow с указателем на него mywin, а затем вызовом функции SetMainWindow() созданное окно объявляется главным. В процессе создания экземп­ляра класса MyWindow (т.е. вызова конструктора этого класса) конструктору передаются требуемые па­раметры, первый из которых (0) говорит о том, что у этого окна нет родителя (поскольку оно является главным), а второй представляет собой заголовок окна. Очевидно, что составить текст замещающей функции InitMainWindow можно, только изучив исходный текст замещаемой, который можно найти в файле \source\owl\applicat.cpp, содержащем исходные тексты всех функций класса TApplication.

Для того, чтобы описанный выше фрагмент работал должным образом, необходимо описать конст­руктор нашего класса MyWindow, предусмотрев в нем, разумеется, вызов конструктора базового класса TFrameWindow ради передачи в него инициализирующих параметров. Этот конструктор описан в файле bc5\include\owl\window.h следующим образом:

TFrameWindow(TWindow* parent, const char far *title=0,TWindow* clientWnd=0 bool shrinkToClient=false,TModule* module=0);

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

class MyWindow:public TFrameWindow{ public:

MyWindow(TWindow*parent,char far*title):TFrameWindow(parent,title){ SetBkgndColor(COLOR_WINDOWFRAME+1); //Задаем цвет фона окна (серый) Attr.X=10; Attr.Y=10; //Задаем координаты окна Attr.W=200; Attr.H=60; //Задаем размеры окна } };

указывается, что они является производным от TFrameWindow и описывается единственная функция этого класса, именно, его конструктор. В конструкторе MyWindow предусмотрен вызов конструктора ба­зового класса TFrameWindow с передачей ему двух параметров parent и title. Как мы уже видели, при фактическом вызове этого конструктора ему передаются значения параметров 0 и "Программа 25-1".

Далее в текст конструктора MyWindow включены действия, которые мы хотим выполнить при соз­дании главного окна: вызов открытой функции-члена класса TWindow SetBkgndColor() для задания цвета фона окна, а также изменение действующих по умолчанию значений структуры Attr, определяющих ко­ординаты и размеры окна. В принципе эти действия не обязательно вносить в конструктор; их можно было выполнить и после создания экземпляра класса MyWindow, включив в функцию InitMainWindow следующие строки:

mywin->SetBkgndColor(COLOR_WINDOWFRAME+1); mywin->Attr.Х=20; mywin->Attr.Y=20; mywin->Attr.W=200; mywin->Attr.H=60;

Ясно, однако, что этим инициализирующим действиям самое место в конструкторе класса. Вернемся теперь к классу TApplication. Для того, чтобы переопределить его функцию-член Init-MainWindow(), мы создаем производный класс МуАрр:

/*Кпасс МуАрр приложения, производной от Tapplication*/

class МуАрр:public TApplication{ public:

virtual void InitMainWindow(void); //Замещаем функцию InitMainWindow

};

В описании класса МуАрр указано, что он является производным от TApplication; конструктор этого класса мы не описываем, так как в классе нет никаких данных, и явный конструктор для него не нужен, а в конструкторе базового класса (описанном в файле bc5\include\owl\applicat.h)

226 Глава 25

TApplication(const char

far*name=0,TModule*&gModule=::Module,TAppDictionary*appDict=0);

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

Описав в секции public класса МуАрр прототип виртуальной функции InitMainWindow(), мы замес­тили исходную функцию с тем же именем, описанную в базовом классе TApplication. Как отмечалось в гл. 24, при замещении виртуальной функции описатель virtual можно опустить; часто его оставляют ради наглядности.

Рассмотрим возможный вариант текста главной функции OwlMain(). В примере 25-1 обращение к объекту класса МуАрр происходило по его имени туАрр. Вместо имени объекта можно использовать его адрес; в этом случае текст функции OwlMain несколько изменится:

int OwlMain(int,char*[]){

МуАрр* myApp=new МуАрр;

return myApp->Run(); }

Здесь, разумеется, myApp имеет другой смысл - это указатель на объект класса МуАрр.