Раздел второй

РАЗРАБОТКА ПРИКЛАДНЫХ ПРОГРАММ
ДЛЯ WINDOWS В СИСТЕМЕ

ПРОГРАММИРОВАНИЯ BORLAND C++ BUILDER

 

Цель этого раздела состоит в том, чтобы дать читателям представление о визуальной технологии программирования и научить их применять эту технологию при разработке прикладных программ (приложений) для Windows, используя язык программирования С++ и систему программирования Borland C++ Builder. Следует отметить, что в настоящее время при разработке программного обеспечения методы визуального программирования являются весьма популярными и востребованными, так как обеспечивают приближение формы представления программы и способов ее кодирования к образному способу мышления человека. Применение этих методов позволяет в значительной степени сократить число ошибок, допускаемых человеком при разработке программ и повысить надежность программирования.

Система Borland С++ Builder – это мощная среда программирования, которая поддерживает принципы визуального объектно-ориентированного программирования для 32-разрядных операционных систем Microsoft Windows и позволяет значительно сократить время на разработку приложений.

Как отмечает А.Я. Архангельский, «С++ Builder настолько многогранен, что рассказать о всех его аспектах в одной книге невозможно». [6]. Поэтому данный раздел посвящен изложению лишь основных аспектов разработки приложений в этой среде. В нем рассмотрены такие вопросы, как интегрированная среда разработки С++ Builder, состав модулей проекта приложений, организация реакции программы на события, использование библиотеки визуальных компонентов, проектирование интерфейса пользователя, основы работы с графикой, поставка приложений пользователю.

Читателям, не знакомым с языком программирования С++, перед чтением  данного раздела необходимо изучить первый раздел пособия.  Как и в первом разделе, изложение материала сопровождается многочисленными примерами программ. Все приведенные примеры компилировались в среде Borland С++ Builder 6. Большинство примеров программ являются достаточно короткими, так как они предназначены для демонстрации излагаемого материала и их следует рассматривать как инструменты для обучения, а не как образцы законченных приложений для Windows.

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

9. СИСТЕМА ПРОГРАММИРОВАНИЯ BORLAND С++ВUILDER

 

Ниже дается общая характеристика системы программирования Borland C++ Builder как среды быстрой разработки прикладных программ. Здесь описана структура и основные элементы интегрированной среды разработки (ИСР). Поясняются многие термины (форма, свойства, компоненты, методы и др.), которые в дальнейшем используются в других подразделах пособия. При обучении программированию сложилась традиция, в соответствии с которой в качестве первой предлагается программа, выводящая на экран приветствие – строку Hello Word. Не отступая от этой традиции, в главе показано, как, используя технологию визуального программирования, создать первую программу и подробно проанализирован ее код. Также рассмотрены вопросы организации проектов в среде С++ Builder. Изучение данной главы является обязательным для понимания материала, изложенного в других главах учебного пособия.

 

9.1.  Общая характеристика системы программирования

Borland C++ Builder. Основы визуального программирования

 

Система программирования Borland C++ Builder предназначена для быстрой разработки приложений Rapid Application Development (RAD) в среде операционной системы Windows, построенных на современном фундаменте объектно-ориентированного программирования (ООП). Быстрая разработка приложений означает реальное ускорение типичного цикла проектирования программ: кодирование => компоновка => прогон => отладка => редактирование. Эта система позволяет создавать программы  для Windows на языке С++ быстрее и проще, чем это можно сделать с помощью  других систем программирования, например Borland C++ 5.02. Интегрированная среда системы программирования C++ Builder обеспечивает скорость визуальной разработки, продуктивность повторно используемых компонент в сочетании с мощью средств языка C++, усовершенствованными инструментами и разномасштабными средствами доступа к базам данных.

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

– создание пользовательского интерфейса  по способу drag-and-drop (буквально – перетащи и отпусти). Это  позволяет создавать приложение простым перетаскиванием захваченных мышью визуальных компонент из палитры компонент на форму приложения. Инспектор объектов предоставляет возможность оперировать свойствами и событиями компонент, автоматически создавая заготовки функций обработки событий, которые наполняются кодом и редактируются в процессе разработки;

– механизмы двунаправленной разработки (two-way-tools), которые устраняют барьеры между программистом и его кодом. Технология двунаправленной разработки обеспечивает контроль за кодом разрабатываемого приложения посредством гибкого, интегрированного и синхронизированного взаимодействия между инструментами визуального проектирования и редактором кода;

– свойства, методы и события –  элементы языка, обеспечивающие быструю разработку приложений в рамках объектно-ориентированного программирования. Свойства позволяют легко устанавливать разнообразные характеристики объектов. Методы производят определенные, иногда довольно сложные, операции над объектом. События связывают воздействия пользователя на объекты с кодами реакции на эти воздействия. События могут возникать при таких специфических изменениях состояния объектов, как обновление данных в интерфейсных элементах доступа к базам данных. Работая совместно, свойства, методы и события образуют среду быстрого и интуитивного программирования надежных приложений для Windows;

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

– испытание прототипа, которое позволяет без труда переходить от прототипа приложения к полностью функциональному, профессионально оформленному программному продукту в пределах интегрированной среды. Чтобы удостовериться в том, что ваша программа производит ожидаемые результаты, раньше приходилось многократно проходить по циклу редактирование => компиляция => сборка, непроизводительно расходуя время. Сиcтема C++ Builder объединяет три этапа разработки в единый производственный процесс. В результате удается строить приложения, базирующиеся на текущих требованиях заказчика, вместе с тем гибкие настолько, чтобы быстро адаптировать их к новым запросам пользователей;

– мастер инсталляции, руководящий созданием унифицированных дистрибутивных пакетов для разработанных приложений;

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

 – открытые инструменты API. Они могут быть непосредственно интегрированы в визуальную среду системы. Можно также подключить привычный текстовый редактор или создать собственного мастера для автоматизации выполнения повторяющихся процедур;

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

Рассмотрим далее основы визуального программирования.

После загрузки  среды программирования C++ Builder  откроется основное окно интегрированной среды разработки (ИСР) (рис. 9.1).

 

Главное меню                                            Палитра компонентов   библиотеки VCL

Быстрые кнопки

  

Инспектор                                                                       Редактор форм

объектов

 

 

Рис. 9.1. Основное окно интегрированной среды разработки C++ Builder 6

 

Ниже полосы главного меню расположены две инструментальные панели. На левой панели имеется два ряда быстрых кнопок, дублирующих наиболее часто используемые команды меню. Правая панель содержит палитру компонентов библиотеки визуальных компонентов (Visual Component Library, VCL).  Эта палитра включает ряд страниц, закладки которых видны в ее верхней части.

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

Компоненты VCL оформлены как классы объектного языка Паскаль и разделяются на видимые (визуальные) и невидимые (невизуальные). Визуальные компоненты появляются во время выполнения точно так же, как и во время проектирования. Примерами являются кнопки и редактируемые поля. Невизуальные компоненты появляются во время проектирования как пиктограммы на форме. Они никогда не видны во время выполнения, но обладают определенной функциональностью (например, обеспечивают доступ к данным, вызывают стандартные диалоги Windows  и др.).

Каждый компонент C++ Builder имеет три разновидности характеристик: свойства, события и методы.

Слева в основном поле окна  (см. рис.9.1) расположен инспектор объектов (Object Inspector). Он позволяет визуально устанавливать свойства объектов без необходимости рутинного программирования и содержит события, которые можно связывать с кодами реакции объектов на их возникновение. Если выбрать компонент из палитры и добавить его к форме, инспектор объектов автоматически покажет свойства и события, которые могут быть использованы с этим компонентом.

Инспектор объектов имеет страницу свойств (Properties) и страницу событий (Events).

Свойства компонента определяют его внешний вид и поведение, например изменение свойства Color (цвет) приведет к изменению цвета фона данного компонента.

Многие свойства компонента в колонке свойств имеют значение, устанавливаемое по умолчанию (например, высота кнопок, заголовок и цвет фона окна приложения). Свойства компонента отображаются на странице свойств (Properties) инспектора объектов, который отображает опубликованные (published) свойства компонентов. Но помимо published-свойств, компоненты могут и чаще всего имеют общие (public) свойства, которые доступны только во время выполнения приложения.

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

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

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

Страница событий (Events) инспектора объектов показывает список событий, распознаваемых компонентом (отметим, что программирование для операционных систем с графическим пользовательским интерфейсом, в частности для Windows XP или Windows NT, предполагает описание реакции приложения на те или иные события, а сама операционная система занимается постоянным опросом компьютера с целью выявления наступления какого-либо события). Каждый компонент имеет свой собственный набор обработчиков событий. В системе C++ Builder следует писать функции, называемые обработчиками событий, и связывать события с этими функциями. Создавая обработчик того или иного события, программист  поручает программе выполнить написанную функцию, если это событие произойдет.

