Разработав некоторую функцию, программист может использовать ее в другой программе, поместив текст этой функции в раздел implementation. Однако этот способ неудобен, т. к. приходится набирать текст функции зановоили копировать его из текста другой программы.
Создание модуля
Delphi позволяет программисту поместить свои функции и процедуры в отдельный модуль, а затем использовать процедуры и функции модуля в своих программах, указав имя модуля в списке модулей, необходимых программе (инструкция uses).
Чтобы приступить к созданию модуля, нужно сначала закрыть окно формы и окно модуля формы (в ответ на вопрос о необходимости сохранения модуля следует выбрать No, т. е. модуль, соответствующий закрытой форме, сохранять не надо). Затем из меню File нужно выбрать команду New | Unit. В результате открывается окно редактора кода, в котором находится сформированный Delphi шаблон модуля. Его текст приведен в листинге 6.7.
Листинг 6.7. Шаблон модуля
Начинается модуль заголовком — инструкцией unit, в которой указано имя модуля. Во время сохранения модуля это имя будет автоматически заменено на имя, указанное программистом.
Слово interface отмечает раздел интерфейса модуля. В этот раздел программист должен поместить объявления находящихся в модуле процедур и функций, которые могут быть вызваны из других модулей, использующих данный.
В раздел implementation (реализация) нужно поместить процедуры и функции, объявленные в разделе interface. В качестве примера в листинге 6.8 приведен модуль программиста, который содержит рассмотренные ранее функции isint и IsFloat.
Для просмотра «.png» картинок надо скачать в интернете модуль TPNGImage и подключить его наподобие модуля JPEG.
Интерфейс главной формы проекта.
При своём открытии среда IDE Delphi автоматически создаёт форму с именем Form1, которая будет являться главной формой программы (то есть её закрытие приводит к закрытию всей программы).
Разместим на ней все необходимые нам компоненты:
Во первых, это главное меню «TmainMemu». Далее, это панель, на которой расположим компонент «Tmemo». В нём будет размещено краткое справочное описание разрабатываемой нами программы.
Дополнительно используем две кнопки «BitBtn». Воспользуемся свойством «Kind» этого компонента. Для кнопки, расположенной на панели, установим значение «bkOK». Для второй установим «bkClose». Кнопка такого вида будет закрывать форму автоматически при её нажатии.
Сделаем так, чтобы панель «Panel1»не была видима при запуске программы. Для этого в инспекторе объектов установим свойство панели «Visible» в «false».
Если пользователь захочет посмотреть краткое описание программы, он должен выбрать пункт меню «О программе».
Main menu delphi
Создание главного меню формы.
Разместим на «Form1» компонент главное меню (MainMenu).
Прежде мы управляли действиями программы, нажимая на кнопки, теперь же будем делать это, выбирая пункты меню.
Для создания пунктов меню необходимо вызвать редактор, дважды щёлкнув по компоненту MainMenu1 или выбрать пункт «Items …» в окне ObjeсtInspector.
В открывшемся окне щелкаем по прямоугольнику и он окрашивается в голубой цвет:
В инспекторе объектов заполняем свойство «Caption» значением «Перейти» и нажимаем «Enter». Поле заполнится введённым значением.
Далее выделяем прямоугольник, расположенный справа и в «Caption» в инспекторе объектов вводим значением «О программе».
Появляется пункт подменю:
Подпункты подменю заполняются аналогично пунктам меню, вводя туда два значения: «ко второй форме» и «завершить программу».
Здесь приведём обработчики обработчики «кликов» по пунктам меню.
Обработчики пунктов меню.
Обработчики пунктов меню вызываются так же, как и для кнопки: двойным щелчком по пункту (если вдруг редактор пунктов меню исчез, то он вызывается вновь двойным щелчком по компоненту MainMenu).
Обработчики задаём для пунктов подменю.
Для пункта «ко второй форме»:
procedure TForm1.N3Click(Sender: TObject);
form2.Show;
Обработчик второго пункта меню «завершить программу»:
procedure TForm1.N4Click(Sender: TObject);
close; //процедура завершения программы.
Второй пункт главного меню «о программе»
procedure TForm1.N5Click(Sender: TObject);
self.Panel1.Visible:=true; //панель становится видимой.
Обработчик «клика» кнопки «ok»:
procedure TForm1.BitBtn1Click(Sender: TObject);
self.Panel1.Visible:=false; // делаем панель снова невидимой.
обработчик события для кнопки «Close» писать не надо. При выборе такого типа кнопки её срабатывание происходит автоматически и программа будет закрыта.
Создание второй, третьей и так далее форм и модулей.
В предыдущем разделе мы создали главную форму программы. Однако реальные программы часто содержат две и более форм.
Создадим вторую форму. Для этого в пункте главного меню IDE выберем пункт «File» и в нём пункт «New» и далее в открывающемся подменю пункт «Form».
Будет создана вторая форма с именем «Form2» и соответствующий ей модуль «Unit2».
Но модуль не обязательно должен быть привязан к форме. Создадим самостоятельный модуль «Unit3». Для этого опять воспользуемся главным меню «File» > «New» > «Unit».
Связь модулей между собой.
Если в созданных модулях написать программный код, то он никак не будет связан между собой. Пока модули не могут видеть друг друга.
Но попытка компиляции выдаст ошибку, так как в модуле «Unit1» ничего не известно о существовании «Unit2».
Аналогично добавляется ссылка на модуль «Unit3».
Предложение будет добавлено в секцию «implementation», а не в главное предложение «Uses» в секции «Interface» в связи со следующими соображениями.
Circular unit reference delphi — перекрёстные ссылки.
Существует проблема перекрёстных ссылок на модули.
Предположим, в модуле 2 есть данные, которые используются для работы процедур, расположенных в модуле 1.
Тогда в модуле 1 в предложении uses надо сделать ссылку на модуль 2. В принципе, это можно сделать в uses, расположенном в секции interface.
Всё будет нормально, пока не потребуется получить из модуля 2 доступ к данным, расположенным в модуле 1. Если сделать ссылку на модуль 1 в секции interface модуля 2, то в силу особенностей компилятора он выдаст ошибку «о недопустимости перекрёстных ссылок».
Решение этой проблемы весьма тривиально. Необходимо размещать ссылки на модули в секции implementation, что и происходит автоматически при использовании команды главного меню «File» > «Use Unit …».
This topic covers the overall structure of a Delphi application: the program header, unit declaration syntax, and the uses clause.
Contents
Program Structure and Syntax
Note: Strictly speaking, you need not explicitly use any units in a project, but all programs automatically use the System unit and the SysInit unit.
The source code file for an executable Delphi application contains:
The Program Heading
The program heading specifies a name for the executable program. It consists of the reserved word program, followed by a valid identifier, followed by a semicolon. For applications developed using Embarcadero tools, the identifier must match the project source file name.
Delphi project files are usually short, since most of a program’s logic resides in its unit files. A Delphi project file typically contains only enough code to launch the application’s main window, and start the event processing loop. Project files are generated and maintained automatically by the IDE, and it is seldom necessary to edit them manually.
In standard Pascal, a program heading can include parameters after the program name:
Embarcadero’s Delphi ignores these parameters.
In RAD Studio, the program heading introduces its own namespace, which is called the project default namespace.
The Program Uses Clause
The uses clause lists those units that are incorporated into the program. These units may in turn have uses clauses of their own. For more information on the uses clause within a unit source file, see Unit References and the Uses Clause, below.
The uses clause consists of the keyword uses, followed by a comma delimited list of units the project file directly depends on.
The Block
The block contains a simple or structured statement that is executed when the program runs. In most program files, the block consists of a compound statement bracketed between the reserved words begin and end, whose component statements are simply method calls to the project’s Application object. Most projects have a global Application variable that holds an instance of Vcl.Forms.TApplication, Web.WebBroker.TWebApplication, or Vcl.SvcMgr.TServiceApplication. The block can also contain declarations of constants, types, variables, procedures, and functions; these declarations must precede the statement part of the block. Note that the end that represents the end of the program source must be followed by a period (.):
Unit Structure and Syntax
A unit file begins with a unit heading, which is followed by the interface keyword. Following the interface keyword, the uses clause specifies a list of unit dependencies. Next comes the implementation section, followed by the optional initialization, and finalization sections. A skeleton unit source file looks like this:
The unit must conclude with the reserved word end followed by a period.
The Unit Heading
The unit heading specifies the unit’s name. It consists of the reserved word unit, followed by a valid identifier, followed by a semicolon. For applications developed using Embarcadero tools, the identifier must match the unit file name. Thus, the unit heading:
The Interface Section
The interface section of a unit begins with the reserved word interface and continues until the beginning of the implementation section. The interface section declares constants, types, variables, procedures, and functions that are available to clients. That is, to other units or programs that wish to use elements from this unit. These entities are called public because code in other units can access them as if they were declared in the unit itself.
The interface declaration of a procedure or function includes only the routine’s signature. That is, the routine’s name, parameters, and return type (for functions). The block containing executable code for the procedure or function follows in the implementation section. Thus procedure and function declarations in the interface section work like forward declarations.
The interface declaration for a class must include declarations for all class members: fields, properties, procedures, and functions.
The interface section can include its own uses clause, which must appear immediately after the keyword interface.
The Implementation Section
The implementation section of a unit begins with the reserved word implementation and continues until the beginning of the initialization section or, if there is no initialization section, until the end of the unit. The implementation section defines procedures and functions that are declared in the interface section. Within the implementation section, these procedures and functions may be defined and called in any order. You can omit parameter lists from public procedure and function headings when you define them in the implementation section; but if you include a parameter list, it must match the declaration in the interface section exactly.
In addition to definitions of public procedures and functions, the implementation section can declare constants, types (including classes), variables, procedures, and functions that are private to the unit. That is, unlike the interface section, entities declared in the implementation section are inaccessible to other units.
The implementation section can include its own uses clause, which must appear immediately after the keyword implementation. The identifiers declared within units specified in the implementation section are only available for use within the implementation section itself. You cannot refer to such identifiers in the interface section.
The Initialization Section
The initialization section is optional. It begins with the reserved word initialization and continues until the beginning of the finalization section or, if there is no finalization section, until the end of the unit. The initialization section contains statements that are executed, in the order in which they appear, on program start-up. So, for example, if you have defined data structures that need to be initialized, you can do this in the initialization section.
For units in the interfaceuses list, the initialization sections of the units used by a client are executed in the order in which the units appear in the client’s uses clause.
The Finalization Section
The finalization section is optional and can appear only in units that have an initialization section. The finalization section begins with the reserved word finalization and continues until the end of the unit. It contains statements that are executed when the main program terminates (unless the Halt procedure is used to terminate the program). Use the finalization section to free resources that are allocated in the initialization section.
Finalization sections are executed in the opposite order from initialization sections. For example, if your application initializes units A, B, and C, in that order, it will finalize them in the order C, B, and A.
Once a unit’s initialization code starts to execute, the corresponding finalization section is guaranteed to execute when the application shuts down. The finalization section must therefore be able to handle incompletely initialized data, since, if a runtime error occurs, the initialization code might not execute completely.
Unit References and the Uses Clause
A uses clause lists units used by the program, library, or unit in which the clause appears. A uses clause can occur in
Most project files contain a uses clause, as do the interface sections of most units. The implementation section of a unit can contain its own uses clause as well.
Case Sensitivity: In unit declarations and uses clauses, unit names must match the file names in case. In other contexts (such as qualified identifiers), unit names are case insensitive. To avoid problems with unit references, refer to the unit source file explicitly:
If such an explicit reference appears in the project file, other source files can refer to the unit with a simple uses clause that does not need to match case:
The Syntax of a Uses Clause
A uses clause consists of the reserved word uses, followed by one or more comma delimited unit names, followed by a semicolon. Examples:
In the uses clause of a program or library, any unit name may be followed by the reserved word in and the name of a source file, with or without a directory path, in single quotation marks; directory paths can be absolute or relative. Examples:
Use the keyword in after a unit name when you need to specify the unit’s source file. Since the IDE expects unit names to match the names of the source files in which they reside, there is usually no reason to do this. Using in is necessary only when the location of the source file is unclear, for example when:
In the uses clause of a unit, you cannot use in to tell the compiler where to find a source file. Every unit must be in the compiler’s search path. Moreover, unit names must match the names of their source files.
Multiple and Indirect Unit References
A uses clause need include only units used directly by the program or unit in which the clause appears. That is, if unit A references constants, types, variables, procedures, or functions that are declared in unit B, then A must use B explicitly. If B in turn references identifiers from unit C, then A is indirectly dependent on C; in this case, C needn’t be included in a uses clause in A, but the compiler must still be able to find both B and C in order to process A.
The following example illustrates indirect dependency:
When a change is made in the interface section of a unit, other units that depend on the change must be recompiled. But when changes are made only in the implementation or other sections of a unit, dependent units don’t have to be recompiled. The compiler tracks these dependencies automatically and recompiles units only when necessary.
Circular Unit References
When units reference each other directly or indirectly, the units are said to be mutually dependent. Mutual dependencies are allowed as long as there are no circular paths connecting the uses clause of one interface section to the uses clause of another. In other words, starting from the interface section of a unit, it must never be possible to return to that unit by following references through interface sections of other units. For a pattern of mutual dependencies to be valid, each circular reference path must lead through the uses clause of at least one implementation section.
In the simplest case of two mutually dependent units, this means that the units cannot list each other in their interface uses clauses. So the following example leads to a compilation error:
However, the two units can legally reference each other if one of the references is moved to the implementation section:
To reduce the chance of circular references, it’s a good idea to list units in the implementation uses clause whenever possible. Only when identifiers from another unit are used in the interface section is it necessary to list that unit in the interface uses clause.
На основании сказанного можно изобразить процесс создания приложения в среде Delphi от постановки задачи до получения готового выполняемого файла (рисунок 7.1):
Рисунок 7.1. Процесс создания приложения в среде Delphi
Давайте рассмотрим назначение и внутреннее устройство файлов проекта. Это поможет вам легче ориентироваться в проекте.
7.1.2. Файлы описания форм
Если вы желаете взглянуть на содержимое DFM-файла, вызовите у формы контекстное меню щелчком правой кнопки мыши и выберите команду View as Text (рисунок 7.2).
Рисунок 7.2. Переход к текстовому представлению формы с помощью команды View as Text контекстного меню
В ответ среда Delphi вместо графического изображения формы покажет следующий текст в редакторе кода:
Несмотря на столь длинный текст описания, разобраться в нем совсем не сложно. Здесь на специальном языке задаются исходные значения для свойств формы Form1 и ее компонентов Button1, Button2, Edit1, Edit2, Label1, Label2. Большего знать не требуется, поскольку вы всегда будете использовать визуальные средства проектирования и работать с графическим представлением формы, а не с текстовым описанием. Раз так, давайте поспешим вернуться к графическому представлению, не внося в текст никаких изменений. Для этого вызовите контекстное меню редактора кода и выберите команду View as Form (рисунок 7.3).
Рисунок 7.3. Переход к графическому представлению формы с помощью команды View as Form контекстного меню
На экране снова появится графический образ формы. Если вы все-таки внесли корректировки в текст, то они отразятся на внешнем виде формы.
Файл описания формы (DFM-файл) нужен только на этапе проектирования. При сборке приложения описание формы из DFM-файла помещается в специальную область данных выполняемого файла (область ресурсов). Когда во время работы приложения происходит создание формы, ее описание извлекается из области ресурсов и используется для инициализации формы и ее компонентов. В результате форма отображается на экране так, как вы задали при проектировании.
7.1.3. Файлы программных модулей
Каждой форме в проекте соответствует свой программный модуль (unit), содержащий все относящиеся к форме объявления и методы обработки событий, написанные на языке Delphi. Программные модули размещаются в отдельных файлах с расширением PAS. Их количество может превышать количество форм. Почему? Потому, что в ряде случаев программные модули могут и не относиться к формам, а содержать вспомогательные процедуры, функции, классы и проч. Наша задача об идеальном весе очень простая, поэтому в ней имеется только один программный модуль, связанный с формой. Не поленитесь изучить его внимательно:
Дадим необходимые комментарии к тексту программного модуля. В самом начале после ключевого слова unit записывается имя модуля
Содержание интерфейсной секции модуля (interface) начинается с подключения стандартных модулей библиотеки VCL, в которых определены часто вызываемые подпрограммы и классы помещенных на форму компонентов.
Среда Delphi формирует список модулей без вашего участия и автоматически пополняет его, когда вы добавляете на форму новые компоненты. Тем не менее, список подключенных модулей можно изменять прямо в редакторе кода (вручную).
Смотрим дальше. В разделе описания типов (type) объявлен класс формы. По умолчанию он называется TForm1 и порожден от стандартного класса TForm.
Помещенные на форму компоненты представлены полями формы. У нас на форме шесть компонентов, поэтому и полей в описании класса тоже шесть. Имена полей совпадают с именами компонентов, заданными в окне свойств.
После полей следуют заголовки методов обработки событий. Название каждого такого метода среда Delphi формирует автоматически на основании имени компонента и имени генерируемого им события. Например, для кнопки Button1 метод обработки события OnClick называется Button1Click.
Обратите внимание, что поля, представляющие компоненты формы, а также методы обработки событий получают атрибут видимости published (он принимается по умолчанию для всех наследников TForm). Благодаря этому вы можете работать с ними на визуальном уровне, например, видеть их имена в окне свойств. Поскольку среда Delphi сама управляет содержимым секции published, никогда не модифицируйте эту секцию вручную (в редакторе кода), пользуйтесь визуальными инструментами: палитрой компонентов и окном свойств. Запомните:
После описания класса идет объявление собственно объекта формы:
На этом содержание интерфейсной секции модуля заканчивается и начинается раздел реализации (implementation). Сначала в нем подключается файл описания формы:
Пожалуйста, не подумайте, что эта директива подключает все файлы с расширением DFM. Подключается лишь один DFM-файл, в котором описана форма данного модуля. Имя DFM-файла получается заменой звездочки на имя модуля, в котором записана директива.
Далее следует реализация методов обработки событий. Пустые заготовки для них среда Delphi создает сама одновременно с добавлением заголовков в класс формы. Вы же наполняете их содержанием.
При внимательном изучении исходного текста модуля остается невыясненным один вопрос: как обеспечивается вызов методов Button1Click и Button2Click при нажатии на форме кнопок, ведь в тексте модуля отсутствует даже намек на это. Все очень просто. Загляните в DFM-файл. Кроме установки значений свойств вы найдете установку и обработчиков событий.
Мы достаточно глубоко погрузились во внутреннее устройство файлов описания форм и файлов программных модулей и, признаемся, сделали это намеренно, чтобы дать вам полное понимание вопроса, не заставляя принимать на веру далеко неочевидные вещи. А сейчас пора подняться на уровень проекта и посмотреть, что же объединяет все эти файлы.
7.1.4. Главный файл проекта
Когда вы по команде File / New / Application начинаете разработку нового приложения, среда Delphi автоматически создает файл проекта. По мере создания новых форм содержимое этого файла видоизменяется автоматически. Когда вы закончите работу и будете готовы компилировать проект, в DPR-файле будет находиться перечень программных модулей, которые будут поданы на вход компилятору. Чтобы увидеть содержимое DPR-файла нашего приложения, вычисляющего идеальный вес, выберите в меню среды Delphi команду Project / View Source. В редакторе кода появится новая страница со следующим текстом:
Немного прокомментируем этот текст. Подключение модуля Forms обязательно для всех программ, так как в нем содержится определение объекта Application. Этот объект лежит в основе любого графического приложения и доступен на протяжении всей его работы.
Подключаемый следом модуль Unit1 содержит определение формы. Название формы приводится в фигурных скобках. Директива in указывает на то, что модуль является необходимой частью проекта и существует в виде исходного текста на языке Delphi.
Директива <$R *.res>подключает к результирующему выполняемому файлу так называемые ресурсы, в данном случае значок приложения. Этот значок будет виден на Панели Задач.
Внимание! Никогда не изменяйте DPR-файл вручную. Оставьте эту работу для среды Delphi. Добавление и удаление модулей, а также управление созданием форм осуществляется с помощью команд и диалоговых окон среды.
7.1.5. Другие файлы проекта
Выше мы рассмотрели основные файлы проекта. Кроме них существует ряд дополнительных файлов:
В проект могут входить также логически автономные элементы: точечные рисунки (BMP-файлы), значки (ICO-файлы), файлы справки (HLP-файлы) и т.п., однако ими управляет сам программист.
Теперь можно уточнить рисунок, отражающий состав проекта (рисунок 7.4):
Рисунок 7.4.Состав проекта в среде Delphi
7.2. Управление проектом
7.2.1. Создание, сохранение и открытие проекта
При запуске среды Delphiавтоматически создается новый проект. Это сделано для вашего удобства. Если вам потребуется создать новый проект, не перегружая среду Delphi, просто выполните команду меню File / New / Application. В результате старый проект будет закрыт, а вместо него создан новый. В новый проект среда Delphi всегда помещает чистую форму.
В процессе разработки приложения вы добавляете на форму компоненты, пишите обработчики событий, добавляете в проект дочерние формы, в общем, проектируете приложение. Когда что-то уже сделано, имеет смысл сохранить проект. Для этого выполните команду главного меню File / Save All. Среда запросит сначала имя для программного модуля с формой, а затем имя для проекта (кстати, вы уже сохраняли файл в первой главе). Если файл с введенным именем уже есть на диске, среда Delphi сообщит вам об этом и запросит подтверждение на перезапись существующего файла или запись под другим именем.
Рисунок 7.5. Окно выбора проекта
С открытым проектом можно продолжить работу: исправить, компилировать, выполнить, и не забыть сохранить.
7.2.2. Окно управления проектом
Рисунок 7.6. Окно управления проектом
Управление проектом выполняется с помощью контекстного меню, которое вызывается щелчком правой кнопки мыши по элементу Project1 (рисунок 7.7).
Рисунок 7.7. Контекстное меню проекта
Назначение команд контекстного меню кратко описано в следующей таблице:
Команда
Описание
Add…
Добавляет существующий файл (модуль) в проект.
Remove File…
Удаляет файл (модуль) из проекта.
Save
Сохраняет проект на диск.
Options…
Вызывает диалоговое окно настройки проекта (Project Options).
Activate
Делает проект активным (при работе с группой проектов, см. параграф 7.2.3).
Close
Закрывает проект.
Remove Project
Удаляет проект из группы (см. параграф 7.2.3).
Build Sooner
Перемещает проект вверх по списку, определяющему очередность сборки проектов. Используется при работе с группой проектов (см. параграф 7.2.3).
Build Later
Перемещает проект вниз по списку, определяющему очередность сборки проектов. Используется при работе с группой проектов (см. параграф 7.2.3).
Compile All From Here
Компилирует измененные проекты по порядку, начиная с выделенного проекта. Используется при работе с группой проектов (см. параграф 7.2.3).
Build All From Here
Компилирует все проекты по порядку, начиная с выделенного проекта. Используется при работе с группой проектов (см. параграф 7.2.3).
Управление отдельным модулем выполняется с помощью контекстного меню, которое вызывается щелчком правой кнопки мыши по соответствующему элементу, например Unit1 (рисунок 7.8).
Рисунок 7.8. Контекстное меню модуля в окне управления проектом
Назначение основных команд контекстного меню кратко описано в следующей таблице:
Команда
Описание
Open
Открывает модуль. Если модуль содержит форму, то на экране появляется ее графическое представление. Иначе, на экране появляется редактор кода с исходным текстом программного модуля.
Remove From Project
Удаляет модуль из проекта.
Save
Сохраняет модуль на диск.
Save As…
Сохраняет модуль с новым именем.
Теперь вы всегда сможете узнать, из каких файлов состоит тот или иной проект, а управление им не составит для вас никакого труда.
7.2.3. Группы проектов
На практике несколько проектов могут быть логически связаны между собой, например проект динамически подключаемой библиотеки связан с проектом приложения, в котором используется эта библиотека. Среда Delphi позволяет объединить такие проекты в группу. Именно для этого в окне управления проектом имеется корневой элемент ProjectGroup1, подчиненными элементами которого и являются логически связанные проекты. Порядок элементов определяет очередность сборки проектов. Изменить порядок можно с помощью команд Build Sooner и Build Later, которые находятся в контекстном меню, вызываемом щелчком правой кнопки мыши по соответствующему проекту (рисунок 7.7).
Рисунок 7.9. Контекстное меню группы проектов
Назначение команд контекстного меню кратко описано в следующей таблице:
Команда
Описание
Add New Project…
Создает новый проект и добавляет его в группу.
Add Existing Project…
Добавляет существующий проект в группу.
Save Project Group
Сохраняет файл, описывающий группу проектов.
Save Project Group As…
Сохраняет описание группы проектов в файле с другим именем.
View Project Group source
Показывает текстовый файл, описывающий группу проектов.
Когда в группу объединены несколько проектов, среда Delphi создает специальный текстовый файл с описанием этой группы. Файл имеет расширение BPG (от англ. Borland Project Group), а его имя запрашивается у пользователя. Для групп, состоящих из одного единственного проекта BPG-файл не создается.
7.2.4. Настройка параметров проекта
Диалоговое окно параметров проекта состоит из нескольких вкладок. Параметров очень много, поэтому мы рассмотрим только те, которые используются наиболее часто.
На вкладке Forms (рисунок 7.10) можно задать главную форму приложения (Main form) и в списке Auto-create forms указать формы, которые будут создаваться одновременно с главной формой.
Рисунок 7.10. Окно параметров проекта. Вкладка Forms
На вкладке Application (рисунок 7.11) можно задать название (Title) вашей программы. В среде Delphi дополнительно можно задать файл справки (Help file) и значок (Icon).
Рисунок 7.11. Вкладка Application в окне параметров проекта
Рисунок 7.12. Вкладка Compiler в окне параметров проекта
На вкладке Compiler Messages (рисунок 7.13) настраивается чувствительность компилятора к подозрительному коду. Включив переключатели Show hints и Show warnings, вы будете получать от компилятора весьма полезные подсказки (hints) и предупреждения (warnings), а не только сообщения об ошибках.
Рисунок 7.13. Вкладка Compiler Messages в окне параметров проекта
На вкладке Linker (рисунок 7.14) настраиваются параметры сборки проекта. Обладателям среды Delphi следует обратить внимание на группу Memory sizes, особенно на два параметра: Min stack size и Max stack size. Они задают соответственно минимальный и максимальный размеры стека прикладной программы. Вам может потребоваться увеличить значения этих параметров при написании приложения, активно использующего рекурсивные подпрограммы.
Рисунок 7.14. Вкладка Linker в окне параметров проекта
Рисунок 7.15. Вкладка Directories/Conditionals в окне параметров проекта
Рисунок 7.16. Вкладка Version Info в окне параметров проекта
Рисунок 7.17. Вкладка Packages в окне параметров проекта
Когда все параметры проекта установлены, можно приступать к его компиляции.
7.2.5. Компиляция и сборка проекта
Компиляция и сборка проекта могут выполняться на любой стадии разработки проекта. Под компиляцией понимается получение объектных модулей (DCU-файлов) из исходных текстов программных модулей (PAS-файлов). Под сборкой понимается получение выполняемого файла из объектных модулей. В среде Delphi компиляция и сборка проекта совмещены.
Для выполнения компиляции достаточно выполнить команду меню Project / Compile или нажать комбинацию клавиш Ctrl+F9. При этом компилируются все исходные модули, содержимое которых изменялось после последней компиляции. В результате для каждого программного модуля создается файл с расширением DCU (сокр. от Delphi Compiled Unit). Затем среда Delphi компилирует главный файл проекта и собирает (иногда говорят компонует) из DCU-модулей выполняемый файл, имя которого совпадает с именем проекта. К сведению профессионалов заметим, что смышленый компилятор среды Delphi выбрасывает из выполняемого файла весь неиспользуемый программный код, поэтому не стоит волноваться по поводу лишних объектов и подпрограмм, которые могут присутствовать в подключенных модулях.
7.2.6. Запуск готового приложения
Когда после многочисленных компиляций вы исправите все ошибки и получите-таки выполняемый файл, можно будет посмотреть на результат вашего самоотверженного труда. Для этого надо выполнить созданное приложение с помощью команды меню Run / Run или клавиши F9. Перед выполнением будет автоматически повторен процесс компиляции (если в проект вносились изменения) и после его успешного завершения приложение запустится на выполнение. В результате вы увидите на экране его главную форму.
7.3. Форма
7.3.1. Понятие формы
Форма имеет очень много свойств, и поначалу в них легко запутаться. Практика показывает, что путаница возникает из-за алфавитного порядка свойств в окне Object Inspector: близкие по смыслу свойства оказываются разбросанными по ячейкам списка. Чтобы у вас сложилось представление о возможностях формы, рассмотрим основные свойства формы в порядке их важности. Для этого нам понадобится новое приложение.
Выберите в меню команду File / New / Application. Среда Delphi автоматически создаст в новом проекте чистую форму и поместит ее исходный текст в редактор кода (рисунок 7.18).
Рисунок 7.18. Форма на экране и ее описание в редакторе кода
7.3.2. Имя и заголовок формы
Рисунок 7.19. Программный идентификатор формы
На будущее заметим, что свойство Name есть в любом компоненте, и оно редактируется в окне свойств.
Рисунок 7.20. Заголовок формы
ПРИМЕЧАНИЕ
7.3.3. Стиль формы
Настраивая форму, нужно принимать во внимание, какой пользовательский интерфейс будет иметь ваше приложение: многодокументный интерфейс MDI (от англ. Multiple Document Interface) или обычный одно-документный интерфейс SDI (от англ. Single Document Interface). За это отвечает свойство формы FormStyle, которое может принимать следующие значения:
Многие приложения, с которыми вы работаете, имеют пользовательский интерфейс MDI. Они состоят из основного окна, которое включает одно или несколько внутренних окон. Внутренние окна ограничены областью основного окна и не могут выходить за его границы. Для главной формы, соответствующей основному окну MDI-приложения, значение свойства FormStyle должно быть равно fsMDIForm. Для всех второстепенных форм, соответствующих внутренним окнам, значение свойства FormStyle равно fsMDIChild. Для окон диалога, выполняющихся в монопольном режиме, свойство FormStyle равно значению fsNormal, что дает возможность выносить их за пределы основной формы.
Если программа имеет пользовательский интерфейс SDI, то каждая форма существует в виде отдельного независимого окна. Одно из окон является главным, однако оно не содержит другие окна. В SDI-приложении значение свойства FormStyle равно fsNormal и для главной формы, и для второстепенных форм. В некоторых случаях допускается установка значения fsStayOnTop для того, чтобы форма всегда отображалось поверх других форм.
7.3.4. Размеры и местоположение формы на экране
Рисунок 7.21. Размеры и местоположение формы на экране
Кроме того, с помощью свойства Position можно организовать автоматическое размещение формы на экране, выбрав одно из следующих возможных значений:
Иногда размеры формы рассчитываются исходя из размеров ее внутренней рабочей области (client area), на которой размещаются компоненты. Как известно, в рабочую область не входят рамка и заголовок. Размеры рабочей области хранятся в свойствах ClientWidth и ClientHeight. При их установке значения свойств Width и Height автоматически пересчитываются (и наоборот).
Бывает, что при выборе размеров формы учитываются размеры экрана. Поскольку современные видео-адаптеры поддерживают множество режимов с различными разрешениями, встает вопрос: как обеспечить одинаковую пропорцию между формой и экраном независимо от разрешающей способности дисплея. На этот случай в форме предусмотрено свойство Scaled. Если оно установлено в значение True, то форма будет автоматически масштабироваться в зависимости от разрешающей способности дисплея.
При перемещении по экрану, форма может слегка прилипать к краям экрана, если края формы находятся в непосредственной близости от них. Это происходит в том случае, если свойство ScreenSnap содержит значение True. Расстояние формы до краев экрана, при котором форма прилипает, задается в свойстве SnapBuffer и измеряется в пикселях.
Работая с приложением, пользователь может свернуть форму или развернуть ее на всю рабочую область экрана с помощью соответствующих кнопок рамки. Состояние формы (свернута или развернута) определяется свойством WindowState, которое принимает следующие значения:
Если при проектировании вы измените значение свойства WindowState на wsMinimized или wsMaximized, то получите форму, которая при первом появлении будет автоматически либо свернута в панель задач, либо развернута на весь экран.
На компьютере с двумя и более мониторами существует возможность выбрать для формы монитор, на котором она отображается. Для этого следует установить свойство DefaultMonitor в одно из следующих значений:
Свойство DefaultMonitor учитывается лишь в том случае, если в программе существует главная форма.
7.3.5. Цвет рабочей области формы
С размерами формы все ясно и теперь желающие могут изменить стандартный цвет ее фона с помощью свойства Color. Для этого следует обратиться к окну свойств. Перейдите к свойству Color, откройте выпадающий список, и выберите любой цвет из набора базовых цветов. Базовые цвета представлены в списке именованными константами. Вы можете также выбрать цвет из всей цветовой палитры, выполнив двойной щелчок мыши в поле значения свойства. На экране появится стандартное диалоговое окно выбора цвета (рисунок 7.22).
Рисунок 7.22. Стандартоне диалоговое окно выбора цвета
7.3.6. Рамка формы
Во внешнем виде формы очень важную роль играет рамка и расположенные на ней кнопки «Свернуть», «Развернуть», «Закрыть» (рисунок 7.23). Стиль рамки задается с помощью свойства BorderStyle, которое может принимать следующие значения:
Обычно свойство BorderStyle имеет значение bsSizeable. В этом случае форма имеет стандартную изменяемую в размерах рамку (как при проектировании), заголовок, меню управления, кнопки «Свернуть», «Развернуть», «Закрыть» и, иногда, «Справка». Для указания того, какие именно из этих элементов отображать, используется свойство BorderIcons. Список его возможных значений следующий:
Рисунок 7.23. Рамка формы и ее контекстное меню
Команды меню управления не нуждаются в комментариях.
7.3.7. Значок формы
Если вы разрабатываете коммерческое приложение, а не тестовый пример, следует позаботиться о том, чтобы форма имела в своем левом верхнем углу выразительный значок. Для разработки значков существует множество средств, на которых мы не будем останавливаться. Когда значок готов и сохранен в файле, его нужно просто установить в качестве значения свойства Icon (рисунок 7.24).
Рисунок 7.24. Установка значка формы
Для этого откройте окно Picture Editor нажатием кнопки с многоточием (рисунок 7.25). Нажмите кнопку Load. и выберите какой-нибудь файл из стандартной коллекции значков (как правило, каталог C:\Program Files\Common Files\Borland Shared\Images). После этого закройте диалоговое окно с помощью кнопки OK.
Рисунок 7.25. Окно выбора значка для формы
Среда Delphi сразу же подставит выбранный значок в левый верхний угол формы (рисунок 7.26).
Рисунок 7.26. Новый значок формы
7.3.8. Невидимая форма
Сценарий решения задачи может потребовать, чтобы в некоторый момент форма стала невидимой, т.е. исчезла с экрана. За «видимость» формы отвечает булевское свойство Visible. Установка ему значения False скроет форму, а установка значения True покажет ее.
7.3.9. Прозрачная форма
Некоторые части формы можно сделать прозрачными (рисунок 7.27). Причем щелчок мыши по прозрачной области формы будет приводить к активизации окон (форм), находящихся за формой. Это достигается установкой свойства TransparentColor в значение True и выбором цвета прозрачности в свойстве TransparentColorValue. Все пиксели формы с цветом TransparentColorValue будут прозрачными.
Рисунок 7.27. Прозрачная форма
Например, рисунок 7.27 был получен следующим образом. Мы положили на форму компонент Shape, превратили его в эллипс (Shape = stEllipse), растянули до размеров формы (Align = alClient), в форме установили свойство TransparentColor в значение True и уравняли в форме значение свойства TransparentColorValue со свойством Brush.Color компонента Shape. После сборки и запуска программы получили «дырявую» форму.
7.3.10. Полупрозрачная форма
Форма может быть полупрозрачной (рисунок 7.28). За полупрозрачность формы отвечают свойства AlphaBlend и AlphaBlendValue. Первое свойство включает и выключает эффект полупрозрачности, а второе определяет силу прозрачности.
Рисунок 7.28. Полупрозрачная форма
7.3.11. Недоступная форма
Иногда бывает нужно просто запретить доступ к форме, не убирая ее с экрана. Для этого служит другое булевское свойство Enabled. Обычно оно равно значению True, но стоит ему присвоить противоположное значение, и после запуска приложения вы не сможете сделать форму активной.
Как вы понимаете, все описанные выше свойства доступны не только в окне свойств, но и в редакторе кода, т.е. в тексте программы. При работе с формой на уровне исходного кода вы также получаете доступ к некоторым дополнительным свойствам, которые не видны в окне свойств. Они будут рассматриваться по мере надобности.
7.3.12. События формы
Итак, со свойствами мы разобрались и пора сказать пару слов о возникающих при работе с формой событиях. С вашего позволения мы опустим те события формы, которые происходят во всех видимых на экране компонентах (мы о них расскажем позже, когда будем рассматривать компоненты). Перечислим лишь характерные события форм:
7.4. Несколько форм в приложении
Часто одной формы для решения задачи бывает мало. Поэтому сейчас мы рассмотрим, как добавить в проект новую форму, выбрать главную форму приложения, переключаться между формами. Затем мы расскажем, как на этапе работы приложения решается вопрос показа форм на экране.
7.4.1. Добавление новой формы в проект
Рисунок 7.29. Две формы в проекте
7.4.2. Добавление новой формы из Хранилища Объектов
Рисунок 7.30. Окно создания новой формы или другого элемента проекта
Если на вкладке New диалогового окна выбрать значок с подписью Form, то в проект добавится обычная пустая форма, как по команде меню File / New Form. Если вас интересуют формы с «начинкой», обратитесь к вкладкам Forms и Dialogs (рисунок 7.31).
Рисунок 7.31. Быстрое создание формы с «начинкой»
На вкладках Forms и Dialogs существует переключатель, указывающий, что нужно сделать с формой-заготовкой: копировать (Copy), наследовать (Inherit) или использовать (Use). Отличие между ними состоит в следующем:
Для нашего учебного примера двух форм достаточно, поэтому вернемся к уже созданным формам, нажав кнопку Cancel.
7.4.3. Переключение между формами во время проектирования
Иногда за формами становиться трудно уследить. Навести порядок помогает окно View Form, для вызова которого служит команда меню View / Forms. (рисунок 7.32).
Рисунок 7.32. Окно для переключения на другую форму
Выберите в этом окне форму, с которой собираетесь работать, и щелкните по кнопке OK. Выбранная форма сразу же станет активной.
7.4.4. Выбор главной формы приложения
Когда в проекте несколько форм, возникает вопрос: какая из них главная. Давайте не будем ломать голову, а обратимся к известному вам диалоговому окну Project Options и посмотрим на вкладке Forms, какая форма выбрана в выпадающем списке Main form (рисунок 7.33).
Рисунок 7.33. Главная форма в проекте записана в поле Main form
7.4.5. Вызов формы из программы
Работая с несколькими формами, вы должны принимать во внимание, что после загрузки приложения отображается только главная форма. Остальные формы хотя и создаются вслед за ней автоматически, на экране сразу не показываются, а ждут пока их вызовут. Форму можно вызвать для работы двумя разными способами:
Покажем, как реализуются эти способы на примере вызова формы SecondaryForm из формы MainForm.
Чтобы форма SecondaryForm была доступна для использования формой MainForm, необходимо подключить модуль формы SecondaryForm к модулю формы MainForm. Это делается очень просто.
Рисунок 7.34. Окно для выбора подключаемого модуля
На экране не произойдет видимых изменений, но в секции implementation программного модуля Main добавится строка
Теперь обеспечим вызов формы SecondaryForm из формы MainForm. В большинстве случаев формы вызываются при нажатии некоторой кнопки. Добавим такую кнопку на форму MainForm.
2. Отыщите в палитре компонентов на вкладке Standard значок с подсказкой Button, щелкните по нему, а затем щелкните по форме MainForm. На форме будет создана кнопка Button1 и в окне свойств отобразится список ее свойств. Перейдите к свойству Caption и замените текст Button1 на текст Secondary (рисунок 7.35).
Рисунок 7.35. Текст на кнопке записывается в свойстве Caption
Чтобы при нажатии кнопки отображалась форма SecondaryForm, необходимо для этой кнопки определить обработчик события OnClick. Это делается очень просто.
3. Активизируйте в окне свойств вкладку Events и сделайте двойной щелчок в поле события OnClick. Среда Delphi определит для кнопки обработчик события, поместив программную заготовку в исходный текст модуля Main. Вставьте в тело обработчика оператор SecondaryForm.Show, в результате метод обработки события примет следующий вид:
Рисунок 7.36. Приложение с двумя формами на экране
Таким образом, при использовании метода Show пользователь может работать одновременно с несколькими формами, переключаясь между ними.
Ситуация, когда пользователю предлагается для работы сразу несколько доступных форм, встречается редко. Поэтому для показа формы в основном применяется метод ShowModal. Он обеспечивает работу формы в монопольном режиме, не возвращая управление до тех пор, пока пользователь не закроет форму.
5. Посмотрим, что произойдет, если в предыдущем примере заменить вызов метода Show на ShowModal.
6. После компиляции и запуска приложения нажмите на форме MainForm кнопку Secondary. После появления формы SecondaryForm попробуйте активизировать форму MainForm. У вас ничего не выйдет, поскольку на этот раз форма SecondaryForm отображается в монопольном режиме (рисунок 7.37).
Рисунок 7.37. Вторая форма работает в монопольном режиме
Только закрыв форму SecondaryForm, вы вернетесь к форме MainForm. Теперь понятно и назначение метода ShowModal. С его помощью организуется пошаговый (диалоговый) режим взаимодействия с пользователем, который подробно рассмотрен в главе 9.
7.5. Компоненты
7.5.1. Понятие компонента
Понятие компонента является фундаментальным для среды Delphi. Без компонентов все преимущества визуальной разработки приложений исчезают и говорить становится не о чем. Поэтому соберите все силы и внимательно прочитайте этот параграф, пытаясь усвоить не только технику использования компонентов, но и саму их суть.
Существует два взгляда на компоненты.
При анализе структуры компонента обнаруживается, что его природа троична и лучше всего описывается формулой:
Компонент = состояние (свойства) + поведение (методы) + обратная реакция (события).
7.5.2. Визуальные и невизуальные компоненты
Все компоненты делятся на две группы: визуальные и невизуальные компоненты (рисунок 7.38).
Рисунок 7.38. Визуальные и невизуальные компоненты
Невизуальные компоненты могут иметь подписи (рисунок 7.38). Отображение подписей обеспечивается установкой переключателя Show component captions в окне Environment Options на вкладке Designer. Окно вызывается по команде меню Tools / Environment Options…
7.5.3. «Оконные» и «графические» компоненты
Рисунок 7.39. Компоненты, рисуемые оконной системой Windows и графической библиотекой Delphi
Общая классификация компонентов составлена, поэтому перейдем к обсуждению их свойств и событий. Очевидно, каждый компонент обладает специфичным набором свойств и событий и, казалось бы, изучать их следует в контексте изучения компонента. Так мы и будем поступать в будущем при рассмотрении отличительных свойств компонентов. Однако сейчас имеет смысл рассмотреть общие для большинства компонентов свойства и события.
7.5.4. Общие свойства визуальных компонентов
Визуальные компоненты имеют ряд общих свойств:
7.5.5. Общие события визуальных компонентов
Визуальные компоненты имеют ряд общих событий:
Для организации буксировки и стыковки, в визуальных компонентах существует еще несколько событий:
Подробно события буксировки и стыковки рассмотрены в главе 10.
7.6. Управление компонентами при проектировании
7.6.1. Помещение компонентов на форму и их удаление
Чтобы поместить на форму нужный компонент из палитры компонентов, выполните следующие действия:
Выбранный компонент окажется на форме и будет готов к настройке в окне свойств.
Часто требуется разместить на форме несколько компонентов одного и того же типа, например, кнопок. В этом случае действуйте следующим образом:
Если вы по каким-либо причинам решили убрать лишний компонент с формы, просто выберите его с помощью мыши и нажмите клавишу Del.
7.6.2. Выделение компонентов на форме
На стадии проектирования любой компонент может быть выделен на форме. Свойства выделенного компонента видны в окне свойств и доступны для редактирования. Чтобы выделить компонент, достаточно навести на него указатель и нажать кнопку мыши. Вокруг компонента тут же появятся так называемые «точки растяжки» (sizing handles) для изменения размеров компонента по ширине и высоте (рисунок 7.40).
Рисунок 7.40. Точки растяжки компонента
При проектировании сложных форм вы столкнетесь с ситуацией, когда сразу в нескольких компонентах нужно установить некоторое свойство в одно и то же значение. Например, в нескольких кнопках установить свойство Enabled в значение False. Быстрее всего это можно сделать, если выделить несколько компонентов, после чего перейти к окну свойств и изменить нужное свойство. Когда на форме выделено несколько компонентов, в окне свойств видны только их общие свойства.
Выделить несколько компонентов можно двумя способами:
Вы можете комбинировать оба способа для выделения лишь тех компонентов, которые вам нужны.
Когда на форме выделено несколько компонентов, в окне свойств отображаются лишь их общие свойства. Активизируйте нужное свойство и установите в нем нужное значение. Вы увидите, что эта установка отразится на всех выделенных компонентах (рисунок 7.41).
Рисунок 7.41. Установка свойства для группы компонентов
7.6.3. Перемещение и изменение размеров компонента
Для перемещения компонента на другое место:
Изменить размер компонента тоже просто:
Рисунок 7.42. Расстояние между узлами сетки по горизонтали и вертикали
Иногда после грубого размещения компонента на сетке необходимо подогнать его положение и размеры с точностью до точки экрана. Для этого не требуется отключать сетку или изменять ее шаг. Просто выберите компонент на форме и действуйте следующим образом:
7.6.4. Выравнивание компонентов на форме
Когда на форме много компонентов, ручное выравнивание становится весьма утомительным занятием. На этот случай в среде Delphi предусмотрены средства автоматизированного выравнивания компонентов. Алгоритм выравнивания следующий:
1. Выделите компоненты, которые собираетесь выравнять. Во всех четырех углах каждого выделенного компонента появятся небольшие квадратики-маркеры;
Рисунок 7.43. Диалоговое окно для выбора способа выравнивания группы компонентов на форме
3. Выберите в списке то, что вам надо, и нажмите кнопку OK. Окно закроется и все компоненты будут выравнены согласно вашим указаниям.
Если компонентов на форме много и вам предстоит большая работа по их выравниванию, откройте окно Align (с помощью команды меню View / Alignment Palette) и используйте его на втором шаге приведенного выше алгоритма (рисунок 7.44).
Рисунок 7.44. Вспомогательная панель кнопок для выравнивания группы компонентов на форме
7.6.5. Использование Буфера обмена
При работе с несколькими формами иногда встает задача копирования и перемещения компонентов с одной формы на другую. Обычное перетягивание здесь не помогает. Проблема легко решается с помощью Буфера обмена:
Добавим, что команды работы с Буфером обмена применяются не только для копирования и перемещения компонентов с одной формы на другую, но также для копирования и перемещения компонентов в пределах одной формы между разными компонентами-владельцами, например для перемещения кнопок с одной панели на другую. Необходимость использования Буфера обмена в этом случае вызвана тем, что компоненты твердо знают своего владельца (например, кнопки знают панель, на которой они расположены), поэтому обычная операция буксировки ни к чему не приводит.
7.7. Закулисные объекты приложения
Объект Application отсутствует в палитре компонентов, поэтому его свойства можно изменять только из программы. Кратко рассмотрим наиболее важные свойства этого объекта:
Рисунок 7.45. Окно параметров проекта
Объект Application имеет несколько полезных событий. Самые важные из них: OnActivate, OnDeactivate, OnException.
При необходимости на помощь объекту Application спешат менее значительные «персоны»: объекты Screen, Printer и Clipboard. Они также являются глобальными и создаются автоматически при запуске приложения (если, конечно, подключены стандартные модули, где они расположены).
Каждая программа что-то выводит на экран, иначе она просто бесполезна. В среде Delphi экран трактуется как глобальный объект Screen класса TScreen, имеющий набор свойств. Многие из них жестко связаны с физическими характеристиками экрана (с «железом»), поэтому в большинстве случаев не доступны для записи. Обозначим самые важные свойства:
В качестве примера использования объекта Screen приведем фрагмент, устанавливающий указателю мыши вид песочных часов на время выполнения какой-либо длительной операции:
Вряд ли сейчас можно встретить компьютеры без миниатюрного «хвостатого» устройства, называемого мышью. Для работы с ним в среде Delphi есть специальный объект Mouse: TMouse, автоматически добавляемый в программу при подключении модуля Controls. Перечислим наиболее важные свойства этого объекта:
Большинство программ выводят некоторый текст или рисунки на печатающее устройство. Для этого полезного дела в среде Delphi имеется специальный объект Printer. Он становится доступен после подключения модуля Printers. Если вы включите этот модуль в проект, сразу после старта будет порожден объект Printer класса TPrinter. Его свойства и методы дают вам весьма неплохие возможности для печати из приложения на все виды принтеров. Однако, тема эта заслуживает отдельной главы (см. гл. 10).