Для того чтобы добавить обработчик событий, нужно выбрать на форме с помощью мыши компонент, которому необходим обработчик событий, затем открыть страницу событий инспектора объектов и дважды щелкнуть левой клавишей мыши на колонке значений рядом с событием, чтобы заставить C++ Builder сгенерировать прототип обработчика событий и показать его в редакторе кода. При этом автоматически генерируется текст пустой функции, и редактор открывается в том месте, где следует вводить код. Курсор позиционируется внутри операторных скобок { ... }. Далее нужно ввести код, который должен выполняться при наступлении события. Обработчик событий может иметь параметры, которые указываются после имени функции в круглых скобках.

Справа от инспектора объектов расположено окно редактора форм (см. рис. 9.1). Он предназначен для создания интерфейса программы с пользователем. Форма, на которой размещаются компоненты, является основой почти всех приложений среды программирования C++ Builder. Форма может быть главным окном программы, диалоговым окном или окном любого другого типа. Форма имеет те же свойства, которые присущи другим окнам. Форма является контейнером (родителем – Parent) размещенных на ней компонентов. Приложение может иметь как одну, так и несколько форм.

За окном редактора форм скрыто окно редактора кода (Сode Editor), предназначенного для написания текста программы, в частности функций обработки событий. В окно редактора кода вставлена контекстная справка. Чтобы получить справку по какому то слову кода, достаточно установить курсор на это слово и нажать клавишу F1.

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

Метод является функцией, которая связана с компонентом и которая объявляется как часть объекта. Создавая обработчики событий, можно вызывать методы, используя  нотацию –>, например:

 

Button1 –> Show();  

 

Обработка событий в VCL крайне проста. Список событий, на которые реагирует компонент, приведен во вкладке Events окна инспектора объектов и программист не обязан прописывать реакцию на все события, на которые реагирует компонент.

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

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

 

9.1.1. Создание первого приложения

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

 

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

 

Для создания первого приложения выполните следующие шаги:

1. Запустите среду программирования C++ Builder с помощью меню  Пуск, Программы или с помощью ярлыка на рабочем столе.

Откройте новое приложение. Для этого необходимо выполнить команду File | New Application (файл, новое приложение). На экране будет присутствовать пустая форма.

2. Дайте имена файлам создаваемого приложения. Для этого в главном меню выберите пункт File | Save All (файл, сохранить все). Вначале в открывшемся окне Save Unit1 As (Сохранить модуль как) будет запрошено имя исходного файла (с расширением .cpp) главной формы. Введите имя в поле Имя файла, например hello и щелкните на кнопке Сохранить. Затем средой программирования будет запрошено имя файла проекта (с расширением .bpr). Введите имя файла проекта, например mainhello и щелкните на кнопке Сохранить. Необходимые расширения имен исходного файла и файла проекта средой C++ Builder будут добавлены автоматически.

По умолчанию среда программирования присвоит новой форме имя Form1, а соответствующему модулю – Unit1.cpp. Термин Unit переводится как модуль и служит для обозначения исходного файла.

3. Перенесите на пустую форму кнопку типа TButton со страницы Standard палитры компонентов. Для этого выделите пиктограмму кнопки и затем щелкните мышью в нужном вам месте формы. На форме появится кнопка, которой C++ Builder присвоит имя по умолчанию - Button1.

 

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

 

4. Аналогичным образом перенесите на форму с той же страницы Standard палитры компонентов метку Label. В этом компоненте в процессе выполнения приложения будет появляться текст при нажатии пользователем кнопки. Среда C++ Builder  присвоит метке имя Label1.

5. Присвойте заголовок окну вашего приложения. Для этого перейдите в окно инспектора объектов и измените  свойство Caption (надпись) формы. По умолчанию это свойство имеет значение Form1. Присвойте этому свойству какое-либо значение например, Первое приложение.

6. Разместите компоненты на форме примерно так, как показано на рис. 9.2. При этом с помощью мыши  уменьшите окно формы до разумных размеров, так как в нашем первом приложении никаких других компонентов не будет.

7. Выделите на форме компонент Button1 (кнопку). Перейдите в окно инспектора объектов и измените свойство кнопки Caption, равное по умолчанию значению Buttton1 на Пуск.

 

 

Рис. 9.2. Форма в процессе проектирования приложения

 

8. Укажите метке Label1, что надписи на ней надо делать жирным шрифтом. Для этого выделите метку, в окне инспектора объектов раскройте двойным щелчком свойство Font (шрифт), затем также двойным щелчком раскройте подсвойство Style (стиль) и установите в значение true свойство fsBold  (жирный).

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

Теперь вам осталось написать оператор, который заносил бы в свойство Caption метки Label1 нужный вам текст в нужный момент. Этот момент определяется щелчком пользователя на кнопке. При щелчке в кнопке генерируется событие OnClick. Следовательно, обработчик этого события следует написать.

10. Выделите кнопку Button1 на форме, перейдите в окно инспектора объектов, откройте в нем страницу событий Events, найдите событие кнопки OnClick (оно первое сверху) и сделайте двойной щелчок в окне справа от имени этого события. Это стандартный способ задания обработчиков любых событий. Но перейти в обработчик события OnClick можно и иначе: достаточно сделать двойной щелчок на компоненте Button1 на форме. В обоих случаях вы окажетесь в окне редактора кода и увидите там текст

 

void  __fastcall TForm :: Button1Click (TObject  *Sender)

{

}    

 

Заголовок этой функции складывается из имени класса  формы (TForm1), имени компонента (Button1) и имени события без префикса On (Click). Передаваемый в любую функцию – обработчик события параметр Sender – это указатель на источник события, он подробно рассмотрен в п. 10.3.2 пособия.

11. Напишите в обработчике оператор задания надписи метки Label1. Этот оператор может иметь вид

 

Label1-> Caption = "Это мое первое приложение";

 

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

 

void __fastcall TForm1 : : Button1Click (TObject *Sender)

{            

Label1–> Caption = "Это мое первое приложение";

} 

 

Оператор, составляющий тело функции – обработчика событий, означает следующее: Label1–> Caption – обращение к  свойству Caption компонента Label1. Все указания свойств и методов производятся аналогичным образом: пишется имя компонента, затем ставятся символы операции стрелка  –> (символ минус – и символ больше  >, записанные без пробела. После этих символов пишется имя свойства или метода. В данном случае свойству Caption вы присваиваете строку текста Это мое первое приложение.

Если вы написали первый идентификатор оператора Label1, поставили символы стрелки и ненадолго задумались, то  всплывет подсказка, содержащая список всех свойств и методов метки. Это начал работать знаток кода (Code Insight), который стремится подсказать программисту свойства и методы компонентов, аргументы функций и их типы, конструкции операторов. Вы можете выбрать из списка нужное ключевое слово, нажать клавишу Enter и выбранное слово (свойство, метод) окажется вписанным в текст. Можно поступить иначе, начав писать нужное свойство. Тогда знаток кода по первым введенным символам сам найдет нужное свойство. Когда вы увидели, что нужное слово найдено, то можете его не дописывать, а нажать клавишу Enter, и знаток кода допишет его за вас. Этот инструмент очень удобен в тех случаях, когда вы не точно помните последовательность перечисления параметров какой-нибудь функции или не уверены в имени какого-то свойства (особенно в том, какие буквы этого слова  и в каком регистре надо писать).

Итак, первое приложение готово. Теперь сохраните внесенные в него изменения, выполнив команду File Save All, откомпилируйте и запустите приложение. Для этого выполните команду Run | Run, или нажмите соответствующую быструю кнопку на панели быстрых кнопок, или нажмите «горячую» клавишу F9. Если вы сделали все правильно, то после недолгой компиляции, сопровождающейся временным появлением на экране окна компилятора, перед вами появится окно вашего первого приложения      (рис 9.3). Нажав в нем кнопку Пуск, вы увидите указанную вами строку текста.

 

 

Рис. 9.3. Окно первого приложения

 

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

 

9.1.2. Анализ кода созданного приложения

Код созданного в п. 9.1.1 приложения содержится в трех файлах: головном файле проекта, заголовочном файле формы и исходном файле формы.

В процессе проектирования приложения средой программирования С++ Builder были автоматически созданы исходные коды головного файла проекта и файла формы. В исходный файл формы программист вводит  свой код, создавая обработчик события - щелчок на кнопке. А головной файл  проекта, как правило, нет необходимости изменять. Только в редких случаях вам надо что-то изменять в тексте головной программы, сгенерированном С++ Builder.

Головной файл проекта – это файл  с  расширением .cpp. Он содержит главную функцию WinMain, с которой начинается выполнение программы. Чтобы увидеть код головного файла программы, выполните команду  View | Units и выбрав в выпадающем окне файл, имеющий то же имя, что и проект и расширение .cpp (в нашем примере это файл с именем mainhello.cpp). В окне редактора кода вы увидите текст, приведенный в листинге 9.1 (без включенных в него комментариев на русском языке).

 

Листинг 9.1. Текст головного файла программы

// ---------------------------------------------------------------------------

// директивы препроцессора

#include <vcl.h>

#pragma hdrstop

 

// макросы, подключающие файлы ресурсов и форм

USERES("mainhello.res");

USEFORM("hello.cpp", Form1);

// главная функция

//---------------------------------------------------------------------------

WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int)

{    try

    {

// инициализация объектов компонентов данного приложения

        Application –> Initialize();

// Создание объекта формы

        Application –> CreateForm(__classid(TForm1), &Form1);

// запуск приложения и  цикла ожидания сообщений

        Application –> Run();

    }

    catch (Exception &exception)

{ // вызов  функции – стандартного обработчика исключений

        Application –> ShowException(&exception);

    }

// завершение приложения с кодом 0

    return 0;

}

 

Начинается файл головного модуля с  директивы препроцессора #include <vcl.h>, подключающей  заголовочный файл vcl.h, содержащий объявления, используемые в библиотеке визуальных компонентов среды программирования C++ Builder. После директив препроцессора в файле размещены предложения USERES и USEFORM, содержащие имена файлов ресурсов проекта и реализации модуля, автоматически создаваемые средой программирование. Назначение этих файлов поясняется в п.9.2.1.

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

 

WINAPI WinMain (HINSTANCE, HINSTANCE, LPSTR S, int)

 

Этот заголовок объявляет строку S, в которой будет содержаться текст командной строки.

После заголовка функции следует ее тело, заключенное в фигурные скобки. Первый выполняемый оператор тела функции – Application            –> Initialize() – инициализирует объекты компонентов данного приложения. Следующий оператор - Application –> CreateForm – создает объект формы. Последний оператор – Application –> Run() начинает собственно выполнение программы. После этого оператора программа ждет соответствующих событий, которые и управляют ее ходом.

Перечисленные операторы тела функции WinMain заключены в блок try, после которого следует блок catch. По умолчанию в этом блоке расположен стандартный обработчик исключений с помощью функции Application –> ShowException.

Все описанные выше операторы головного файла приложения автоматически заносятся в него в процессе проектирования приложения. Например, при добавлении в проект новой формы происходит автоматическая вставка в файл соответствующего предложения USEFORM и оператора Application –> CreateForm, создающего форму. Как правило, программисту ничего в головном файле изменять не надо.

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

Конечно, вы можете ввести в головной файл программы какие-то операторы, функции и т. п., но это будет плохой стиль программирования, поскольку он противоречит принципу модульности. Все необходимые вам в начале выполнения процедуры и функции настройки помещайте в один из модулей форм, а еще лучше – в отдельный модуль без формы. Такой модуль, не связанный с какой-то формой, можно включить в приложение, выполнив в среде разработки C++ Builder команду File | New и щелкнув на пиктограмме Unit. В этом или другом модуле вы можете предусмотреть функцию, которая осуществляет все необходимые настройки. Тогда в головной программе достаточно будет вызвать в соответствующий момент эту функцию, передав в нее, если необходимо, какие-либо параметры, например текст командной строки.

 

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

 

Следует учесть, что все определенные вами в головном файле проекта глобальные  константы и переменные будут доступны в другом блоке только в том случае, если они объявлены там со спецификацией extern.  А функции, определенные вами в головном файле проекта, станут доступными в другом блоке только в случае если там повторен их прототип.

 

1.1.3. Структура файла модуля формы

 

Рассмотрим теперь, как выглядят тексты модулей форм. Каждый такой модуль состоит из двух файлов: заголовочного, содержащего описание класса формы, и файла, содержащего исходный код. Файл исходного кода формы, с которой вы работаете, находится в окне редактора кода, расположенного за формой. Чтобы увидеть окно редактора кода, сверните окно формы. А чтобы загрузить в редактор кода заголовочный файл этого модуля, следует, находясь в файле реализации модуля, щелкнуть правой кнопкой мыши и выбрать из всплывшего меню команду Open Source / Header File.

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

 

Листинг 9.2. Заголовочный файл hello.h

//---------------------------------------------------------------------------

#ifndef helloH

#define helloH

//---------------------------------------------------------------------------

#include <Classes.hpp>

#include <Controls.hpp>

#include <StdCtrls.hpp>

#include <Forms.hpp>

//---------------------------------------------------------------------------

// сюда могут помещаться дополнительные директивы

// препроцессора (в частности, include), не включаемые в файл автоматически

//---------------------------------------------------------------------------

// объявление класса формы TForm1 как производного

// от базового  библиотечного класса TForm

class TForm1 : public TForm

{  _published:

// объявление указателей на размещенные на форме компоненты: кнопку и метку

TButton  *Buttonl;

TLabel  *Label1;

// прототипы функций – обработчиков событий

void _fastcall ButtonlClick (TObject *Sender);

 

private:   // спецификатор доступа – «собственный» (закрытый раздел класса)

// сюда могут помещаться объявления типов, переменных,

// функций, включаемых в класс формы, но не доступных для других модулей

public:    // спецификатор доступа – «общедоступный» (открытый раздел класса)

// сюда могут помещаться объявления типов, переменных,

// функций, включаемых в класс формы и доступных для других модулей

// объявление конструктора формы

__fastcall  TForm1 (TComponent  *Owner);

};

 

//——————————————————————

extern PACKAGE TForm1 *Forml;

//————————————————————————

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

// которые не включаются в класс формы;

// доступ к ним из других блоков возможен только при

// соблюдении некоторых дополнительных условий

 #endif

 

Листинг 9.3. Файл реализации

//———————————————————

#include <vcl.h>

#pragma hdrstop

#include "hello.h"

//————————————————————————

#pragma package(smart init)

#pragma resource "*.dfm"

// сюда могут помещаться дополнительные директивы

// препроцессора (в частности, include),  не включаемые в файл автоматически

// объявление объекта формы Form1

TForm1    *Form1;

//————————————————————————

// определение  конструктора формы Form1

__fastcall TForm1 :: TForm1(TComponent  *Owner) : TForm(Owner)

{

// сюда можно поместить операторы,

// которые должны выполняться при создании формы

}

//————————————————————————

// сюда могут помещаться объявления типов и переменных,

// доступ к которым из других модулей возможен только при соблюдении

// некоторых дополнительных условий; тут же должны быть реализации всех

// функций, объявленных в заголовочном файле, также могут быть

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

// определение функции – обработчика события – щелчка по кнопке

void  __fastcall  TForm1 :: ButtonlClick (TObject *Sender)

{

// изменение значения свойства Caption компонента Label1 в процессе

// работы приложения

Labell –> Caption = "Это мое первое приложение";

}

//————————————————————————

 

Рассмотрим эти файлы подробнее. Заголовочный файл начинается с включенных в него автоматически директив препроцессора. В частности, система C++ Builder сама помещает туда директивы include, подключающие копии файлов, в которых описаны те компоненты, переменные, константы, функции, которые вы используете в данном модуле. Однако для некоторых функций такое автоматическое подключение не производится. В этих случаях разработчик должен добавить соответствующие директивы include вручную.

После директив препроцессора следует описание класса формы. Имя класса вашей формы – TForm1. Класс содержит три раздела:

 – _published – открытый раздел, содержащий объявления размещенных на форме компонентов и обработчиков событий в них; private – закрытый раздел класса; public – открытый раздел класса. В данном случае в разделе _published вы можете видеть объявления указателей на два компонента: компонент Button1 типа TButton и компонент Label1 типа ТLabel. Там же вы увидите объявление функции Button1Click – введенного пользователем обработчика события щелчка на кнопке Button1. Все, что имеется в разделе _published, С++ Builder автоматически включает в него в процессе проектирования вами формы, так что вам, как правило, не приходится работать с этим разделом. А в разделы private и public вы можете добавлять свои объявления типов, переменных, функций. То, что вы или С++ Builder объявите в разделе public, будет доступно для других классов и модулей, но то, что объявлено в разделе private, будет доступно только в пределах данного модуля. Как вы можете видеть, единственное, что система С++ Builder самостоятельно включила в раздел public, –  это объявление (прототип) конструктора вашей формы ТForm1.

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

Теперь рассмотрим текст файла реализации модуля. После автоматически включенных в этот файл директив препроцессора следует тоже автоматически включенное объявление указателя на объект формы Form1, а затем – вызов конструктора формы. Тело соответствующей функции пустое, но вы можете включить в него какие-то операторы. После этого размещаются описания всех функций, объявленных в заголовочном файле. Вы можете также размещать здесь объявления любых типов, констант, переменных, не объявленных в заголовочном файле, и описания любых функций, не упомянутых в заголовочном файле. Служебное слово (модификатор) __fastcall  в определениях функций означает быстрый вызов функций.

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

 

<возвращаемый тип> __fastcall  <name>(<список параметров>

 

Это ключевое слово определяет, что первые три типизированных параметра функции с именем name (слева направо по списку) передаются не через стек, а через процессорные регистры AX, BX и DX. Регистры не используются, если значение параметра не умещается в регистр, т. е. при передаче через параметр чисел с плавающей точкой, структур и функций.

Имена файлам модулей С++ Builder дает по умолчанию: для первого модуля имя равно Unit1, для второго Unit2 – и т. д.

 

Примечание. Если в вашем приложении несколько модулей, сохраняйте их файлы под какими-то осмысленными именами, изменяя тем самым имена модулей, заданные С++ Builder по умолчанию, так как работать с осмысленными именами, а не с именами Unit1, Unit2, Unit3, которые ни о чем не говорят, проще.

 

Таким образом, системой С++ Builder были автоматически созданы файлы вашей программы и сформированы многие операторы. Кроме того, среда С++ Builder включила в вашу программу множество модулей, содержащих коды всех использованных компонентов и самой формы. А ваш вклад в данном случае ограничился написанием всего одного оператора. В этом и проявляется удобство и сила визуального программирования.

 

9.1.4. Основные свойства формы

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

Система программирования С++ Builder автоматически обеспечивает стандартный для Windows вид окон приложения. Программисту при проектировании  приложения необходимо указать, какие кнопки в полосе системного меню должны быть доступны в том или ином окне, должно ли окно допускать изменение пользователем его размеров, каким должен быть заголовок окна. Эти характеристики окон обеспечиваются установкой и управлением свойствами формы. Рассмотрим далее  наиболее часто используемые свойства форм Caption, Icon, BorderStyle.

Свойство Caption определяет заголовок окна приложения. По умолчанию значение этого свойства системой С++ Builder устанавливается равным имени объекта формы например, Form1.

Свойство Icon  определяет значок, который будет использоваться в строке заголовка формы при выполнении программы, а также для свернутой формы. В отдельных случаях значение этого свойства игнорируется, например когда свойство BorderStyle имеет значение bsDialog. Чтобы установить значение этого свойства, найдите его в окне инспектора объектов, щелкните мышкой по кнопке рядом с ним и в открывшемся окне Picture Editor с помощью кнопки Load выберите имя файла значка.

Для прикрепления иконки к окну приложения выполните команду Project | Options и в открывшемся окне опций проекта (рис. 9.4) перейдите на страницу Application. 

 

В этом окне можно задать заголовок (Title), который увидит пользователь в полосе задач при сворачивании приложения. Кнопка Load Icon позволит выбрать пиктограмму, которая будет видна в полосе задач при сворачивании приложения или при просмотре пользователем каталога, в котором расположен выполняемый файл приложения.

                    

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Рис.9.4. Страница Application окна опций проекта

 

Примечание. Со средой С++ Builder  поставляется ряд иконок, которые можно найти в папке, путь к которой имеет вид C:\Program Files\Common Files\Borland Shared\Images\Icons.

 

Свойство BorderStyle определяет общий вид окна и операции с ним, которые разрешается выполнять пользователю (табл.9.1). По умолчанию это свойство имеет значение bsSizeable, что означает, что среда С++ Builder создает обычное окно Windows, имеющее полосу заголовка, кнопку системного меню и три стандартные кнопки управления окном справа. Кроме того, можно изменять размеры такого окна, как с помощью мыши, так и с помощью клавиатуры.

 

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

Таблица 9.1

Значения свойства BorderStyle

 

Значение	Вид окна
bsSizeable	Обычный вид окна с возможностью изменять размеры окна с помощью кнопок или с помощью мыши. Задается по умолчанию
bsDialog	Неизменяемое по размерам окно. Типичное окно диалогов
bsSingle	Окно, размер которого пользователь не может изменить, потянув курсором мыши за край окна, но может менять кнопками в полосе заголовка.
bsToolWindow	То же, что и bsSingle, но с полосой заголовка меньшего размера
bsSizeToolWin	То же, что и bsSizeable, но с полосой заголовка меньшего размера и с отсутствием в ней кнопок изменения размера
bsNone	Без полосы заголовка. Окно не только не допускает изменения размера, но и не позволяет переместить его по экрану

 

 

Таким образом, система C++ Builder представляет собой совершенную интерактивную среду программирования на языке С++. Визуальная разработка приложений, поддерживаемая в этой системе, упрощает и ускоряет трудоемкий процесс программирования приложений.

Библиотека визуальных компонентов VCL предоставляет в распоряжение разработчика компоненты, которые инкапсулируют все элементы пользовательского интерфейса операционной системы Windows. Компоненты библиотеки из палитры компонентов размещаются в окне приложения с помощью мыши простым перетаскиванием. Свойства компонент, используемых в приложении, программист может устанавливать как в процессе проектирования с помощью инспектора объектов, встроенного в ИСР, так и в процессе работы приложения. С каждым компонентом связана серия событий, определяющих его реакцию на различные воздействия.

Инспектор объектов обеспечивает доступ к свойствам компонент библиотеки VCL и автоматически создает заготовки функций обработки событий, связывающих воздействия пользователя на интерфейсные объекты приложения с кодами реакций на эти воздействия. Значительная часть кода приложения создается самой средой, работа программиста сводится в основном только к написанию кода обработчиков событий. Встроенный в ИСР редактор кода обеспечивает контроль создаваемого кода. При разработке приложения среда C++ Builder обеспечивает возможность его многократного испытания и тестирования, что позволяет создавать надежные и отлаженные программные продукты.

 

Контрольные вопросы и задания

 

1. Что означает быстрая разработка приложений?

2. За счет чего в среде C++ Builder реализована концепция визуального программирования?

3. Что такое компоненты, методы и события?

4. Все ли компоненты видимы во время разработки и выполнения программы?

5. Что является основным элементом любого приложения?

6. Как выполнить размещение нового компонента на форме?

7. Каким образом можно изменять свойства размещенного на форме компонента?

8. Как в программе следует организовать реакцию на события, определенные для компонента?

9. Что означает модификатор __fastcall в определении функции – обработчика события?

10. Как задать заголовок окна приложения?

12. Объясните последовательность создания нового проекта в  С++ Builder.

13. С какой функции начинается выполнение программы? Какие действия выполняет эта функция?

14. Перечислите основные свойства формы.

15. Как выполнить изменение стиля главного окна создаваемого приложения?

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

17. Как прикрепить иконку к приложению?

18. Создайте приложение, выполнив действия, указанные в п.9.1.1 и внесите  в созданное приложение следующие изменения:

– разместите на форме вторую метку и вторую кнопку. Напишите код, позволяющий при нажатии на вторую кнопку выводить во вторую метку текст Привет всем!

– текст, выводимый в окно должен  отображаться красным шрифтом размером 14 пунктов, жирный;

– установите цвет фона окна зеленым;

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

– прикрепите иконку к окну приложения;

– измените иконку, которая будет появляться рядом с именем загрузочного файла приложения;

– измените заголовок окна;

– разместите в окне приложения еще одну, третью кнопку. Разместите на ней надпись Выход, а в обработчик щелчка по не поместите оператор Close(), позволяющий выполнять закрытие приложения;

–       измените свойство BorderStyle формы на значение bsSingle;

–                    задать заголовок, который увидит пользователь в полосе задач при сворачивании приложения, как показано на рис. 9.4.

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

– измените свойство BorderStyle формы на значение bsDialog, вновь откомпилируйте приложение. Отображается ли теперь в окне приложения прикрепленная вами иконка?

измените свойство BorderStyle формы на значение bsNone и вновь откомпилируйте приложение. Отображаются ли теперь в окне приложения кнопки управления окном? Как закрыть это окно?

 

9.2. Проекты системы borland c++ builder

 

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

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

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

 

9.2.1. Основные файлы проектов

 

Файлы, создаваемые системой C++ Builder в процессе проектирования приложения, показаны в табл.9.2.

Таблица  9.2

Файлы, автоматически создаваемые средой программирования

Borland C++ Builder

 

Файл	Значение
Головной файл проекта (.срр)	Система  C++Builder создает файл .срр для головной функции WinMain, инициирующей приложение и запускающей его на выполнение. С эти файлом программисту практически не приходится работать.
Файл опций проекта (.bpr)	Этот текстовый файл содержит установки опций проекта и указания на то, какие файлы должны компилироваться и компоноваться в проект. Файл сохраняется в формате ХМL
Файл ресурсов проекта (.res)	Двоичный файл, содержащий ресурсы проекта :пиктограммы, курсоры и т. п. По умолчанию содержит только пиктограмму проекта. Может дополняться с помощью редактора изображений (Image Editor)
Файл реализации модуля (.срр)	Каждой создаваемой  форме соответствует текстовый файл реализации модуля, используемый для хранения кода. Иногда можно создавать модули, не связанные с формами
Заголовочный файл модуля (.h)	Каждой создаваемой форме соответствует не только файл реализации модуля, но и его заголовочный файл с описанием класса формы
Файл формы (.dfm)	Это двоичный или текстовый файл, который среда C++Builder создает для хранения информации о ваших формах. Вы можете смотреть этот файл в текстовом виде или в виде формы. Каждому файлу формы соответствует файл модуля (.срр)
Заголовочный файл компонента (.hрр)	Файл создается при создании  нового компонента. Вам также часто будет необходимо подключать к проекту эти файлы из библиотеки ком­понентов С++ Builder, расположенные в каталоге Include\VCL
Файл группы проектов (.bpg)	Текстовый файл для группы проектов
Файлы пакетов (.bpl и .bрk)	Эти двоичные файлы используются С++ Builder при работе с пакетами: .bpl – файл самого проекта; .bрk – файл, определяющий компиляцию и компоновку пакета
Файл рабочего стола проекта (.dsk)	В этом текстовом файле С++ Builder хранит информацию о последнем сеансе работы с проектом: открытых окнах, их размерах и положении. Благодаря этому файлу в новом сеансе вы сразу видите тот же экран, который был в предыдущем сеансе. Файл создается только в том случае, если вы включили опцию Autosave options / Project desktop
Окончание табл. 9.2
Файл	Значение
Файлы резервных копий (.~bр, .~df, .~ср, .~h)	Это соответственно файлы резервных копий для файлов проекта, формы, реализации модуля и заголовочного файла . Если вы что-то совсем испортили в своем проекте, то можно изменить расширения этих файлов и таким образом вернуться к предыдущему неиспорченному варианту

 

Помимо этих файлов существуют и другие файлы, которые создаются компилятором и средой С++ Builder. Они показаны в табл. 9.3. и 9.4.

 

Таблица 9.3.

Группа файлов, создаваемых компилятором

 

Файл	Значение
файл  (.еxе)	Это исполняемый файл приложения. Он является автономным исполняемым файлом, для которого больше ничего не требуется, если только вы не используете библиотеки, содержащиеся в пакетах DLL, OCX и т. д.
Объектный файл модуля (.obj)	Это откомпилированный файл модуля (.срр), который компонуется в окончательный исполняемый файл.
Динамически присоединяемая библиотека (.dll)	Этот файл создается в случае, если вы проектируете свою собственную d11
Файл таблицы символов (.tds)	Двоичный файл, используемый отладчиком в процессе отладки приложения
Файлы выборочной компоновки (.il)	Файлы с расширением, начинающимся с  (.ilc, .ild, .ilf, .ils), позволяют повторно компо­новать только те файлы, которые были изменены после последнего сеанса

 

Таблица 9.4

Другие файлы, создаваемые средой С++ Builder

 

Файл	Значение
Файлы справки (.hlр)	Это стандартные файлы справки которые могут быть использованы приложением С++Builder.
Файлы изображений или графические файлы (.wmf, .bmp, .ico)	Эти файлы обычно используются в приложениях Windows для создания привлекательного и дружественного пользовательского интерфейса.

 

Из всех перечисленных файлов важнейшими являются .срр, .h, .dfm, .bpr, .res. Это те файлы, которые вы должны перенести на другой компьютер, если захотите продолжить на нем работу над своим проектом. Все остальные файлы С++ Builder создаст автоматически в процессе компиляции проекта и его отладки.

Главной частью приложения является головной файл .срр с функцией WinMain(), которая начинает выполнение программы и которая обеспечивает инициализацию других модулей. В большинстве случаев вы можете создать законченное приложение С++ Builder, даже не взглянув на этот файл. Он создается и модифицируется С++ Builder автоматически в процессе разработки приложения. Имя, которое вы даете файлу проекта, когда сохраняете его, становится именем исполняемого файла.

Все изменения файла проекта при добавлении новых форм, изменении имен форм и т. п. поддерживаются С++ Builder автоматически. Если необходимо посмотреть исходный файл проекта, то нужно выполнить команду View | Project Source.

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

Информация о формах системы С++ Builder хранится в трех файлах: .dfm, .срр и .h. В двоичном или текстовом файле с расширением .dfm хранится информация о внешнем виде формы, ее размерах, местоположении на экране и т. д. Щелкнув на форме правой кнопкой мыши, вы можете выбрать из контекстного меню раздел View as Text и увидеть в окне редакторе кода файл .dfm в текстовом виде, а также можете что-то изменить в этом файле. Щелкнув правой кнопкой мыши в окне редактора кода на файле .dfm, вы можете выбрать в контекстном меню раздел View as Form и опять увидеть файл в виде формы.

Основной файл, с которым вы работаете, – это файл реализации модуля .срр, в котором хранится код, соответствующий данной форме. В текстовом заголовочном файле с расширением .h хранится объявление класса вашей формы. Весь основной текст этого файла С++ Вuilder формирует автоматически по мере проектирования вами формы. Но иногда может потребоваться вводить в этот файл объявления каких-то своих функций, типов, переменных вручную. Для этого вы можете загрузить этот файл в окно редактора кода, щелкнув в его окне с файлом реализации модуля .срр правой кнопкой мыши и выбрав из всплывшего меню команду Ореn Sourse / Header File. Имена всех трех файлов, описывающих модуль, одинаковы. Вы задаете это имя, когда в первый раз сохраняете ваш модуль.

Вы также можете создавать модули, не привязанные к конкретным формам. Например, в большом приложении полезно иметь модуль (заголовочный файл и файл реализации), содержащий константы, переменные, функции, используемые в различных модулях. Наличие такого модуля позволяет сократить число взаимных ссылок различных модулей. К тому же подобный модуль может использоваться в других ваших проектах. Чтобы создать в проекте новый модуль, не связанный с какой-либо формой, нужно выполнить команду File | New и в открывшемся окне New Items на странице New щелкнуть на пиктограмме Unit.

 

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

 

Если вы поочередно работаете над многими проектами, то пространство на диске может неэффективно использоваться из-за ненужных файлов. В этом случае полезно удалять вспомогательные файлы тех проектов, над которыми вы временно не работаете. Прежде всего это относится к файлам .obj, res, .tds, .il?, .~*. Особо обратите внимание на файлы .tds, объем которых может быть очень большим (он может достигать нескольких мегабайт).

 

9.2.2. Организация каталогов проекта, создание  и сохранение

нового проекта

При организации нового проекта следует взять за правило отводить для каждого нового проекта новый каталог (папку Windows). Этот совет связан с тем, что если помещать несколько проектов в один каталог, то и вы, и, возможно, С++ Вuilder скоро запутаетесь в том, какие файлы к какому проекту относятся. Размещение разных проектов в разных каталогах избавит вас в дальнейшем от многих неприятностей.

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

Начать новый проект можно несколькими способами. Один из этих способов уже рассматривался ранее, в п.9.1.1 – это  команда File | New Application. Можно сделать то же самое и с использованием быстрой кнопки New на панели быстрых кнопок. При нажатии этой кнопки открывается окно New Items (новые элементы) (рис. 9.5).

Это окно является витриной депозитария объектов (Оbject Repository) – хранилища образцов компонентов, форм и проектов. Вы можете и сами создавать свои формы, компоненты, проекты и включать их в депозитарий. В нашем случае мы хотим открыть новый проект. Это можно сделать, щелкнув на пиктограмме Аррlication (приложение), расположенной на странице New (новый). Пиктограмма Аррlication создает приложение с пустой формой.

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

Хороший стиль программирования. После создания  приложения с пустой формой его необходимо сразу сохранить его в нужном каталоге. В течение работы над проектом следует его почаще сохранять.

 

 

Рис.9.5. Страница New окна Депозитария New Items

 

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

 

Хороший стиль программирования. Всегда сохраняйте проект под каким-то осмысленным именем, изменяя тем  самым имя проекта, заданное С++ Вuilder по умолчанию. Иначе очень скоро вы запутаетесь в бесконечных программах Рrоjесt1, лежащих в ваших различных каталогах. К тому же учтите, что имя файла проекта будет в дальнейшем именем вашего выполняемого модуля. Отметим еще, что  не очень хорошо будет отдавать заказчику проект с таким странным названием, как Рrоjеct1.

Сохранить проект можно командой File | Save All. Удобно также  использовать соответствующую быструю кнопку. При первом сохранении С++ Вuilder спросит у вас имя файла сохраняемого модуля а затем – имя файла проекта. Следует иметь в виду, что С++ Вuilder не допускает одинаковых имен модулей и проектов. Это естественно, поскольку файлы модуля и головной файл проекта имеют одинаковое расширение .срр и, значит, должны различаться именами.

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

Почему же все-таки не стоит соглашаться при сохранении с именами, предлагаемыми С++ Вuilder по умолчанию: – Unit1, Unit2 и т. п.? Имя файла модуля будет и именем самого модуля, и именем его заголовочного файла. В проекте с одним модулем имя Unit1, возможно, не так и страшно. Но если у вас в проекте будет несколько модулей, то вряд ли будет удобно все время помнить, что такое Unit1, а что такое Unit5. Кроме того, представьте себе, что вы на некоторое время прекратили работу над своими проектами, а потом опять ее возобновили, или сопровождение ваших проектов осуществляется не вами, а кем-то другим.  Будете ли вы уверены в том, что вам легко разберетесь в многочисленных Рroject1 и Unit1 непонятного назначения?

Хороший стиль программирования. При разработке простых прототипов проектов удобно задавать имена файлов проектов и модулей одинаковыми, различая их только префиксами Р или U соответственно, например, файл проекта будет РЕditor1, файл модуля — UЕditor1. Это упрощает понимание того, какие файлы к какому варианту проекта относятся, поскольку на начальных стадиях проектирования у вас может появиться несколько альтернативных вариантов одного и того же проекта.

Итак, рекомендации по созданию нового проекта сводятся к следующему:

– создайте новый каталог для своего нового проекта;

– создайте новый проект командой File | New Application;

– сразу сохраните проект и файл модуля командой File | Save All

– при сохранении файлов давайте им свои имена, а не те, что присвоены средой С++ Вuilder по умолчанию. Не используйте одинаковые имена файлов в проекте.

В последующих сеансах работы вы можете открыть сохраненный проект командой File | Open Project. Но если вы работали с проектом недавно, то намного удобнее открыть его командой File | Reopen.

Имеется еще более удобный способ автоматически открывать при загрузке С++ Вuilder тот проект, с которым вы работали в предыдущем сеансе. Для того чтобы обеспечить себе такую возможность, надо выполнить команду Тооls | Environment Options. В открывшемся многостраничном диалоговом окне следует перейти на страницу Preferences и включить индикатор Рrоjесt Desktop группы опций автосохранения Autosave Options. Тогда при каждом очередном запуске С++ Вuilder будет загружаться ваше последнее приложение предыдущего сеанса и откроются все окна, которые были открыты в момент предыдущего выхода из С++ Вuilder.

Вы можете сохранить свой проект в депозитарии объектов. Впоследствии при появлении схожей задачи вы можете заимствовать его оттуда, что-то в нем изменить и таким образом сэкономить себе много времени. Если вы хотите включить в депозитарий открытый в данный момент проект, выполните команду Рrоjесt | Add То Repository.

 

 

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

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

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

 

Контрольные вопросы и задания

 

1. Что такое проект системы C++ Builder?

2. Перечислите способы, с помощью которых можно создать новый проект.

2. Как следует организовать каталоги проекта?

3. Какие файлы проекта  создаются системой C++ Builder в процессе проектирования приложения?

4. Как выполнить сохранение файлов проекта приложения? Можно ли давать одинаковые имена всем файлам проекта?

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

6. Какое имя система C++ Builder присваивает загрузочному файлу приложения?

Какая команда позволяет увидеть текст исходного файла проекта?

7. Как называется главная функция, с которой начинается выполнение программы? В каком файле она находится?

8. В каком файле находится определение класса формы? Как можно просмотреть содержимое этого файла?

9. В каком файле находятся функции – обработчики событий?

10. Какие файлы, созданные средой C++ Builder, можно удалить после разработки приложения?

11. Как можно просмотреть файл формы .dfm в текстовом виде?

Как можно быстро перейти от просмотра формы к просмотру файла реализации модуля?

12. Как открыть существующий проект?

13. Как сделать так, чтобы при загрузке C++ Builder автоматически открывался ваш последний проект?

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

 

9.3. Интегрированная среда разработки системы

Borland C++ Builder

 

Интегрированная среда разработки (ИСР) – это среда, в которой есть все необходимое для проектирования, запуска и тестирования приложений и где все нацелено на облегчение процесса создания программ. ИСР интегрирует в себе редактора кодов, отладчика, инструментальные панели, редактора изображений, инструментарий баз данных, т. е. все, с чем приходится работать программисту. Эта интеграция предоставляет разработчику гармоничный набор инструментов, дополняющих друг друга. Более того, программист имеет  возможность расширять меню интегрированной среды разработки, включая в него необходимые дополнительные программы, в том числе и собственные. Результатом является удобная среда быстрой разработки сложных прикладных программ.

Рассмотрим далее основные элементы ИСР С++ Вuildеr. Читая этот материал, полезно запустить систему С++ Вui1dеr, увидеть обсуждаемые элементы среды и поэкспериментировать с ними.

 

9.3.1. Главное и всплывающие меню

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

Разделы меню File (файл) позволяют создать новый проект, новую форму, открыть ранее созданный проект или форму, сохранить проекты или формы в файлах с заданными именами.

Разделы меню Edit (правка, редактирование) позволяют выполнять обычные для приложений Windows операции обмена с буфером Clipboard, а также дают возможность выравнивать группы размещенных на форме компонентов по размерам и местоположению.

Разделы меню Search (поиск) позволяют осуществлять поиск и контекстные замены в коде приложения, которые свойственны большинству известных текстовых редакторов.

Разделы меню View (просмотр) позволяют вызывать на экран различные окна, необходимые для проектирования.

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

Меню Run (выполнение) дает возможность выполнять проект в нормальном или отладочном режимах, продвигаясь по шагам, останавливаясь в указанных точках кода, просматривая значе­ния переменных и т. д.

Меню Component (компонент) позволяет создавать и устанавливать новые компоненты, конфигурировать палитру компонентов, работать с пакетами.

Разделы меню Database (база данных) позволяют использовать инструментарий для работы с базами данных.

Меню Тооls (инструментарий) включает ряд разделов, позволяющих настраивать ИСР и выполнять различные вспомогательные программы, например вызывать редактор изображений (Image Editor), работать с программами, конфигурирующими базы данных и т. д. Кроме того, в это меню вы сами можете включить любые разделы, вызывающие те или иные приложения, и таким образом расширить возможности главного меню C++Builder, приспособив его для своих задач.

Меню Неlр (справка) содержит разделы, помогающие работать со встроенной в C++ Builder справочной системой.

Помимо главного меню, в C++ Builder имеется система контекстных всплывающих меню которые появляются, если пользователь поместил курсор мыши в том или ином окне или на том или ином компоненте и щелкнул правой кнопкой мыши. Большинство разделов этих контекстных меню дублируют основные разделы главного меню. Однако во всплывающих меню в ряде случаев имеются разделы, отсутствующие в главном меню. И, кроме того, до многих инструментов, используемых для работы с некоторыми компонентами, можно добраться только через всплывающие меню. Работа с правой кнопкой мыши  позволит ускорить выполнение многих проектных операций.

 

9.3.2. Быстрые кнопки

Инструментальные панели быстрых кнопок для C++ Builder  имеют следующий вид (рис.9.6).  Назначение размещенных на них быстрых кнопок можно узнать из ярлычков, появляющихся в том случае, когда вы поместите курсор мыши над соответствующей кнопкой и на некоторое время задержите его.

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

 

 

 

 

 

                                                                                           Рис. 9.6. Панель быстрых кнопок

 

Таблица .9.5

Назначение быстрых кнопок

 

Пиктограмма	Команда меню	Пояснения команды
	File | New	Открыть окно New Items (новые элементы)
	File | Open	Открыть файл проекта, модуля, пакета
	File | Save	Сохранить файл модуля, с которым в данный момент идет работа
	File | Save All	Сохранить все (все файлы модулей и файл проекта)
	File | Open Project	Открыть файл проекта
	Project | Add to Project	Добавить файл в проект
	Project | Remove  from Project	Удалить файл из проекта
	Help contens	Загрузить файл справки среды C++ Builder
	View | Unit	Переключится на просмотр текста файла модуля, выбираемого из списка
	View | Form	Переключиться на просмотр формы, выбираемой из списка
	View | Toggle Form / Unit	Переключение между формой и соответствующим ей файлом модуля
	File | New Form	Включить в проект новую форму
	Run | Run	Выполнить приложение
	Run |Program Pause	Пауза выполнения приложения. Кнопка и соответствующий раздел меню доступны только во время выполнения приложения
	Run | Trace Into	Пошаговое выполнение программы с заходом в функции
	Run | Step Over	Пошаговое выполнение программы без захода в функции

 

9.3.3. Палитра компонентов

 

Палитра компонентов (рис. 9.7) – это витрина библиотеки визуальных компонентов (Visual Component Library, VCL). Она позволяет сгруппировать компоненты в соответствии с их смыслом и назначением. Эти группы, или страницы, снабжены закладками. Вы можете изменять комплектацию страниц, вводить новые страницы, переставлять их, вносить на страницы разработанные шаблоны и компоненты и т. д.

Поскольку число страниц в C++ Builder велико и не все закладки видны на экране одновременно, в правой части палитры компонентов имеются две кнопки со стрелками, направленными влево и вправо. Эти кнопки позволяют перемещать отображаемую на экране часть палитры.

 

Рис. 9.7. Палитра компонентов

 

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

Поместить выбранный в палитре компонент на форму очень просто: – следует сделать щелчок мышью в нужном месте формы. Есть и другой способ поместить компонент на форму – достаточно сделать двойной щелчок на пиктограмме компонента в палитре и он автоматически разместится в центре вашей формы.

Имена компонентов, соответствующих той или иной пиктограмме, вы можете узнать из ярлычка, который появляется, если вы задержите над этой пиктограммой курсор мыши. Если вы выберете в палитре компонент и нажмете клавишу F1, то вам будет показана справка по типу данного компонента. Но здесь нужно сделать одно замечание. Имена на ярлычках выглядят, например, так: Main Menu, Button и т. д. Однако в C++ Builder все имена классов в действительности начинаются с символа T, например TMainMenu, TButton. Под такими именами вы можете найти описания соответствующих компонентов в справочной системе, встроенной в среду C++ Builder.

 

9.3.4. Редактор кода

Одной из наиболее важных частей среды C++ Builder является окно редактора кода, показанное на рис. 9.8. Редактор кода является полноценным программным редактором. Его можно настраивать на различный стиль работы например на тот стиль, который вам более привычен. В редакторе кода применяется выделением цветом и шрифтом синтаксических элементов. Жирным шрифтом выделяются ключевые слова С++ (на рис. 9.8 это слова class, public и др.). Зеленым цветом выделяются директивы препроцессора (на рис. 9.8 это директивы #include). Синим курсивом выделяются комментарии.

B заголовке окна редактора кода отображается имя текущего файла – того файла, с текстом которого вы работаете.

В приложениях C++ Builder часто приходится работать с несколькими файлами. В частности, обычно кроме файла реализации модуля .срр вам еще нужен заголовочный файл модуля .h. Этот файл можно загрузить в окно редактора кода, щелкнув правой кнопкой мыши и выбрав из всплывающего (контекстного) меню команду Open Source / Header File. Если в этот момент вы находились в окне редактора кода на странице с текстом файла реализации модуля, то тогда в окно редактора кода загрузится заголовочный файл вашего модуля.  В верхней части окна вы можете видеть закладки, или ярлычки, указывающие текущую страницу и помогающие переходить от одного файла к другому (см. рис.1.8). Если какой-то из открытых файлов вам больше не нужен, то вы можете закрыть его страницу в окне редактора кода, выбрав в контекстном меню команду Сlоse Рage. Можно также открыть дополнительное окно редактора кода с помощью команды View | New Edit Window или щелкнув в окне редактора кода правой кнопкой мыши и выбрав аналогичную команду из всплывшего меню и одновременно работать с несколькими модулями или с разными фрагментами одного модуля.

 

 

Рис.1.8. Окно редактора кода

 

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

Второй элемент строки – индикатор модификации. Когда вы начинаете новый проект, то код, который C++ Builder автоматически написал для вас, еще не сохранен. Вы должны сделать это сами командой File | Save. Если код изменялся вами или C++ Builder с того момента, когда вы в последний раз сохраняли его в файле, то в индикаторе модификации (правее индикатора строки и колонки) появляется слово Моdified. Это слово показывает вам, что код, который вы видите, не тот же самый код, что на диске.

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

В окно редактора кода, как и в другие окна C++ Builder, встроена контекстная справка. Чтобы получить справку по какому-то слову кода (ключевому слову, написанному имени функции и т. п.), достаточно установить курсор на это слово и нажать клавишу F1. Вам будет показана соответствующая тема справки.

 

9.3.5. Инспектор объектов

Инспектор объектов (Object Inspector) обеспечивает простой и удобный интерфейс для изменения свойств объектов C++ Builder и управления событиями, на которые реагирует объект.

Окно Инспектора Объектов (рис. 9.9) имеет две страницы. Выше этих страниц имеется выпадающий список всех компонентов, размещенных на форме. В нем вы можете выбрать тот компонент, свойства и события которого вас интересуют.

                      а                                                               б

Рис. 9.9. Страницы свойств (а) и  (б) инспектора объектов

 

Страница свойств (Рroperties) инспектора объектов (рис. 9.9 а), показывает свойства того объекта, который в данный момент выделен вами. Щелкнув на окне пустой формы и на странице свойств инспектора объектов, вы сможете увидеть свойства формы,  вы можете также изменять эти свойства. Например, если вы измените свойство Сарtion (надпись) вашей формы, написав в нем «Моя форма», то вы увидите, что эта надпись появится в полосе заголовка вашей формы.

Если щелкнуть на некоторых свойствах, например на свойстве Соlоr (цвет), то справа от имени свойства откроется окно выпадающего списка. Нажав в нем на кнопку со стрелкой вниз, вы можете увидеть список возможных значений свойства.  Например, если вы смените значение свойства Соlоr с принятого по умолчанию сlВtnFасе (цвет поверхности кнопок) на clWindow (цвет окна), то вы увидите, что поверхность формы изменит свой цвет.

Рядом с некоторыми свойствами вы можете видеть знак плюс (например, со свойством ВоrdегIсоns на рис. 9.9, а). Это означает, что данное свойство является объектом, который в свою очередь имеет ряд подсвойств.

Найдите, например, свойство Fоnt (шрифт). Рядом с ним вы увидите знак плюс. Щелкните на этом плюсе или сделайте двойной щелчок на свойстве Fоnt. После этого откроется таблица таких свойств, как Соlог (цвет), Неight (высота), Name (имя шрифта) и др. Среди них вы увидите свойство Stуlе (стиль), около которого тоже имеется знак плюс. Щелчок на этом плюсе или двойной щелчок на этом свойстве раскроет дополнительный список подсвойств, в котором вы можете, например, установить в truе свойство fsBold (жирный). Кстати говоря, для смены truе на fаlsе и обратно в подобных булевых свойствах не обязательно выбирать значение из выпадающего списка. Достаточно сделать двойной щелчок на значении свойства, и оно изменится. После того как вы просмотрели или изменили подсвойства, вы можете опять сделать двойной щелчок на головном свойстве или щелчок на знаке минус около него, и список подсвойств свернется.

Страница событий (Events) составляет вторую часть Инспектора Объектов (см. рис. 9.9, б). На ней указаны все события, на которые может реагировать выбранный объект. Например, если вам надо выполнить какие-то действия в момент создания формы (обычно это различные операции настройки), то вы должны выделить событие ОnСrеаtе. Рядом с именем этого события откроется окно с выпадающим списком. Если вы уже написали в своем приложении какие-либо обработчики событий и хотите при событии ОnСrеаtе использовать один из них, то вы можете выбрать необходимый обработчик из выпадающего списка. Если же вам надо написать новый обработчик, то сделайте двойной щелчок на пустом окне списка. Вы попадете в окно pедактора rода, в котором увидите текст:

 

void_fastcall Tforml : : FormCreate (Tobject *Sender)

{

 

}

 

Курсор будет расположен в пустой строке между строками с открывающейся и закрывающейся фигурными скобками. Увиденный вами код – это заготовка обработчика события, которую автоматически сделала система С++ Builder. Вам нужно в промежутке между фигурными скобками только написать необходимые операторы.

Если вы сделали эти операции, то вернитесь в окно инспектора объектов, выделите в нем, например, событие Inactivate и нажмите в нем кнопку выпадающего списка. Вы увидите в нем введенный вами ранее обработчик события ОnСreаtе. Если вам нужно использовать тот же самый обработчик и в событии ОnАсtivatе, то просто выберите его из списка. Таким образом вы можете избежать дублирования в программе одних и тех же фрагментов кода.

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

 

9.3.6. Управление конфигурациями окон интегрированной

среды разработки

Выше мы уже рассмотрели несколько окон ИСР (инспектора объектов, редактора кода), также упоминалось окно СlаssЕхрlоrеr. Каждый пользователь открывает те окна, которые требуются ему для того или иного вида работ, и располагает их удобным для себя образом. Одни окна развернуты, другие свернуты, какие-то окна встроены друг в друга. Так создается удобная для пользователя конфигурация окон. А для того чтобы не повторять работу по оборудованию своего рабочего места каждый раз при запуске системы C++ Builder, эту конфигурацию нужно запомнить.

К примеру, можно сделать так, чтобы при очередном запуске C++ Builder восстанавливалась конфигурация, которая была на момент завершения предыдущего сеанса работы, причем должна быть восстановлена не только конфигурация окон, но и загруженный в них проект, с которым вы работали в последний раз. И даже положение курсора в окне редактора кода восстановится именно таким, какое было в момент окончания предыдущего сеанса. Так что вы сразу можете продолжать работу над тем же проектом с того самого места, на котором остановились. Эта возможность реализуется выполнением команды Tools | Environment Options. В открывшемся диалоговом окне настроек среды проектирования (рис. 9.10) на странице Preferences в группе опций Autosave нужно включить опцию Project desktop. Тогда текущая конфигурация и открытые файлы проекта автоматически сохраняются при завершении сеанса работы с C++ Builder и автоматически восстанавливаются при начале нового сеанса. При включении этой опции конфигурация окон запоминается также в каждом проекте. И если вы впоследствии откроете проект, с которым работали ранее, то восстановится конфигурация всех окон, которые были открыты в момент окончания предыдущего сеанса работы с данным проектом.

Уточним, что именно должно сохраняться в конфигурациях:

–     совокупность отрытых окон;

–     размеры и расположение окон на экране (но не сохраняется их положение в так называемой Z-последовательности, определяющей в случае взаимного перекрытия окон, какие из них находятся поверх других);

–     состояние каждого окна (свернутое, развернутое, встроенное в другое окно);

– настройки окна (например, в окне инспектора объектов сохраняется способ отображения информации  (по алфавиту или по категориям и установки фильтрации, во встраиваемых окнах сохраняется состояние индикатора Docrable).

 

 

Рис. 9.10. Диалоговое окно настроек среды проектирования

 

Введенные вами конфигурации можно впоследствии реорганизовать, удалив ненужные командой View | Desktops | Delete.

Конфигурация различных вспомогательных окон, установленная для одной из запомненных конфигураций, используется как конфигурация отладки. Какая именно — устанавливается с помощью команды View | Desktops | Set Debug Desktop или соответствующей ей быстрой кнопки. Пользователю предлагается список сохраненных конфигураций, из которого он должен выбрать конфигурацию отладки. В этом случае именно данная конфигурация будет автоматически загружаться, как только вы запускаете свое приложение на выполнение в режиме отладки.

Например, вы сделали и сохранили две конфигурации: одну без каких-либо вспомогательных окон под именем Умолчание, вторую с окном наблюдения Watches, встроенным в окно инспектора объектов, – под именем Watches, а выполняя команду установки конфигурации отладки, указали в качестве этой конфигурации Watches. Тогда, независимо от того, какую из конфигураций: Умолчание или Watches вы указали при работе с проектом, в момент, когда приложение будет запущено на выполнение, установится конфигурация Watches. После окончания сеанса отладки конфигурация автоматически вернется к исходной.

 

9.3.7. Менеджер проекта

Менеджер проекта предназначен для манипуляций с текущим проектным файлом с расширением .срр. Чтобы открыть окно менеджера

(рис. 9.11), выполните команду View | Project Manager. Окно содержит список всех составляющих файлов, ассоциированных с текущим проектом. С помощью кнопок панели быстрого вызова или опций контекстного меню вы сможете добавлять, вычеркивать, сохранять и копировать выбранный файл в текущем проекте.

 

 

Рис. 9.11. Окно менеджера проектов

 

Открыть контекстное меню менеджера проекта можно щелчком правой кнопки мыши в любом месте окна менеджера или нажатием клавиш Alt+F10. Контекстное меню содержит следующие опции:

– Save Project сохраняет изменения всех составляющих проектного файла, используя текущие имена файлов. Такое же действие вызывает команда File | Save Project As;

– Add To Repository открывает диалог Save Project Template для добавления проектного шаблона к хранилищу объектов;

– New Unit создает новый модуль в окне редактора кода и добавляет его к проектному файлу. Новым модулям присваиваются имена Unit1, Unit2, ... .Такое же действие вызывает команда File | New Unit;

– New Form создает пустую форму и новый модуль в окне редактора кода и добавляет их к проектному файлу. Новым формам присваиваются имена Form1, Form2. Такое же действие вызывает команда File | New Form;

– Add File открывает диалог Add To Project для добавления текущего модуля и связанной с ним формы к проектному файлу;

– Remove File вычеркивает модуль из списка ассоциированных файлов текущего проекта. Такое же действие вызывает команда Project | Remove from Project. Обратите особое внимание на то, чтобы  не вычеркивать файлы модулей напрямую или посредством других программ;

– View Unit активизирует выбранный модуль в окне редактора кода. Такое же действие вызывает команда View | Units;

– View Form активизирует форму, связанную с выбранным модулем, в окне hедактора форм. Такое же действие вызывает команда View | Forms;

– View Project Source активизирует текст текущего проектного файла в окне редактора кода;

– Options открывает диалог Options | Project для установки проектных опций. Такое же действие вызывает команда Options | Project;

– Update записывает изменения текста проекта в проектный файл. Важное замечание: не редактируйте проект вручную – система C++ Builder делает это автоматически.

 

9.3.8. Манипуляция компонентами на форме

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

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

Выбрать один компонент можно следующими способами:

– выбрав с помощью мыши компонент на форме;

– выбрав имя компонента в селекторе объектов;

– перейдя к компоненту на форме с помощью  клавишы Tab.

Выбор нескольких компонентов (рис.9.12) можно сделать несколькими способами:

– удерживая нажатой клавишу Shift, щелкнуть мышью на каждом компоненте;

– нажать левую клавишу мыши и окружить нужные компоненты прямоугольным контуром.

Большинство визуальных компонентов имеют общие свойства, например, Visible, Width, Left. Для установки одинаковых значений общих свойств нескольких компонентов  выполните следующие действия:

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

 

 

Рис. 9.12. Выбор нескольких компонентов для групповых операций

 

2. Установите значения свойств, общих для выделенных компонентов. На рис. 9.13  показаны  результаты изменения свойств Font и Left:  все выбранные компоненты приобрели одинаковые значения этих свойств.

 

 

Рис. 9.13. Установка одинаковых значений свойств компонентов

 

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

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

 

                                                                            

                                             Рис. 9.14. Изменение размера компонента при его

                                                                         добавлении на форму

 

Для изменения размеров нескольких компонентов следует выбрать их одним из описанных выше способов. Далее нужно выбрать пункт меню Edit / Size. Появится диалоговое окно Size, в котором необходимо выбрать  опции размера. Для точной установки размера в пикселях можно ввести числа в поля Width и Height. Далее нужно нажать кнопку OK.

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

Выравнивание компонентов. Для выравнивания компонентов на форме можно использовать как пункты меню среды разработки, так и клавиатуру (табл.9.6)

Выравнивание компонентов с помощью  пункта меню View / Alignment Palette производится так:

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

2. Выберите пункт меню View / Alignment Palette. Загрузится панель с кнопками, позволяющими выполнить различные способы выравнивания компонентов.

3. Нажмите нужную кнопку.

Можно выровнять компоненты, используя пункт меню Edit / Align (рис. 9.15). Последовательность операций такая:

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

2. Выберите пункт меню Edit / Align, после чего  появится диалоговое окно Alignment.

3. Выберите нужную опцию и нажмите на кнопку OK.

 

 

Рис.9.15. Выравнивание компонентов  с помощью меню Edit / Align

 

Таблица 9.6

Комбинации клавиш для выравнивания компонентов

 

Клавиша	Значение
Shift + стрелки	Изменяет размер компонента на 1 пиксель в направлении выбранной стрелки
Shift + Ctrl + стрелки	Перемещает компонент на одну единицу сетки в направлении выбранной стрелки
Ctrl + стрелки	Перемещает компонент на 1 пиксель в направлении выбранной стрелки

 

Еще один из способов изменения условий выравнивания компонентов –  использование пункта меню Options / Environment. Для этого нужно выполнить следующие действия:

1. Выберите пункт меню Options/Environment. Диалоговое окно Environment появится открытым на странице Preferences.

2. В группе Form designer можно выбрать следующие опции:

– Display grid  – сделать сетку из точек на форме видимой для выравниваемых компонентов;

– Snap to grid – заставить левые и верхние стороны компонентов расположиться на линиях сетки.

3. Для того чтобы изменить расстояние между узлами сетки введите новые значения вместо имеющихся. Значение по умолчанию – 8 пикселей по оси X (по горизонтали) и по оси Y (по вертикали).

4. Нажмите кнопку  OK.

 

Таким образом, интегрированная среда разработки системы C++ Builder является удобным средством разработки, отладки и тестирования приложений. Интерфейсными элементами  ИСР являются  главное и всплывающие меню и инструментальные панели быстрых кнопки. Можно также выполнять управление конфигурациями окон ИСР. Среда предоставляет в распоряжение программиста справочную систему, позволяющую получить помощь как по языку С++, так и по работе с компонентами библиотеки VCL.

При разработке интерфейса приложения программист может выполнять различные манипуляции компонентами на форме: изменять размеры, выравнивать, устанавливать общие свойства.

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

 

Контрольные вопросы и задания

 

1. Как вызвать диалоговое окно настроек ИСР?

2. Как добавить кнопки в панель инструментов, используя диалоговое окно редактора?

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

4. Как проще всего разместить в форме несколько компонентов одного типа?

5. Как проще всего поместить компонент в центр формы?

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

7. Как отобразить в редакторе кода содержимое заголовочных файлов проекта?

8. Как получить контекстную справку по свойствам и событиям?

9. Как сохранить текущую конфигурацию окон проекта?

10. Для чего предназначен менеджер проекта?

11. Как можно выполнить выбор нескольких компонентов для групповых операций?

12. Как выполнить изменение размеров компонентов?

13. Как выполнить выравнивание компонентов на форме?

14. Какими возможностями по редактированию исходных текстов программ располагает редактор кода?

15. Какая кнопка на панели быстрых кнопок позволяет выполнить  переключение между формой и соответствующим ей файлом модуля?

16. Загрузите среду C++ Builder и выполните такую настройку  ИСР, которая позволяет сохранить конфигурацию окон для использования ее в последующих сеансах работы с проектом.

17. Разместите компоненты на форме, как показано на рис.9.12 и установите значения их свойств, как показано на рис. 9.13.