Изучение средств создания программ в среде «Delphi».

Министерство образования и науки Российской Федерации
Федеральное агентство по образованию
___________________________________________________________
Государственное образовательное учреждение
высшего профессионального образования
Пензенский государственный университет архитектуры и
строительства
Ю.В. Блинков,
В.Д. Былкин
Изучение средств создания
программ в среде «Delphi».
Рекомендовано редсоветом университета
В качестве учебного пособия для специальности 07190
«Информационные системы и технологии»
Пенза 2007
УДК 004.4(075.8)
ББК 32.973я73
Б69
Рецензенты:
кафедра «Автоматизация и управление»
Пензенского технологического института, зав.
кафедрой профессор В. В. Усманов;
Аверьянов В.А., директор Государственного
унитарного предприятия «ЛАНТ».
Изучение средств создания программ в среде «Delphi»: Практикум
/ Ю. В. Блинков, В. Д. Былкин. Пенза: ПГУАС, 2007 - 208 c.
Содержит информацию по практическому изучениюя и освоению
средств визуального и объектно - ориентированного программирования
языка Object Pascal в среде Delphi 3, не требующего использования
мощных компьютеров. Представлены основные теоретические сведения,
основной алгоритм выполнения задачи, подробное описание процесса
решения типовой задачи, варианты заданий, контрольные вопросы.
Подготовлено на кафедре «Информационно – вычислительные
технологии» и предназначено для студентов специальности 071900
«Информационные системы и технологии» при изучении дисциплины
«Программирование на языке высоеого уровня»; может быть использован
студентами других специальностей при изучении аналогичных дисциплин.
:
© Ю. В Блинков., В. Д. Былкин, 2007
© Пензенский государственный
архитектуры и строительства, 2007
2
университет
ПРЕДИСЛОВИЕ
Руководство по практикуму предназначено для практического изучения
и освоения средств визуального и объектно - ориентированного
программирования в среде Delphi, рассматриваемых в одном из главных
разделов курса «Основы алгоритмизации и программирование», читаемого
студентам специальности 071900 «Информационные системы и
технологии». Практикум может быть использован при изучении
аналогичных дисциплин других специальностей.
Работа содержит методические указания по практическому изучению
следующих тем:
 Изучение основ визуального программирования в среде Delphi.
 Изучение средств управления проектом в среде Delphi.
 Изучение свойств и событий форм приложения в среде Delphi.
 Изучение свойств и методов использования компонентов в среде Delphi.
 Изучение средств создания и использования меню в Delphi проектах.
 Изучение основ печати из Delphi - программ.
 Создание собственных компонентов в среде Delphi.
 Изучение средств отладки программ в среде Delphi.
 Изучение структуры и принципов построения приложений с
многодокументальным интерфейсом MDI.
 Изучение основ создания справочной системы приложения в Delphi.
 Приложение. Краткие сведения по языку Object Pascal.
Каждая тема содержит основные теоретические сведения, алгоритм
выполнения задания, подробные примеры с иллюстрациями, варианты
заданий и контрольные вопросы.
ВВЕДЕНИЕ
Эволюция технических и программных средств персональных
компьютеров привела к повсеместному вытеснению ОС MS-DOS
значительно более мощными системами Windows, программирование для
которых существенно сложнее. Разработчики систем программирования, и
прежде всего такие корпорации, как Microsoft и Borland, не замедлили
выпустить соответствующие средства: уже в 1991 году, т. е. сразу после
появления Windows 3.1, Borland выпустила Turbo Pascal for Windows, а в
1992 - усовершенствованную версию этой системы программирования Borland Pascal with Objects 7.0. Эти средства требовали основательного
знания Windows и были сложны в освоении. В 1993 году Microsoft
выпустила первую визуальную среду программирования Visual Basic, и
программирование для Windows стало даже проще, чем программирование
для MS-DOS. Borland в 1995 году выпустила первую версию Delphi, а затем
версии: 2, 3, 4, 5, 6, 7.
Признано, что лучшим языком для изучения и освоения
программирования является Паскаль, а лучшей в мире системой
программирования для MS-DOS - Turbo Pascal. Delphi продолжила серию
Паскаль - ориентированных средств программирования и, по глубокому
убеждению профессионалов, является наиболее удобным инструментом
для Windows-программирования.
Каждая новая версия Delphi по своим возможностям мощнее
предыдущей, но требует использования более мощных компьютеров.
Однако практика показала, что версия 3 Delphi является одной из наиболее
надежной, не требует слишком мощных компьютеров и одновременно
имеет в наличии все средства визуального и объектно – ориентированного
программирования, наиболее необходимые для создания большинства
серьезных программных проектов. Кроме того, освоив эту версию, легко
перейти к другим. Именно эти факторы заставили авторов при выборе
основной среды программирования, используемой при выполнении
практикума, остановиться на версии Delphi 3.
Прежде всего это лишь практикум, т. е. книга, в которой описываются
самые общие приемы программирования с помощью Delphi. Она
рассчитана, в основном, на начинающих программистов, во всяком случае
ее освоение не требует специальных знаний ни в области
программирования, ни в области Windows, хотя умение работать с
Windows на уровне пользователя - обязательное условие
В первых пяти темах дается знакомство со средой Delphi и основами
построения и управления программным проектом. Изложенный в них
материал позволит «видеть» систему целиком и научит создавать
несложные проекты.
4
Следующие пять тем посвящены изучению более сложных средств,
которые наиболее часто встречаются в практике программирования.
Приложение посвящено языку программирования Object Pascal, без
детального знания которого эффективная работа с Delphi невозможна.
Фактически все основные синтаксические конструкции и операторы
этого языка описываются в довольно небольшом по объему и насыщенной
короткими учебными примерами приложении, которое сделано таким
образом, что при необходимости может быть использовано как отдельная
тема, посвященная изучению языка программирования Object Pascal.
5
1 ИЗУЧЕНИЕ ОСНОВ ВИЗУАЛЬНОГО ПРОГРАММИРОВАНИЯ
В СРЕДЕ DELPHI
Цель
работы:
изучение
программирования в среде Delphi.
основных
средств
визуального
1.1 МЕТОДИКА ВЫПОЛНЕНИЯ РАБОТЫ
1.1.1 Основы визуального программирования
В основе создания Delphi-приложений лежит несколько простых идей.
Начиная работать с Delphi, вы должны:
1. Уяснить задачу, которую собираетесь решать на компьютере.
2. Разработать спецификацию алгоритма. В первом приближении это
требует нарисовать на бумаге все то, что предполагается увидеть на экране
в процессе решения. Если задача сложная, ее следует разбить на этапы и
для каждого этапа нарисовать собственный рисунок.
3. Написать сценарий работы будущей программы. В сценарии должно
быть учтено все: что выводится на экран вначале, что делается потом, как
программа завершается и т.д. Декорациями сценария служат нарисованные
в пункте 2 рисунки.
Реализуем все эти пункты для какой-нибудь простой задачи. Например,
создадим программу вычисления суммы двух целых чисел по простой
формуле C=A+B, причем, каждое из слагаемых должно вводиться в своем
окне, а вывод - в специальном окне вывода. Задача крайне простая, но на
ней проще всего изучить начала визуального программирования.
Нарисуем рисунок, на фоне которого будет проходить компьютерное
решение. На нем будут три редактируемых поля - два для ввода
переменных A и B и одно для вывода результата C - и две кнопки - для
запуска вычислений (ОК) и выхода из приложения (Закрыть) (рис. 1.1).
Рисунок в целом называется формой, а поля ввода, вывода, кнопки и
все прочее, что располагается на форме - компонентами. Нетрудно
заметить, что компоненты на рисунке - разные. Это блоки редактора,
надписи, кнопки. Они могут иметь разные местоположения и размеры, их
текст может отличаться высотой, шрифтом, цветом и др. Каждый
компонент характеризуется рядом признаков, которые называются
свойствами.
Для решения задачи может потребоваться несколько форм. Та форма,
из которой вызываются все остальные, называется главной. Все другие
формы - дочерние. Главная форма в задаче присутствует всегда, дочерних
6
может не быть или быть несколько. В нашем случае достаточно одной
формы.
Выполним пункт 3 - напишем сценарий работы программы. Сразу
после старта программы на экране появляется форма. Пользователь
начинает вычисления: щелкает мышью на блоках редактора с надписями
Введите А, Введите В и вводит значения переменных, затем нажимает
кнопку ОК. Программа реагирует на это событие: вычисляет С и выводит
результат в блок с надписью Результат С. Когда пользователь увидит
результат, он нажмет кнопку Закрыть. В ответ на это событие приложение
уберет с экрана свою форму и закончит работу.
Рис. 1.1
Описанный процесс «событие - отклик - событие - отклик» называется
управлением по событиям, он лежит в основе работы всех Windowsприложений.
При этом:
 Визуальная среда строит по вашим указаниям форму со всеми
компонентами и формирует исходный код соответствующей
программы.
 Программист дописывает на языке Object Pascal детали программы процедуры обработки событий. Он делает это во встроенном в
визуальную среду редакторе кода. Главное событие нашей программы нажатие кнопки ОК. Обработка этого события - кодирование формулы
С=А+В, вывод результата в окно вывода.
 Визуальная среда по команде программиста компилирует весь
исходный код и запускает программу.
Такое распределение работы отражено в структуре самого Delphiприложения, которое состоит из нескольких частей. Важнейшие из них:
файл исходного кода на языке Object Pascal (основа Delphi + ваша
7
детализация) и файл формы (его тоже создает Delphi). Эти файлы и ряд
других, которые также нужны для решения задачи, составляют проект. Для
каждой отдельной задачи создается свой проект. Все подробности о
составе проекта вы узнаете в следующей лабораторной работе.
Только что рассмотренные принципы являются основой используемой
в Delphi технологии визуального и объектно-ориентированного
(компонентного) программирования. Имейте в виду, что среда Delphi
содержит богатый инструментарий различного назначения, и изучение его
в полном объеме - трудоемкая задача.
Рис. 1.2
1.1.2 Среда визуальной разработки
После запуска Delphi вы сразу попадете в визуальную среду (рис. 1.2) и
увидите основные области - формы, компонентов и свойств, а также панель
инструментов и окно редактора кода.
При проектировании из области «компоненты» надо с помощью мыши
взять компонент (кнопку, надпись, строку редактора и т.д.), поместить его
на форму и задать значения его свойств в области «свойства». Это основа
любой программы. Delphi проанализирует содержимое формы, создаст
8
соответствующий программный код, а программисту останется только
создать обработчики событий применительно к форме и компонентам.
Здесь главная часть — форма. Она имеет заголовок Form1, пока пуста и
будет заполняться в процессе создания программы.
Форма имеет все признаки «главного окна» традиционных Windowsприложений - заголовок, кнопки «Свернуть», «Развернуть», «Закрыть»,
размерную рамку - и управляется мышью.
Под формой спрятано окно Редактора Кода (рис. 1.3): в нем Delphi
размещает Pascal-код, соответствующий содержанию формы. Активизация
Редактора Кода осуществляется щелчком мыши на части окна, которая
выглядывает из-под формы. В Редакторе Кода вы выполняете свою часть
работы — дописываете детали решения задачи. Для возврата «в форму»
достаточно поместить курсор мыши над заголовком формы и щелкнуть
левой кнопкой.
Рис. 1.3
Компоненты, которые будем размещать на форме, находятся в области
главного окна визуальной среды, которая называется Палитрой
Компонентов (рис. 1.4).
Рис. 1.4
9
В Палитре Компонентов размещен оптимальный набор компонентов,
достаточных для создания любых приложений: меню, кнопки, надписи,
стандартные диалоговые окна и т.д.
Как видно на рисунке, все множество компонентов подразделяется на
несколько групп. Каждая группа размещена в Палитре Компонентов на
своей странице.
Для перехода между страницами достаточно щелкнуть мышью на
соответствующей закладке.
Кратко рассмотрим содержание каждой страницы.
Standard. Содержит набор основных управляющих элементов
пользовательского интерфейса: главное меню, всплывающее меню,
текстовую надпись, блок однострочного редактора, блок многострочного
редактора, кнопку, блок списка и т.д.
Additional. Содержит дополнительные управляющие элементы: кнопку
с картинкой, кнопку панели инструментов, блок маскирующего редактора,
таблицу, картинку, геометрическую фигуру, прокручиваемую область и т.д.
Win95. Набор новых компонентов Windows 95: блок закладок,
многостраничный блок, дерево элементов, редактор форматированного
текста, строка состояния, шкала, кнопки инкремента-декремента и т.д.
Data Access. Группа невизуальных компонентов, обеспечивающих
доступ к базам данных, включая работу на уровне таблиц и записей,
составление и выполнение SQL-запросов, генерацию отчетов и т.д.
Data Controls. Набор визуальных компонентов для отображения
данных. Они представляют собой расширения стандартных управляющих
элементов формы для совместного использования с невизуальными
компонентами доступа к данным.
Win 3.1. На этой странице находятся компоненты, которые служат
лишь для совместимости с Delphi 1.0.
Dialogs. Набор компонентов, реализующих стандартные диалоговые
окна Windows, такие как окна открытия и сохранения файла, выбора
шрифта, цвета, окна запуска печати и настройки принтера и т.д.
System. Содержит системные компоненты, предназначенные для
управления таймером, файлами, средствами мультимедиа, DDE и другими
системами.
QReport. Содержит компоненты для облегченного создания
встроенных отчетов по базам данных.
ОСХ. Содержит несколько мощных ОСХ-компонентов для создания
диаграмм, графиков, электронных таблиц, проверки правописания и т.д.
Samples. Включает образцы компонентов, которые не слишком
сложны для того, чтобы с их исходными текстами можно было
разобраться. Среди них - градусник, календарь и т.д.
10
Если этих компонент мало, можно разработать свои собственные,
купить готовые ОСХ-компоненты или специализированные библиотеки
компонентов для Delphi. Кроме того, каждая новая версия Delphi
предлагает прежде всего более богатую Палитру Компонентов.
Рис. 1.5
Для выбора и включения нужного компонента в форму:
 выберите щелчком мыши на закладке нужную страницу в Палитре
Компонентов;
 щелкните мышью на нужном компоненте;
 переместите курсор в нужное место формы и щелкните мышью компонент на форме, он активен (или, как говорят, сфокусирован);
 с помощью мыши придайте ему нужные размеры (растягивая по высоте
и ширине) и откорректируйте его местоположение, используя
имеющуюся на форме сетку (рис. 1.5).
Компонент на форме, зададим его свойства. Список свойств
представлен в окне Инспектора Объектов (расположено слева от формы)
(рис. 1.6):
Как только какой-либо компонент появится на форме, в Инспекторе
Объектов будет выведен список его свойств. Остается только присвоить
свойствам нужные значения.
Например, чтобы написать на кнопке слово ОК, достаточно изменить
значение свойства Caption, которое по умолчанию содержит текст Button 1.
По мере набора строки каждая буква будет автоматически появляться на
кнопке.
11
Инспектор Объектов состоит из двух страниц: страницы свойств —
Properties и страницы событий — Events. Если выбрана страница Properties,
— устанавливаются свойства выбранного компонента.
Когда значения свойств определены, активизируйте страницу Events,
тогда и увидите в Инспекторе Объектов список событий, на которые
компонент может реагировать. Приведем список событий, на которые
может реагировать кнопка (рис. 1.7).
Рис. 1.6
Очевидно, что в представленном списке нас интересует событие
OnClick (отклик на нажатие кнопки).
Для управления процессом создания приложения служит главное меню
(рис. 1.8.).
Оно расположено в главном окне Delphi и выполняет ряд функций.
Меню выполнено в традиционном стандарте Windows. Кратко
рассмотрим назначение его важнейших режимов:
•File — работа с файлами (создание и сохранение проектов, форм,
файлов).
•Edit — работа с Буфером Обмена, размещение, упорядочивание,
выравнивание компонентов на форме.
•Search — поиск, замена заданного символа или строки в тексте.
•View — отображение различной информации, вызов Менеджера
Проекта, Инспектора Объектов и других информационных окон.
12
•Project — управление текущим проектом: добавление и удаление
файлов, компиляция и сборка проекта, проверка синтаксиса, установка
параметров проекта.
•Run — выполнение проекта, задание параметров командной строки,
управление отладкой.
Component - разработка нового компонента и его инсталляция,
управление отладкой.
Рис. 1.7
рис. 1.8
Рис. 1.9
Database - запуск утилиты Database Exploler, вызов подсистемы
Database Form Expert, облегчающей построение Database - приложений.
13
Tools — настройка параметров среды, запуск Image Editor и других
утилит, которые могут пригодиться в процессе разработки программ,
Workgroups - настройка среды для работы коллектива программистов
над большим проектом;
Help — получение справочной информации.
Для ускорения доступа к режимам слева от главного меню
расположена панель инструментов (рис. 1.9). В ней есть 14 кнопок—
аналогов основных команд меню. Этот список можно расширить, добавив
кнопки доступа к отдельным режимам. Для этого достаточно установить
курсор мыши на панель инструментов, щелкнуть правой кнопкой мыши и в
появившемся локальном меню выбрать команду Configure.
Не забывайте, что назначение каждого из рассмотренных выше
средства в процессе работы всегда можно уточнить по «всплывающей»
подсказке, появляющейся при размещении указателя курсора над каждым
из этих средств.
1.1.3 Проектирование простого приложения
Реализуем программу по сценарию, отображенному на рис. 1.1. Начнем
с кнопок. Переместите курсор мыши в Палитру Компонентов и щелкните
на пиктограмме Button.
Затем переместите курсор в нужное место формы и щелкните еще раз.
Заготовка кнопки с надписью Button1 окажется на форме (рис. 1.5).
Рис. 1.10
14
С помощью мыши откорректируйте ее местоположение. После этого
посмотрите на Инспектор Объектов. Там вы увидите список свойств
компонента Button. В нем нас интересует свойство Caption, так как именно
оно определяет содержимое надписи. Заменим в Caption стандартное
значение Button1 на ОК (рис. 1.10)
Далее на форму помещается вторая кнопка с надписью Закрыть.
Обратите внимание, что Delphi сама присвоила кнопкам имена
(свойство Name) Button1 и Button2.
Теперь установим поля ввода и вывода. Для этого перейдем к Палитре
Компонентов.
Найдите на странице Standard по всплывающей подсказке компонент
Edit, который лучше всего отвечает нашим целям, щелкните на нем
мышью, переместите курсор в нужное место формы и щелкните еще раз.
На форме появится блок редактора, содержащий текст Edit1.
Придайте ему нужные размеры и откорректируйте местоположение.
Вернувшись в Инспектор Объектов, удалите в свойстве Text ненужное
значение Edit1, и окно редактора на форме очистится (рис. 1.11).
Рис. 1.11
Далее левее окна ввода нужно поместить надпись «Введите А». Для
этого найдите компонент Label на странице Standard Палитры Компонентов
и с помощью мыши поместите в нужное место. Первоначально он
содержит надпись Label1. Для замены ее на требуемую в свойстве Caption
впишите то, что нужно (рис. 1.12).
15
Рис. 1.12
Рис. 1.13
16
Точно так же поместите окна для ввода В и для вывода результата
вычислений С, а также требуемые для них надписи, после чего вы
получите форму, отвечающую сценарию работы программы.
Активизируем форму и присвоим ее свойству Caption значение
«Вычислитель суммы А и В» - и оно появится в самой верхней части
формы.
В результате получилась основа для будущей программы (рис. 1.13),
которая пока не работает, т.к. для кнопок нет обработчиков событий.
Обратите внимание, что Delphi сама присвоила окнам редактора имена
(свойство Name) Edit1, Edit12 и Edit3, а надписям слева от них - имена
Label1, Label2 и Label3.
Приступим к созданию обработчиков событий. Начнем с кнопки ОК.
Прежде всего активизируйте кнопку и перейдите на страницу событий
(Events) Инспектора Объектов. На ней есть список всех возможных
событий для активного компонента. Нас интересует событие OnClick,
возникающее при нажатии кнопки. Чтобы создать обработчик этого
события, сделайте двойной щелчок мыши в поле значения события
OnClick. В ответ появится окно Редактора Кода с заготовкой обработчика
событий и указателем курсора в позиции требуемого ввода кода
обработчика события (рис. 1.14).
Рис. 1.14
Для реализации алгоритма вычисления С=А+В достаточно вставить
одну строку кода между операторными скобками begin - end;
Edit3.Text:=IntToStr(StrToInt(Edit1.Text)+StrToInt(Edit2.Text));
Здесь Edit1, Edit2, Edit3 - имена окон ввода и вывода в программе, а
Text - имена полей этих окон, в которые помещаются данные.
Одновременно Text - это свойство полей, обозначающее тип вводимых в
них данных, т.е. имеется в виду, что вводимые данные А и В в окнах Edit1
и Edit2 имеют тип Text и непосредственно для арифметических операций
не пригодны.
17
Для преобразования типа Text в целое число служит стандартная
функция StrToInt (см. приложение). Только после такого преобразования
типов данных содержимое первых двух окон может быть просуммировано.
Результат суммирования есть целое число, которое может быть
выведено в окно Edit3 только после обратного преобразования типов
данных - из целого в текст - с помощью стандартной функции IntToStr. Имя
обработчику события Button1Click система присвоила сама. Более
подробную информацию о стандартных функциях преобразования типов
данных смотрите в приложении к данной работе.
Для кнопки Закрыть обработчик события устанавливается аналогично.
Обработчику события система присвоит имя Button2Click, а текст,
вставляемый между операторными скобками, еще проще и имеет вид
begin
Close;
end;
где Close - cтандартный метод завершения всех программ. В данном
случае он закрывает форму и завершает приложение.
Теперь требуется сохранить результат работы. Для этого нужно
выбрать команду меню File | Save all . Сначала система предложит ввести
имя для модуля формы, а затем - имя для всего проекта. Напоминаем, что
эти имена могут быть набраны только в латинском алфавите.
Все файлы, относящиеся к проекту, будут записаны на диск по
заданному маршруту. Для удобства рекомендуем для каждого проекта
создавать свой каталог. Сохраненный проект может быть открыт для
доработки в любое время.
1.1.4 Компиляция и проверка работоспособности
программы
Теперь можно проверить программу в работе. Для этого
откомпилируйте и запустите ее на выполнение командой меню Run | Run.
Если при написании обработчиков событий были допущены ошибки,
компилятор выдаст соответствующие сообщения и остановит программу
на операторе с ошибкой. Если компиляция прошла успешно, на экране
появится форма спроектированного приложения, но без сетки координат.
Поочередно активизируйте мышью окна ввода и введите в них слагаемые целые числа, после чего мышью щелкните на кнопке ОК. Если вы
правильно набрали код обработчика события кнопки, в окне результата
появится целое число, равное сумме введенных слагаемых.
Попробуйте ввести вместо целых чисел другие типы данных, например
строковые, и нажмите клавишу ОК. При этом на экране появится
сообщение об ошибке и программа временно прекратит работу. Причина:
при попытке обработать вместо целого числа строку система попала в
18
исключительную ситуацию, с некоторыми из которых справляется Delphi, а
в некоторых случаях об их обработке должен позаботиться программист.
Однако это - отдельная большая тема.
1.2 ПОРЯДОК ВЫПОЛНЕНИЯ РАБОТЫ
 Изучить основы визуального программирования в среде Delphi.
 Изучить основы создания обработчиков событий.
 Изучить основы компиляции и проверки работоспособности программ.
 Ответить на контрольные вопросы.
 Пользуясь своим вариантом задания, разработайте спецификацию
проекта с изображением главной формы и всех элементов управления
со всеми надписями.
 Пользуясь визуальными средствами Delphi и своим вариантом задания,
создайте проект, откомпилируйте его и проверьте в работе (варианты
заданий - предельно простые).
 Составить отчет по лабораторной работе.
В отчет должны входить следующие пункты:
 Цель работы.
 Описание основных средств визуального программирования.
 Описание процесса разработки программы по заданному варианту.
 Результаты проверки программы.
 Вывод о проделанной работе.
1.3 КОНТРОЛЬНЫЕ ВОПРОСЫ
Какие средства являются основой визуального программирования в
среде Delphi?
 Какие задачи решает среда Delphi в процессе программирования?
 Какие задачи решает программист в процессе программирования?
 Как помещаются на форму и настраиваются компоненты?
 Как создаются обработчики событий?
 Как осуществляется компиляция и проверка функционирования
проекта?
 Как реагирует программа на ввод неправильных данных?
 Как записать проект на диск?
1.4 ВАРИАНТЫ ЗАДАНИЙ.
Используя среду визуального программирования, создайте сценарий и
спроектируйте простую программу для вычисления:
1.С=А+В+С. А,В,С - целые числа.
2.С=А+В+С. А,В,С - вещественные числа.
19
3.С=А*В. А,В,С - целые числа.
4.С=А*В. А,В,С - вещественные числа.
5.С=(А+В)*(В-С). А,В,С - вещественные числа.
6.С=(А+В)*(В-С). А,В,С - целые числа.
7.С=(А+В)/(В-С). А,В,С - вещественные числа.
8.С=(А-В)*(В+С). А,В,С - вещественные числа.
9.С=(А-В)/(В-С). А,В,С - целые числа.
10. С=(А-В)*(В+С). А,В,С - целые числа.
11.Более сложные варианты по согласованию с преподавателем.
Для преобразования типов данных используйте стандартные функции
для работы со строками, приведенные в Пояснении к теме.
1.5 ПОЯСНЕНИЕ К ТЕМЕ. НЕКОТОРЫЕ СТАНДАРТНЫЕ ФУНКЦИИ ДЛЯ
РАБОТЫ СО СТРОКАМИ.
Str(X [: Width [: Decimals] ], var S: string) — преобразует числовое
значение величины X в строку S. Необязательные параметры Width и
Decimals являются целочисленными выражениями. Значение Width задает
ширину поля результирующей строки. Значение Decimals используется с
вещественными числами и задает количество символов в дробной части.
Примеры:
Выражение
Значение S
Str(-200, S);
'-200'
Str(200 : 4, S);
' 200'
Str(1.5E+02 : 4, S);
' 150'
Val(S: string, var V; var Code: Integer) — преобразует строку S в
величину целого или вещественного типа и помещает результат в
переменную V. Если во время операции преобразования ошибки не
обнаружено, значение переменной Code равно нулю; если ошибка
обнаружена (строка содержит недопустимые символы), Code содержит
номер позиции первого ошибочного символа, а значение V не определено.
Примеры:
Выражение
Значение V
Значение Code
Val('100', V, Code):
100
О
Val('2.5E+01', V, Code);
25.0
О
Val('2.5A+01', V, Code);
?
4
IntToStr(Value: Longint): string — преобразует целое число Value в
строку.
StrToInt(const S: string): Longint — преобразует строку в число. Если
строка не может быть преобразована в число, функция генерирует
исключительную
ситуацию
класса
EConvertError
(обработка
исключительных ситуаций рассматривается в одной из следующих работ).
20
StrToIntDef(const S: string; Default: Longint): Longint — преобразует
строку в число. Если строка не может быть преобразована в число,
функция возвращает число, заданное в параметре Default.
FloatToStr(Value: Longint): string — преобразует вещественное число
Value в строку.
StrToFloat(const S: string): Longint — преобразует строку в
вещественное число. Если строка не может быть преобразована в число,
функция генерирует исключительную ситуацию класса EConvertError
(обработка исключительных ситуаций рассматривается в приложении).
21
2 ИЗУЧЕНИЕ СРЕДСТВ УПРАВЛЕНИЯ ПРОЕКТОМ В СРЕДЕ
DELPHI
Цель работы: изучение структуры приложения и средств управления
проектом в среде программирования Delphi.
2.1 МЕТОДИКА ВЫПОЛНЕНИЯ РАБОТЫ
2.1.1 Структура проекта в Delphi
В основе любого Delphi-приложения лежит проект. Его основой
является форма, на которую помещаются необходимые для решения
конкретной задачи компоненты.
Проект в Delphi состоит из трех основных типов файлов:
Файлы описания форм - двоичные файлы с расширением DFM,
описывающие формы с компонентами. В них запоминаются начальные
значения свойств, установленные в Инспекторе Объектов.
Файлы программных модулей - текстовые файлы с расширением PAS,
содержащие исходные коды программных модулей на языке Object Pascal.
В этих файлах вы пишете методы обработки событий, генерируемых
формами и компонентами.
Главный файл проекта - текстовый файл с расширением DPR,
содержащий главный программный блок. Он подключает все
используемые программные модули и содержит операторы для запуска
приложения. Этот файл среда Delphi создает и контролирует сама.
Рис. 2.1
Схема формирования Delphi-приложения и постановки задачи до
получения готового выполняемого файла показана на рис. 2.1:
Рассмотрим назначение и содержимое каждого типа файлов,
составляющих проект. Для этого можно воспользоваться любым ранее
созданным проектом. Для открытия ранее сохраненного на диске проекта
достаточно выполнить команду главного меню File/Open. На экране
22
появится окно диалога, где следует выбрать из представленного списка
каталог и имя загружаемого проекта.
2.1.1.1
Файлы описания форм.
Первая составная часть проекта - двоичный файл с расширением DFM,
описывающий форму. В нем сохраняются все установки свойств формы и
ее компонентов, сделанные во время проектирования приложения.
Количество DFM-файлов равно количеству используемых в приложении
форм. DFM-файл является описательным, т. к. в нем хранятся исходные
значения для свойств формы и ее компонентов, заданные вами в
Инспекторе Объектов. Хотя сам DFM- файл - двоичный, у него существует
текстовое представление. Вызовите у формы всплывающее меню щелчком
правой кнопки мыши и выберите команду View as Text (рис. 2.2).
Рис. 2.2
В ответ Delphi заменит графическое изображение формы на текст в
редакторе кода, который система формирует автоматически в процессе
визуального программирования.
Здесь задаются исходные значения для свойств формы Form1 и ее
компонентов. Большего знать не требуется, поскольку вы всегда будете
использовать визуальные средства проектирования и работать с
графическим представлением формы, а не с ее текстовым описанием.
Вернемся к графическому представлению формы. Для этого вызовите
всплывающее меню редактора кода и выберите команду View As Form
(рис. 2.3). На экране вновь появится графический образ формы. Если вы
внесли в текст корректировки, они отразятся на внешнем виде формы.
DFM-файл нужен только на этапе проектирования, т.к. при сборке
приложения данные из него помещаются в область выполняемого ЕХЕ модуля.
23
Рис. 2.3
2.1.1.2
Файлы программных модулей
Каждой проектируемой форме соответствует свой программный
модуль (unit), содержащий все относящиеся к ней объявления и методы
обработки событий, написанные на языке Object Pascal. Программные
модули размещают в отдельных файлах с расширением PAS. Их
количество может превышать количество форм, т.к. PAS-модули могут
содержать описание других процедур, функций, объектов и т.д. Пример
программного модуля - ниже:
unit Unitl;
interface
uses
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls;
type
{ Описание класса, соответствующего форме }
TForm1 = class(TForm)
Button1: TButton;
Button2: TButton;
Editl: TEdit;
Edit2: TEdit;
Edit3: TEdit;
Label1: TLabel;
Label2:Tlabel1;
Label3:Tlabel1;
procedure Button1Click(Sender: TObject);
procedure Button2Click(Sender: TObject);
24
private
{ Private declarations }
public
{Public declarations}
end;
var
Form1:TForm1;{экземпляр класса}
implementation
{$R*.DFM} {подключение двоичного образа формы}
procedure TForm1.Button1Click(Sender:Tobject);
begin
{Реализация алгоритма}
end;
procedure TForm1.Button2Click(Sender:Tobject);
begin
{Реализация алгоритма}
end;
В начале после слова unit записывается имя модуля:
unit Unitl;
Ни в коем случае не изменяйте это имя вручную. Delphi требует, чтобы
имя модуля совпадало с именем файла, поэтому если вы хотите
переименовать модуль, сохраните его в файле с новым именем,
воспользовавшись командой меню File|Save As. Delphi сама подставит
после слова unit новое имя. После этого удалите старый модуль.
Содержание интерфейсной секции модуля (interface) начинается с
подключения стандартных модулей библиотеки VCL, в которых
определены часто вызываемые подпрограммы и классы помещенных на
форму компонентов.
Uses
Windows,. Messages, SysUtils, Classes, Graphics, Controls, Forns,
Dialogs, StdCtrls;
Delphi формирует список модулей самостоятельно и автоматически
пополняет его, когда вы добавляете на форму новые компоненты, но это
можно делать вручную.
В разделе описания типов (type) объявлен класс формы. По умолчанию
он называется TForm1 и порожден от стандартного класса TForm:
type
TForm1= class(TForm)
Button1: TButton;
25
Button2: TButton;
Editl: TEdit;
Edit2: TEdit;
Edit3: TEdit;
Label1: TLabel;
Label2:Tlabel1;
Label3:Tlabel1;
procedure Button1Click(Sender:Tobject);
procedure Button2Click(Sender:Tobject);
private
{Private declarations}
public
{Public declarations}
end;
Помещенные на форму компоненты представлены полями формы. У
нас на форме восемь компонентов, поэтому и полей в описании класса тоже восемь. Имена полей совпадают с именами компонентов, заданными
в окне Инспектора Объектов.
После полей идут заголовки методов обработки событий. Название
каждого такого метода Delphi формирует автоматически на основании
имени компонента и имени генерируемого им события. Например, для
кнопки Button1 метод обработки события OnClick называется Button1Click.
Обратите внимание, что поля, представляющие компоненты формы, а
также методы обработки событий получают атрибут видимости published
(он принимается по умолчанию для всех наследников TForm). Благодаря
этому вы можете работать с ними на визуальном уровне, например видеть
их имена в окне Инспектора Объектов. Поскольку Delphi умеет понимать
содержимое секции published на этапе проектирования, никогда не
модифицируйте эту секцию вручную, а пользуйтесь визуальными
инструментами: Палитрой Компонентов и Инспектором Объектов.
Запомните: когда вы помещаете на форму компоненты, Delphi сама
добавляет в описание класса соответствующие поля, а когда вы удаляете
компоненты с формы, Delphi удаляет их поля из описания класса; когда вы
определяете в форме или компонентах обработчики событий, Delphi сама
определяет в классе соответствующие методы, а когда вы удаляете весь
код из методов обработки событий, Delphi удаляет и сами методы.
Для удобства в классе формы заранее объявлены пустые секции private
и public, в которых вы можете размещать любые вспомогательные поля,
методы и свойства, но с ними можно работать только на уровне
программного кода, т.е. в Редакторе Кода.
После описания класса идет объявление собственно объекта формы:
26
var
Form1: TForm1;
Form1-это переменная, которая содержит ссылку на объект класса
TForm1. Конструирование объекта Form1 выполняется в главном файле
проекта -DPR-файле.
На этом содержание интерфейсной секции модуля заканчивается и
начинается секция реализации (implementation). Сначала в ней
подключается файл описания формы:
{$R*.DFM}
Эта директива компилятора подключает лишь один DFM-файл, в
котором описана форма данного модуля. Имя DFM-файла получается
заменой звездочки на имя модуля, в котором записана директива.
Далее следует реализация методов обработки событий. Пустые
заготовки для них Delphi создает одновременно с добавлением заголовков
в класс формы. Вы же начиняете их операторами.
porocedure TForm1.ButtonlClick(Sender:TObject);
begin
(Реализация алгоритма обработки события}
end;
procedure TForm1.Button2Click(Sender: TObject) ;
begin
{Реализация алгоритма обработки события}
end;
Если вы хотите удалить метод обработки события и убрать ссылки на
него, просто сделайте метод пустым, удалив весь код. При сохранении или
компиляции проекта Delphi выбросит из текста пустые методы.
Теперь выясним, как обеспечивается вызов методов Button1Click и
Button2Click при нажатии на форме кнопок.. Для этого заглянем в текст
DFM-файла (рис. 2.3). Кроме установки значений свойств вы найдете там
установку обработчиков событий.
object Button1: TButton
..........
OnClick = Button1Click
end
object Button2: TButton
.............
OnClick = Button2Click
End.
27
Благодаря этому обеспечивается привязка методов формы к
соответствующим событиям. Cмысл приведенного фрагмента описания
становится более понятным, если иметь в виду, что события в языке Object
Pascal - это на самом деле свойства, но их значениями являются указатели
на методы. Таким образом, установка событий мало чем отличается от
установки свойств формы, т.к. по природе это одно и то же.
2.1.1.3
Главный файл проекта
Файл проекта с расширение DPR (сокращение от Delphi Project),
представляет собой главный программный файл на языке Object Pascal,
который с помощью оператора uses подключает все файлы модулей,
входящих в проект. Для каждого проекта существует только один DPRфайл.
Когда вы по команде File/New Application начинаете разработку нового
приложения, среда Delphi автоматически создает файл проекта. По мере
создания новых форм содержимое этого файла видоизменяется
автоматически. Перед компиляцией проекта в DPR-файле будет находиться
перечень всех программных модулей проекта. Чтобы увидеть содержимое
DPR-файла, выберите в меню Delphi команду View/Project Source. В
Редакторе Кода появится страница со следующие текстом:
program Project1;
uses
Forms,
Unit1 in ‘Unit1.pas’ {Form1};
{$R *.RES}
begin
Application.Initialize;
Application.CreateForm(TForm1,Form1);
Application.Run;
end.
Подключение модуля Forms обязательно для всех программ, так как в
нем содержится определение объекта Application. Этот объект лежит в
основе любого Delphi-приложения и доступен на протяжении всей его
работы.
Модуль Unit1 содержит определение формы приложения. Название
формы приводится в фигурных скобках. Директива in указывает на то, что
модуль является необходимой частью проекта и существует в виде
исходного текста на языке Object Pascal.
28
Деректива {$R *.RES} подключает к ЕХЕ - файлу так называемые
ресурсы, в данном случае - значок приложения, который будет виден на
Панели задач Windows.
Далее следует главный программный блок, содержащий вызовы трех
методов объекта Application. Вызов метода Initialization подготавливает
приложение к работе, метод GreateForm загружает и инициализирует
форму Form1, а метод Run активизирует форму и начинает выполнение
приложения. Фактически время работы метода Run - это время работы
приложения. Выход из метода Run происходит тогда, когда пользователь
закрывает главную форму приложения, и приложение завершается.
Никогда не изменяйте DPR-файл вручную. Это делает Delphi.
Добавление и удаление модулей, а также управление созданием форм
осуществляется с помощью команд и диалоговых окон визуальной среды.
2.1.1.4
Другие файлы проекта
Кроме рассмотренных выше существует ряд дополнительных файлов:
Файл ресурсов с расширением RES (сокращение от RESource). В нем,
например, хранится пиктограмма приложения, которая будет видна на
Панели Задач Windows.
Подключаемые в модулях объектные файлы с расширением OBJ,
написанные на других языках, например на C++.
Файл опций с расширением DOF (сокращение от Delphi Options File),
где сохраняются заданные программистом параметры компиляции и
компоновки проекта.
Файл с расширением DSK (сокращение от DeSKtop), где размещены
настройки визуальной среды, используемые с данным проектом. (Чтобы
Delphi сохраняла настройки среды в DSK-файле, выберите в меню команду
Tools|0ptions... и в диалоговом окне Environment Options на странице
Preferences в группе Autosave options отметьте пункт Desktop.)
В проект могут входить также логически автономные элементы:
точечные рисунки (ВМР-фаилы), значки (ICO-файлы), файлы
справочников (HLP-файлы) и т.п., однако ими управляет сам программист.
Уточненная схема структуры проекта показана на рис. 2.4.
2.1.2 Создание, сохранение и открытие проекта
При старте Delphi автоматически создается новый проект. Если
требуется создать новый проект, не перегружая Delphi, выполните команду
меню File|New Application. При этом старый проект будет закрыт, а вместо
него создан новый. В новый проект Delphi всегда помещает чистую форму.
В процессе разработки приложения вы добавляете на форму
компоненты, пишете обработчики событий, добавляете в проект дочерние
формы. Когда часть работы сделана, можно сохранить проект. Для этого
выполните команду главного меню File/Save All. Среда запросит сначала
29
имя для программного модуля с формой, а затем имя для проекта. Если
файл с введенным именем уже есть на диске, Delphi скажет вам об этом и
попросит подтвердить перезапись файла или ввести другое имя.
Если требуется заменить имя проекта на другое, воспользуйтесь
командой меню File/Save Project As.. Если нужно заменить имя модуля,
используйте командой File|Save As....
Для открытия ранее сохраненного на диске проекта достаточно
выполнить команду главного меню File/Open.. На экране появится окно
диалога, где вы должны указать или выбрать из представленного списка
каталог и имя загружаемого проекта.
Рис. 2.4
2.1.2.1
Окно Project Manager
При создании проекта нужно знать, на какой стадии разработки он
находится, каков его состав, уметь активизировать нужный файл, добавить
новый файл или удалить ненужный, установить параметры проекта и т.п.
Для этого в Delphi имеется окно Project Manager (Менеджер Проекта) визуальный инструмент для редактирования главного файла проекта. Он
вызывается из меню командой View|Project Manager, после выбора которой
на экране появится окно со списком форм и программных модулей,
составляющих проект (рис. 2.5):
30
Рис. 2.5
Окно Менеджера Проекта имеет панель инструментов с шестью
кнопками. Их назначение кратко описано в табл. 2.1.
табл. 2.1
Кнопка
Описание
Add
Добавляет модуль в проект.
Remove
Удаляет один или несколько отмеченных модулей из проекта.
Unit
Открывает и отображает текст выбранного модуля в
Редакторе кода.
Form
Отображает визуальный образ формы. Если отмеченный
модуль не связан с формой, кнопка запрещена.
Options
Отображает окно Менеджера Проекта для установки
параметров проекта.
Update
Синхронизирует содержимое окна Менеджера Проекта c
исходным текстом DPR- файла.
2.1.2.2
Настройка параметров проекта в окне Project Options
Установить параметры проекта можно тремя способами:
 вызвать диалоговое окно Project Options и выставить значения в списке
опций;
 присвоить значения директивам в файле опций проекта (DOF-файл);
 задать нужные директивы компилятору непосредственно в исходном
тексте программы.
Какой способ выбрать - зависит от конкретной задачи.
Установить значения параметров можно с помощью диалогового окна
Project Options. Выберите в меню команду Project/Options и щелкните на
соответствующей кнопке в окне Менеджера Проекта. На экране появится
диалоговое окно, вам останется лишь установить в нем нужные значения
31
параметров. Диалоговое окно состоит из нескольких страниц, на них много
параметров. Рассмотрим используемые наиболее часто.
Рис. 2.6
На странице Forms можно задать главную форму приложения (Main
form) и в списке указать формы, которые будут создаваться одновременно
с главной формой (рис. 2.6).
На странице Application задаются название (Title) и значок (Icon)
приложения, которые будут отображаться в среде Windows на Панели
Задач. Здесь же задается имя файла справочника (Help file), который будет
вызываться автоматически при нажатии клавиши F1 (рис. 2.7).
На странице Compiler задаются параметры компилятора. Наиболее
важные из них - Show hints и Show warnings. Включив их, вы будете
получать от компилятора интеллектуальные сообщения и предупреждения
(рис. 2.8).
На странице Linker задаются параметры компоновщика Здесь следует
обратить внимание на параметр Include TDW debug info, управляющий
размещением в результирующем ЕХЕ-файле информации для внешнего
отладчика TurЬо Debugger (рис. 2.9).
На странице Directories/Conditionals (рис. 2.10) можно задать каталог
выхода (Output directory), в котором будет размещен результирующий ЕХЕ
файл, маршруты (Search path), где следует искать исходные файлы
модулей, условные объявления (Conditional defines) для директивы
компилятора SIFDEF.
32
Когда все параметры проекта установлены, можно приступать к его
компиляции.
Рис. 2.7
Рис. 2.8
33
Рис. 2.9
Рис. 2.10
34
2.1.3
Компиляция и сборка проекта
Компиляция может выполняться на любой стадии paзработки проекта.
Уже после первой компиляции вы обнаружите свои первые ошибки.
Основная причина ошибок - неправильное написание имен операторов
и объектов.
Для выполнения компиляции следует выполнить команду меню
Project|Compile или нажать комбинацию клавиш Ctrl+F9. При этом
компилируются все исходные модули, содержимое которых изменялось
после последней компиляции. В результате для каждого программного
модуля создается файл с расширением DCU (сокращение от Delphi
Compiled Unit). Затем Delphi компилирует главный файл проекта и
компонует его (т.е. собирает) из DCU-модулей выполяемый ЕХЕ-файл.
Имя EXE-файла совпадает с именем файла проекта. Компоновщик Delphi
выбрасывает из ЕХЕ - файла весь неиспользуемый программный код,
поэтому не стоит волноваться по поводу лишних объектов, процедур и
функций, которые могут содержаться в подключенных модулях
Кроме обычной компиляции можно выполнить тотальную
компиляцию. Последняя обеспечивает компиляцию абсолютно всех
программных модулей проекта, для которых доступны исходные тексты.
При этом не важно, вносились в них изменения после предыдущей
компиляции или нет. Тотальная компиляция проекта выполняется с
помощью команды главного меню Project|Build All. В результате тоже
формируется EXE-файл, но времени на его получение тратится намного
больше.
2.1.4
Запуск готового приложения
Когда после множества компиляций будут исправлены все ошибки,
можно посмотреть на результат проектирования. Для этого надо выполнить
созданное приложение с помощью команды меню Run|Run или клавиши F9
Перед выполнением будет автоматически повторен процесс компиляции
(если в проект вносились изменения) и после его успешного завершения
приложение запустится на выполнение. В результате вы увидите на экране
его главную форму со всеми встроенными в нее компонентами и сможете
проверить ее работоспособность.
2.2 ПОРЯДОК ВЫПОЛНЕНИЯ РАБОТЫ
 Изучить структуру приложения и средства управления проектом в среде
программирования Delphi.
 Ответить на контрольные вопросы.
 Пользуясь имеющимся в системе проектом, проанализировать его
структуру и свойства всех компонент.
35
 Пользуясь своим вариантом задания, разработайте спецификацию
проекта с изображением главной формы и всех элементов управления
со всеми надписями.
 Пользуясь визуальными средствами Delphi и своим вариантом задания,
создайте проект, откомпилируйте его и проверьте в работе.
 Составить отчет по лабораторной работе.
 В отчет должны входить следующие пункты:
 Цель работы.
 Описание основных средств управления проектом и его структуры.
 Описание результатов анализа существующего проекта.
 Описание процесса разработки алгоритма и программы по заданному
варианту.
 Результаты проверки программы.
 Вывод о проделанной работе.
2.3 КОНТРОЛЬНЫЕ ВОПРОСЫ
 Какие типы файлов используются в Delphi - проекте?
 Основное назначение каждого типа файлов в Delphi - проекте.
 Охарактеризуйте обобщенную структуру Delphi - проекта.
 Какие задачи решает Менеджер Проектов?
 Как загрузить в систему созданный ранее проект?
 Как создать новый проект?
 Как узнать состав и назначение файлов проекта?
 Как установить параметры компиляции и сборки проекта?
 Как запустить проект на компиляцию и выполнение?
2.4 ВАРИАНТЫ ЗАДАНИЙ
1. Спроектировать программу вычисления корней уравнения вида
Ах2+Вх+С=0 по коэффициентам А, В, С.
2.Спроектировать программу вычисления площади прямоугольного
треугольника по катетам А и В.
3.Спроектировать программу вычисления площади равнобедренного
треугольника по основанию А и высоте Н.
4.Спроектировать программу вычисления площади трапеции по высоте
Н и основаниям А и В.
5.Спроектировать программу вычисления объема конуса по высоте Н и
радиусу основания R.
6.Спроектировать программу вычисления корней уравнения вида
(х+А)*(х-А)=0 по А.
36
7.Спроектировать программу - калькулятор на вычисление -, +. *, /. для
целых чисел.
8.Спроектировать программу - калькулятор на вычисление -, +. *, /. для
вещественных чисел.
9.Спроектировать программу - калькулятор на вычисление функций:
степень, корень для целых чисел.
10.Спроектировать программу - калькулятор на вычисление функций:
степень, корень для вещественных чисел.
11.Более сложные варианты по согласованию с преподавателем
37
3 ИЗУЧЕНИЕ СВОЙСТВ И СОБЫТИЙ ФОРМ ПРИЛОЖЕНИЯ В
СРЕДЕ DELPHI
Цель работы: изучение свойств и событий форм приложения Delphi и
приемов их использования при разработке программ.
3.1 МЕТОДИКА ВЫПОЛНЕНИЯ РАБОТЫ
3.1.1 Понятие формы
Форма - это главный компонент приложения, который, как и другие
компоненты, имеет свойства. Важнейшие свойства формы: заголовок,
высота, ширина, местоположение, цвет фона и т.д. Первоначально
визуальная среда Delphi устанавливает свойства формы в значения по
умолчанию, но их можно изменить. Это можно сделать во время
проектирования формы в Инспекторе Объектов, или во время выполнения
приложения с помощью операторов, записанных в исходном тексте
программы.
Рис. 3.1
У формы много свойств, размещенных в окне Инспектора Объектов по
алфавиту. Рассмотрим важнейшие свойства в порядке, в котором обычно
настраивается новая форма.
38
Для изучения свойств формы создадим новое приложение. Выберите в
меню команду File/New Application. Delphi автоматически создаст в новом
проекте чистую форму и поместит в окно Редактора Кода ее исходный
текст (рис. 3.1.). Сразу сохраните проект и его форму, чтобы потом к этому
не возвращаться. Выберите в меню команду File|Save All и дайте модулю
имя MAIN.PAS, а проекту - имя FORMTEST. DPR (имена - только в
латинском алфавите). Теперь можно заняться свойствами формы.
3.1.2
Основные свойства формы
3.1.2.1 Имя и заголовок формы
Главное свойство, с которого начинают настройку формы, - это
свойство Name (имя), которое содержит идентификатор, используемый для
обращения к форме из программы.
Рис. 3.2
По умолчанию первой форме нового проекта назначается имя Form1.
Его следует изменять, чтобы имя формы отражало ее роль в приложении.
Например, главную форму приложения можно назвать MainForm (рис. 3.2).
Свойство Name есть у любого компонента и оно редактируется в окне
Object Inspector. Осмысленные имена следует давать всем компонентам.
Каждая форма приложения должна иметь оригинальный заголовок,
чтобы пользователь мог быстро и безошибочно отыскать ее на экране
среди других. Заголовок задается в свойстве Caption. Можно дать нашей
форме заголовок MainForm (рис. 3.3).
39
Если требуется изменить шрифт, цвет или высоту заголовка, не ищите
никаких свойств в Инспекторе Объектов. Все это системные параметры
Windows, и задаются они в свойствах дисплея самой операционной
системы.
3.1.2.2 Стиль формы
Настраивая форму, нужно иметь в виду, какой пользовательский
интерфейс будет иметь ваше приложение: многодокументальный
интерфейс MDI (от англ Multiple Document Intcrface) или обычный
однодокументальный интерфейс SDI (от англ Single Document Interface). За
это отвечает свойство формы FormStyle, которое может принимать
следующие значения:
Рис. 3.3
_ fsMDIChild -дочернее окно MDI-приложения;
_ fsMDIForm -главное окно MDI-приложения;
_ fsNormal обычное окно (значение по умолчанию);
_ fsStayOnTop окно, всегда расположенное поверх других окон на
экране.
Многие приложения имеют пользовательский интерфейс MDI. Они
состоят из «родительского» окна, которое включает одно или несколько
«дочерних» окон. Дочерние окна ограничены областью родительского окна
и не могут выходить за его границы. Для главной формы MDI-приложения
значение свойства FormStyle равно fsMDIForm. Для всех дочерних форм
значение свойства FormStyle равно fsMDIChild. Для модальных диалоговых
40
окон свойс1во FormStyle равно fsNormal, что дает возможность выносить
их за пределы основной формы.
Если применяется пользовательский интерфейс SDI, то каждая форма
существует в виде отдельного независимого окна. Одно из окон является
главным, однако оно не содержит других окон. В SDI-приложении и
главная, и второстепенные формы имеют в свойстве FormStyle значение
fsNormal. В некоторых случаях допускается установка значения
fsStayOnTop для того, чтобы окно всегда отображалось поверх других окон
на экране, даже если активно другое приложение.
3.1.2.3 Размеры и положение формы на экране
Теперь определимся с размерами формы и ее местоположением на
экране. Установить размеры и положение формы проще всего во время
проектирования с помощью мыши. Другой способ - обратиться к
Инспектору Объектов и задать размеры формы значениями свойств Width
и Height, а местоположение - значениями свойств Left и Тор (значения
задаются в пикселах).
Кроме того, с помощью свойства Position можно организовать
автоматическое размещение формы, выбрав одно из следующих
возможных значений:
poDefault - размер и положение формы подбираются автоматически
средой Windows;
poDefaultPosOnly - положение формы подбирается автоматически, a
ширина и высота - по значениям свойств Width и Height;
poDefaultSizeOnly - размер формы устанавливается автоматически по
умолчанию, местоположение - по значению Left и Тор;
poDesigned - размер и положение задаются значениями Left, Top,
Width, Height, установленными во время разработки приложения;
poScreenCenter - форма размещается в центре экрана; размеры
задаются значениями Width и Height.
Иногда размеры формы рассчитываются из размеров ее рабочей
области (client), на которой размещаются компоненты. В рабочую область
не входят рамка и заголовок. Размеры рабочей области хранятся в
свойствах ClientWidth и ClientHeight При их установке значения свойств
Width и Height автоматически пересчитываются.
Поскольку современные видеоадаптеры поддерживают множество
режимов с различным разрешением, встает вопрос: как обеспечить
одинаковую пропорцию между формой и экраном независимо от
разрешающей способности дисплея. Для этого в форме предусмотрено
свойство Scaled. Если оно установлено в значение True, то форма будет
автоматически масштабироваться в зависимости от разрешающей
способности дисплея.
41
Работая с приложением, пользователь может свернуть форму или
развернуть ее на всю рабочую область экрана с помощью соответствующих
кнопок рамки. Состояние формы (свернута или развернута) определяется
свойством WindowState, которое npинимает следующие значения:
-wsNormal - форма ни свернута, ни развернута;
-wsMinimized - форма свернута;
-wsMaximized - форма развернута.
Если при проектировании вы измените значение свойства WindowState
на wsMinimizec или wsMaximized, то получите форму, которая будет себя
сворачивать или разворачивать автоматически при первом появлении на
экране.
3.1.2.4 Цвет рабочей области формы
Для изменения установленного по умолчанию цвета фона формы
существует свойство Color. Для этого щелкните мышью на свойстве Color
Инспектора Объектов и выберите любой цвет из списка базовых цветов.
Базовые цвета представлены в списке именованными константами.
Можно также выбрать цвет из всей цветовой палитры, выполнив двойной
щелчок мыши на значении свойства. На экране появится стандартное
диалоговое окно выбора цвета (рис. 3.4).
Когда вы установите цвет в окне Инспектора Объектов, изменение
немедленно отразится на форме.
Рис. 3.4
42
3.1.2.5 Рамка формы
Во внешнем виде формы важную роль играет рамка и расположенные
на ней кнопки «Свернуть» «Развернуть» «Закрыть». Стиль рамки задается с
помощью свойства BorderStyle, которое может принимать следующие
значения:
-bsDialog - неизменяемая в размерах рамка, свойственная диалоговым
окнам;
-bsSingle - неизменяемая в размерах рамка для обычного окна;
-bsNone - у окна вообще нет ни рамки, ни заголовка;
-bsSizeable - изменяемая в размерах рамка для обычного окна;
-bsSizeToolWin-аналогично значению bsSingle, но окно имеет слегка
уменьшеный заголовок, что свидетельствует о его служебном назначении;
-bsSizeToolWin-аналогично значению bsSizeable, но окно имеет слегка
уменьшенный заголовок, что свидетельствует о его служебном назначении.
Обычно для окантовки формы используют значение bsSizeable. В этом
случае форма имеет стандартную изменяемую в размерах рамку (как при
проектировании), заголовок, управляющее меню, кнопки «Свернуть»,
«Развернуть», «Закрыть».
Когда значение в свойстве BorderStyle допускает наличие заголовка, вы
можете использовать свойство Borderlcons для определения системных
элементов рамки (управляющего меню), кнопок «Свернуть», «Развернуть»,
«Закрыть», «Справка»), которые будут доступны пользователю. Свойство
BorderIcons состоит из следующих вложенных свойств булевского типа:
biSystemMenu - форма имеет управляющее меню (оно вызывается по
щелчку правой кнопки мыши на заголовке формы);
biMinimize - рамка формы имеет кнопку «Свернуть»;
biMaximize - рамка формы имеет кнопку «Развернуть»;
biHelp - рамка формы имеет кнопку «Справка»; при нажатии кнопки
«Справка» курсор мыши превращается в стрелку со знаком вопроса;
выбирая таким курсором нужный элемент формы, пользователь получает
по нему справку во всплывающем окне.
3.1.2.6 Значок формы
Если вы разрабатываете серьезное приложение, следует позаботиться о
том, чтобы форма имела в своем левом верхнем углу выразительный
значок. Для разработки значков в Delphi существует специальное средство
- Редактор Изображений (Image Editor). Когда пиктограмма разработана, ее
нужно просто установить в свойстве формы Icon. Для этого сделайте
двойной щелчок мыши в окне Инспектора Объектов на значении свойства.
Delphi откроет диалоговое окно, только без рисунка. Нажмите кнопку
Load...
и
выберите
какой-нибудь
файл
значка
из
папки
Delphi20\Images\Icons, после этого закройте диалоговое окно с помощью
43
кнопки ОК. Delphi сразу же подставит эту пиктограмму в левый верхний
угол формы.
3.1.2.7 Невидимая форма
Сценарий решения задачи может потребовать, чтобы в некоторый
момент форма стала невидимой, т.е. исчезла с экрана. За «видимость»
формы отвечает булевское свойство Visible. Установка в нем значения
False скроет форму, а установка значения True - отобразит.
3.1.2.8 Недоступная форма
Иногда требуется запретить доступ к форме, не убирая ее с экрана. Для
этого служит свойство Enabled. Обычно оно равно True, но если ему
присвоить противоположное значение, после запуска приложения вы не
сможете сделать форму активной.
Все описанные выше свойства доступны не только в Инспекторе
Объектов, но и в Редакторе Кода, т.е. в тексте программы. При работе с
формой на уровне исходного кода вы также получаете доступ к некоторым
дополнительным свойствам, которые не видны в Инспекторе Объектов.
Они будут рассматриваться лишь по мере надобности.
3.1.3 События формы
Перечислим наиболее характерные события форм:
Событие OnCreate происходит сразу при создании формы. Обработчик
этого события может установить начальные значения для свойств формы и
ее компонентов, запросить у Windows необходимые ресурсы, создать
служебные объекты, а также выполнить другие действия прежде, чем
пользователь сможет работать с формой. Парным для события OnCreate
является событие OnDestroy.
Событие OnDestroy происходит при разрушении формы. Обработчик
этого события может освободить ресурсы, разрушить служебные объекты,
а также выполнить другие действия прежде, чем объект формы будет
разрушен.
Событие OnShow происходит непосредственно перед тем, как форма
становится видимой. Парным для события OnShow является OnHide.
Событие OnHide происходит непосредственно перед тем, как форма
становится невидимой. Парным для события OnHide является OnShow.
Событие OnActivate происходит, когда пользователь переключается на
форму, т е форма получает активность в результате, например, щелчка
мыши на ней. Парным для события OnActivate является OnDeactivate.
Событие OnDeactivate происходит, когда пользователь переключается
на другую форму, т е. текущая форма теряет состояние активности.
Парным для события OnDeactivate является OnActivate.
Событие OnCloseQuery происходит при попытке закрыть форму.
Попытка может исходить от пользователя, который нажал на рамке формы
44
кнопку «Закрыть», или от программы, которая вызвала у формы метод
Close. В обработчик события OnCloseQuery передается по ссылке
булевский параметр CanClose, разрешающий или запрещающий
действительное закрытие формы.
Рис. 3.5
Событие OnClose происходит после
непосредственно перед закрытием формы.
события
OnCloseQuery,
3.1.4 Создание в проекте новой формы
Часто одной формы для решения задачи бывает мало. Поэтому
рассмотрим, как добавить в проект новую форму, выбрать главную форму
приложения, переключаться между формами, как на этапе работы
приложения решается вопрос показа форм на экране.
Рис. 3.6
45
Для добавления в проект новой формы выберите команду меню
File/New Form, на экране сразу появится вторая форма. При этом в окне
Редактора Кода автоматически появится соответствующий новой форме
программным модуль. Только что созданную форму назовите
SecondaryForm и дайте ей заголовок - Secondary (рис. 3.5). Сохраните
модуль с новой формой под именем SECOND.PAS.
3.1.4.1 Добавление новой формы из Хранилища Объектов DELPHI
Существует и второй, более продуктивный, способ создания форм. Он
основан на использовании готовых форм, существующих в Хранилище
Объектов Delphi (Object Repository). Хранилище Объектов содержит
шаблоны форм, программных модулей и целых проектов, которые вы
можете либо просто скопировать в свой проект, либо унаследовать, либо
вообще использовать напрямую. Чтобы взять новую форму из Хранилища
Объектов, выберите в меню команду File|New… . Delphi откроет
следующее окно (рис. 3.6).
Рис. 3.7
Если выбрать на первой странице диалогового окна значок Form, то в
проект добавится пустая форма, как по команде меню File|New Form. Если
вас интересуют формы с «начинкой», обратитесь к страницам Forms и
Dialogs (рис. 3.7).
На страницах Forms и Dialogs существуют три зависимых
переключателя, задающих различные варианты выполняемых с формойшаблоном действий: скопировать (Сору), унаследовать (Inherit) и
использовать (Use). Отличие между ними состоит в следующем:
Copy - означает, что в проект помещается полная копия формышаблона, которая хранится в Хранилище Объектов;
46
Inherit - означает, что добавляемая в проект форма должна быть
унаследована от формы-шаблона, которая хранится в Хранилище
Объектов;
Use - означает, что в проект добавляется именно та форма, что
хранится в Хранилище Объектов как шаблон.
Какой из режимов использовать - зависит от условия задачи. Режим
Copy хорош тем, что не с нуля начинает разработку новой формы. Режим
Inherit полезен, когда в проекте существует несколько форм, у которых
совпадают некоторые части. В этом случае все похожие между собой
формы порождаются от какой-то одной формы, реализующей общую для
всех наследников часть. Режим Use позволяет добавить в проект именно ту
форму, которая находится в Хранилище Объектов. Изменение формы
будет означать изменение содержимого Хранилища Объектов.
Рис. 3.8
3.1.4.2 Переключение между формами при проектировании
Переключение между формами осуществляется с помощью окна View
Form, для вызова которого служит команда меню View|Forms (рис. 3.8).
Выберите в этом окне форму, с которой собираетесь работать, и
щелкните по кнопке ОК. Выбранная форма станет активной.
3.1.4.3 Выбор главной формы приложения
Когда в проекте несколько форм, возникает вопрос: какая из них
главная. Обратимся к диалоговому окну Project Options и рассмотрим на
странице Forms, какая форма выбрана в выпадающем списке Main form
(рис. 3.9).
Вы обнаружите, что активна форма МainForm, т.е. та, которая была
добавлена в проект первой (Delphi создает ее автоматически при создании
нового проекта). Можно выбрать другую форму - и тогда она будет
отображаться при запуске приложения.
47
Рис. 3.9
3.1.4.4 Отображение второстепенных фори при работе приложения
Работая с несколькими формами, следует иметь в виду, что после
загрузки приложения отображается главная форма, остальные хотя и
создаются вслед за ней автоматически, ждут вызова. Форму можно вызвать
на исполнение двумя разными способами:
 вызвать форму с помощью метода Show для немодального выполнения
вместе с остальными формами (режим параллельной работы);
 вызвать форму с помощью метода ShowModal для модального
выполнения отдельно от остальных форм (режим последовательной
работы).
Рис. 3.10
Рассмотрим эти способы на примере вызова формы Secondary из
формы Main.
48
Чтобы форма Secondary была доступна для использования формой
Main, необходимо подключить модуль формы Secondary к модулю формы
Main. Для этого проделайте следующие действия:
Активизируйте форму Main и выберите в главном меню команду
File/Use Unit. В появившемся диалоговом окне выберите модуль Second
(так называется модуль формы Secondary) и щелкните кнопку ОК (рис.
3.10).
На экране не произойдет видимых изменений, но в секции
implementation программного модуля Main добавится строка
uses Second;
Теперь из формы Main вызовем форму Secondary. Т.к. наиболее часто
формы вызываются по нажатию некоторой кнопки, добавим командную
кнопку в форму Main и обеспечим вызов формы Secondary по ее нажатию.
Отыщите в Палитре Компонентов на странице Standard значок с
подсказкой Button, щелкните на нем, затем - на форме Main. На форме
будет создана командная кнопка Button1 и в окне Object Inspector
отобразятся ее свойства. Активизируйте свойство Caption и замените в нем
текст Button1 на текст Secondary (рис. 3.11).
Рис. 3.11
Чтобы кнопка вызывала форму Secondary, в ней следует определить
обработчик события OnClick. Для этого:
Активизируйте в Инспекторе Объектов страницу Events и выполните
двойной щелчок мыши на значении события OnClick. Визуальная среда
определит для кнопки обработчик события, поместив его заготовку в
49
исходный текст модуля Main. Вставьте в тело обработчика оператор
SecondaryForm.Show, и o6pa6oтчик события станет выглядеть следующим
образом:
procedure TmainForm.Button1Click (Sender: Tobject);
begin
SecondaryForm.Show;
end;
Рис. 3.12
Выполните компиляцию и запустите приложение. Когда на экране
покажется форма Main, щелкните на кнопке Secondary. На экране
покажется еще одна форма - Secondary. Вы можете активизировать любую
из них произвольно (рис. 3.12).
Отсюда следует вывод: с помощью метода Show организуется
параллельное выполнение нескольких форм.
Обратите внимание, что форма Main является главной, а форма
Secondary - второстепенной. Это проявляется в том, что если вы закроете
форму Main, то форма Secondary тоже закроется и приложение завершится.
Если же вы закроете форму Secondary, то форма Main на экране останется.
Ситуация, когда пользователю предлагается для работы сразу
несколько доступных форм, встречается редко. Поэтому для показа формы
в основном применяется метод ShowModal. Он отображает форму и не
возвращает управление, пока пользователь не закроет форму.
Посмотрим, что произойдет, если в предыдущем примере заменить
вызов метода Show на ShowModal:
50
procedure TMainForm.ButtonlClick (Sender: TObject);
begin
SecondaryForm.ShowModal;
end;
После компиляции и запуска приложения нажмите в форме Main
кнопку Secondary. После появления формы Secondary попробуйте
активизировать форму Main. Из этого ничего не выйдет, поскольку теперь
форма Secondary исполняется в модальном режиме (рис. 3.13).
Рис. 3.13
Только закрыв форму Secondary, вы вернетесь в форму Main. Теперь
понятно и название метода ShowModal. С его помощью организуется
последовательное выполнение форм. Последовательное выполнение форм
применяется при организации диалоговых окон.
Размещение компонент на второстепенных формах производится так
же, как и на главных.
3.2 ПОРЯДОК ВЫПОЛНЕНИЯ РАБОТЫ
 Изучить основные свойства форм в среде программирования Delphi.
 Изучить основные события форм в среде программирования Delphi.
 Изучить способы создания второстепенных форм и управления ими в
среде программирования Delphi
51
 Ответить на контрольные вопросы.
 Пользуясь своим вариантом задания, разработайте спецификацию
проекта с изображением главной и второстепенных форм и всех
элементов управления со всеми надписями.
 Пользуясь визуальными средствами Delphi и своим вариантом задания,
создайте проект, откомпилируйте его и проверьте в работе.
 Составить отчет по лабораторной работе.
 В отчет должны входить следующие пункты:
 Цель работы.
 Описание основных средств создания главной и второстепенной форм и
средств управления ими.
 Описание процесса разработки алгоритма и программы по заданному
варианту.
 Результаты проверки программы.
 Вывод о проделанной работе.
3.3 КОНТРОЛЬНЫЕ ВОПРОСЫ
 Как создать главную форму в Delphi - проекте?
 Как установить основные свойства главной формы в Delphi - проекте.
 Как установить основные события главной формы в Delphi - проекте.
 Как создать главную форму в Delphi - проекте на основе использования
хранилища объектов?
 Как создать второстепенную форму в Delphi - проекте?
 Как создать средства управления второстепенной формой из главной
формы в Delphi - проекте?
3.4 ВАРИАНТЫ ЗАДАНИЙ.
1.Спроектировать главную форму с элементами модального
управления двумя второстепенными формами.
2.Спроектировать главную форму с элементами немодального
управления двумя второстепенными формами.
3.Спроектировать главную форму с элементами модального и
немодального управления двумя второстепенными формами.
4.Спроектировать главную форму с элементами модального и
немодального
управления
двумя
второстепенными
формами,
заимствованными из лаб. работ №1, 2.
5.Спроектировать главную форму с элементами модального
управления двумя второстепенными формами, заимствованными из своих
вариантов лаб. работ №1, 2.
52
6.Спроектировать главную форму с элементами немодального
управления двумя второстепенными формами, заимствованными из своих
вариантовлаб. работ №1, 2.
7.Более сложные варианты по согласованию с преподавателем.
53
4 ИЗУЧЕНИЕ СВОЙСТВ И МЕТОДОВ ИСПОЛЬЗОВАНИЯ
КОМПОНЕНТОВ В СРЕДЕ DELPHI
Цель работы: изучение свойств и методов использования компонентов
в среде программирования Delphi.
4.1 МЕТОДИКА ВЫПОЛНЕНИЯ РАБОТЫ
4.1.1 Понятие компонента
Компоненты
являются
фундаментом
визуальной
разработки
приложения Delphi.
Существует два подхода к компонентам:
В визуальной среде разработки компоненты - целостные строительные
блоки, которые вы берете из Палитры Компонентов и переносите на форму
для создания собственного приложения. Это кнопки, строки редакторов и
т.п.
В программе на языке Object Pascal компоненты - это классы,
порожденные прямо или косвенно от класса TComponent и имеющие
опубликованные (published) свойства. Экземпляры компонентов -это
объекты этих классов, существующие в качестве полей формы. Среди
опубликованных свойств компонентов обязательно присутствует имя
(Name), под которым экземпляр компонента представляется в Инспекторе
Объектов.
Объединение этих подходов дает цельное представление о
компонентах. При работе с компонентами из визуальной среды вы всегда
видите их лицевую сторону. Однако при написании обработчиков событий
и при управлении компонентами программно вы соприкасаетесь с
программной стороной компонентов, суть которой - объекты. Так Delphi
обеспечивает единство визуального и объектно-ориентированного
программирования.
При анализе структуры компонента обнаруживается, что его природа
троична и лучше всего описывается формулой:
Компонент =состояние (свойства) + действия (методы) + обратные
связи (события).
Состояние компонента описывается его свойствами. Свойства - это
атрибуты компонента, которые определяют, как компонент отображается
на экране и как функционирует. Свойства бывают изменяемые (для чтения
и записи) и неизменяемые (только для чтения). В зависимости от времени
установки
свойства
подразделяются
на
свойства
времени
54
проектирования (design time) и свойства времени выполнения (run-time).
Первые устанавливаются для каждого компонента в Инспекторе Объектов
и определяют начальное состояние компонента. Во время выполнения
приложения эти свойства могут быть изменены операторами программы,
соответственно изменится вид и поведение компонента. Вторая группа -это
свойства, которые не отражены в окне Инспектора Объектов и управлять
которыми можно только из программы .С точки зрения языка Object Pascal
различия между свойствами времени проектирования и свойствами
времени выполнения проста - первые объявлены в своем классе в секции
published, а вторые - в секции public.
Действия, выполняемые компонентом, - это его методы. Вызовы
методов компонента помещаются в исходный код программы и происходят
только во время выполнения приложения. Методы не имеют под собой
визуальной основы.
Обратные связи компонента - это его события. События
обеспечивают интерактивность компонентов, благодаря им приложение в
Delphi строится как программный автомат. В Object Pascal нет специальных
языковых средств для представления событий, да они и не нужны, т.к.
события реализуются с помощью свойств, содержащих указатели на
методы.
4.1.2 Визуальные и невизуальные компоненты
Все множество компонентов подразделяется на две группы: визуальные
и невизуальные компоненты.
Рис. 4.1
55
Визуальные компоненты (visual components) - это управляющие
элементы пользовательского интерфейса (controls), т.е. кнопки, метки,
окна, блоки списков и др. Они видны на экране и выглядят одинаково на
стадии проектирования и во время работы приложения.
Невизуальные компоненты (nonvisual components) - работают, но сами
на экране не видны. К невизуальным компонентам относятся таймер,
компоненты доступа к базам данным и др. На стадии проектирования
невизуальный компонент представляется на форме небольшим значком.
Его свойства устанавливаются в Инспекторе Объектов. Некоторые
компоненты, хотя и являются невизуальными, могут что-нибудь
отображать на экране. Например, невизуальный компонент MainMenu
отображает на форме строку главного меню, а невизуальный компонент
OpenDialog _ стандартное диалоговое окно выбора файла (рис. 4.1).
4.1.3 Управляющие элементы пользовательского
интерфейса
Управляющие
элементы
пользовательского
интерфейса
подразделяются на управляющие элементы - окна и рисуемые
управляющие элементы.
Управляющие элементы - окна (windowed controls) являются
специализированными окнами внутри окна формы. Их главное свойство способность получать фокус ввода. К числу управляющих элементов - окон
относятся, например, компоненты Button, RadioButton, CheckBox, GroupBox
и т. п. Некоторые управляющие элементы такого типа (например,
GroupBox, TabControl, PageControl) способны содержать другие
управляющие элементы пользовательского интерфейса и называются
владельцами (container controls). Отрисовку управляющих элементов - окон
выполняет операционная система Windows.
Рисуемые управляющие элементы (graphical controls) не являются
окнами и не могут получать фокус ввода и содержать другие управляющие
элементы. Их отрисовку полностью выполняет Delphi. К числу рисуемых
управляющих элементов относятся, например, компоненты Label,
SpeedButton, Image, Bevel и т. д. (рис. 4.2).
Каждый компонент обладает специфическим набором свойств и
событий, но имеются и общие из них. Рассмотрим свойства и события,
общие хотя бы для подмножества этих компонент.
Невизуальные компоненты практически не имеют общих свойств и
событий, единственные общие для них свойства - это Name (комментариев
не требует) и Tag (целочисленное значение, не несущее смысловой
нагрузки - вы можете использовать его по своему усмотрению). А вот
управляющие элементы пользовательского интерфейса имеют много
общих свойств и событий, которые мы рассмотрим.
56
Рис. 4.2.
4.1.3.1 Общие свойства управляющих элементов
Местоположение управляющего элемента внутри формы или
управляющего элемента владельца определяется значениями свойств Left и
Тор. Горизонтальный и вертикальный размеры управляющего элемента
хранятся в свойствах Width и Height соответственно.
Свойство Caption содержит заголовок управляющего элемента.
Установленная в свойстве текстовая строка может содержать управляющий
символ амперсанд ‘’&’’. Если в строке встречается амперсанд, то
следующий за ним символ отображается подчеркнутым (амперсанд при
этом не отображается) и называется символом-сокращением. Нажимая
клавишу с изображением символа в сочетании с клавишей Alt,
пользователь может активизировать управляющий элемент с помощью
клавиатуры.
Свойство Color определяет цвет управляющего элемента.
Управляющий элемент может иметь независимый цвет, а может брать его у
своего владельца (формы или другого компонента). Это определяется
значением свойства ParentColor. Если свойство ParentColor имеет значение
True, то изменение цвета владельца, например формы, автоматически
приводит к изменению значения свойства Color управляющего элемента,
например кнопки, размещенной на форме. Однако, если вы сами
установите свойство Color, то свойство ParentColor автоматически получит
значение False и цвет управляющего элемента станет независимым.
57
Свойство Ctl3D определяет, какой внешний вид имеет управляющий
элемент: рельефный или плоский. Если свойство имеет значение True, то
управляющий элемент имеет рельефный вид, а если False, - плоский.
Свойство рельефности управляющего элемента может зависеть от
рельефности его владельца (формы или другого компонента), что
определяется значением свойства ParentCtl3D. Если свойство ParentCtl3D
имеет значение True, то изменение рельефности владельца, например,
формы, автоматически приводит к изменению значения свойства Ctl3D
управляющего элемента, например кнопки. Однако, если вы сами
установили свойство Ctl3D, то свойство ParentCtl3D автоматически
получит значение False и рельефность управляющего элемента станет
независимой. Заметим, что в Windows 95 и Windows NT 4.0 значение
свойства Ctl3D не играет роли, так как управляющие элементы сразу
имеют рельефный вид.
Свойство Cursor определяет, какое изображение принимает курсор
мыши, когда пользователь переводит его на управляющий элемент.
Возможные основные значения свойства и соответствующие им виды
курсоров иллюстрирует табл. 4.1. (некоторые неосновные значения не
отражены в табл. 4.1).
табл. 4.1
Значение
Вид курсора на экране
crAppStart
crArrow
crCross
crDefault
crHelp
crHourGlass
crlBeam
crNo
crSizeNESW
crSizeNS
crSizeNWSE
crSiseWE
crUpArrow
Свойство DragCursor определяет вид курсора мыши, когда
управляющий элемент является пунктом назначения в операции
буксировки.
Свойство DragMode определяет режим буксировки управляющего
элемента. Если в свойстве установлено значение dmManual (принято по
умолчанию), то буксировка должна инициироваться программно. Если же
58
установлено значение dmAutomatic, то управляющий элемент уже готов к
буксировке, пользователю достаточно просто нажать кнопку мыши в
момент, когда курсор находится над элементом и отбуксировать его в
нужное место.
Свойство Enabled определяет, доступен ли управляющий элемент для
пользователя. Если свойство имеет значение True, то управляющий
элемент доступен, а если False, то недоступен. Недоступный управляющий
элемент обычно имеет блеклый вид.
Свойство Font является сложным и определяет шрифт надписи на
управляющем элементе. Параметры шрифта задаются с помощью
вложенных свойств Color, Name, Size, Style, Height. Шрифт управляющего
элемента может быть независимым, а может копироваться у владельца
(формы или другого компонента). Это определяется значением свойства
ParentFont. Если свойство ParentFont имеет значение True, то изменение
шрифта владельца автоматически приводит к изменению значения
свойства Font управляющего элемента, например кнопки. Однако, если вы
сами установите свойство Font, то свойство ParentFont автоматически
получит значение False и шрифт управляющего элемента станет
независимым.
Свойство HelpContext содержит номер темы в файле справочника,
которая контекстно связана с управляющим элементом. Когда
управляющий элемент обладает фокусом ввода, пользователь может
нажать клавишу F1, чтобы получить по нему оперативную справку. Если
свойство HelpContext имеет значение 0, то управляющий элемент берет
номер темы у своего владельца.
Свойство Hint содержит строку подсказки, которая всплывает под
управляющим элементом, если пользователь временно задерживает над
ним курсор мыши. Всплытие подсказки может быть разрешено или
запрещено с помощью другого свойства – ShowHint.
Значение свойства ShowHint может зависеть от запрета подсказки для
владельца. Это определяется значением свойства ParentShowHint. Если
ParentShowHint имеет значение True, то запрет подсказки для владельца
(например, формы) автоматически приводит к запрету подсказки для
управляющего элемента, например кнопки. Однако, если вы сами
установите свойство ShowHint, то свойство ShowHint автоматически
получит значение False и запрет подсказки для управляющего элемента
станет независимым.
Свойство PopupMenu используется для привязки к управляющему
элементу локального всплывающего меню. Это меню всплывает по щелчку
правой кнопки мыши, когда курсор находится над управляющим
элементом.
59
Свойство TabOrder содержит порядковый номер управляющего
элемента в пределах своего владельца. Это номер очереди, в которой
управляющий элемент получает фокус при нажатии клавиши Tab.
Свойство TabStop определяет, может ли управляющий элемент
получать фокус ввода. Если свойство имеет значение True, то
управляющий элемент находится в очереди на фокус ввода, а если False, то нет.
Свойство Visible управляет видимостью управляющего элемента на
экране. Если свойство имеет значение True, то управляющий элемент
виден, а если False, - то скрыт.
4.1.3.2 Общие события управляющих элементов
Событие OnClick возникает в результате щелчка по управляющему
элементу. Это означает, что пользователь перевел курсор на управляющий
элемент и щелкнул левой кнопкой мыши.
Событие OnDblClick возникает в результате двойного щелчка по
кнопке мыши, когда курсор находится над управляющим элементом.
Событие OnEnter происходит при получении управляющим элементом
фокуса ввода. При потере фокуса ввода в управляющем элементе
генерируется событие OnExit. События OnEnter и OnExit не возникают при
переключении между формами и приложениями.
Событие OnKeyDown происходит при нажатии пользователем любой
клавиши, когда управляющий элемент находится в фокусе ввода. При
отпускании нажатой клавиши возникает событие OnKeyUp. Если
пользователь нажал символьную клавишу, то вслед за событием
OnKeyDown и до события OnKeyUp возникает событие OnKeyPress.
Событие OnMouseDown происходит при нажатии пользователем
кнопки мыши, когда курсор находится над управляющим элементом. При
отпускании кнопки в управляющем элементе происходит событие
OnMouseUp. При перемещении курсора мыши над управляющим
элементом, в последнем периодически возникает событие OnMouseMove,
что позволяет реагировать на простое изменение положения курсора.
4.2 ПАЛИТРА КОМПОНЕНТОВ.
Как мы уже выяснили, компоненты представляют собой элементы, из
которых конструируется видимое изображение, создаваемое работающей
программой. Существует значительное количество компонентов, которые
не создают видимого изображения, но которые, тем не менее, играют
важную роль в тех или иных случаях. Правильнее думать о компонентах
как о заранее приготовленных для вас фрагментах программы, которые
можно вставлять, если в этом есть необходимость, в разрабатываемую
программу. Здесь мы сделаем начальный обзор некоторых страниц
60
Палитры Компонентов, который даст вам самое общее представление о
богатстве возможностей Delphi.
Библиотеки компонентов для разных версий Delphi строятся по
принципу расширения: в первой версии было около 70 компонентов, в то
время как в состав Delphi 4 входит около 170 компонентов. Рассмотрим
стандартные компоненты Delphi 4 .
4.2.1 Страница Standard
На странице Standard палитры компонентов сосредоточены
стандартные для Windows интерфейсные элементы, перечисленные в табл.
4.2:
Табл. 4.2
Имя
Назначение
MainM
Главное меню программы. Компонент способен создавать и
enu
обслуживать сложные иерархические меню.
Рорир
Вспомогательное меню. Обычно это меню появляется в виде
Мепи
отдельного окна после нажатия правой кнопки мыши.
Label
Метка. Этот компонент используется для размещения в окне не
очень длинных однострочных надписей.
Edit
Строка ввода. Предназначена для ввода и/или отображения
одной текстовой строки.
Memo
Многострочный текстовый редактор. Используется для ввода
и/или отображения многострочного текста.
Button
Командная кнопка. Обработчик события OnClick этого
компонента обычно используется для реализации некоторой
команды.
Check
Независимый переключатель. Щелчок мышью на этом
Box
компоненте в работающей программе изменяет его логическое
свойство Checked.
RadloB
Зависимый переключатель. Обычно объединяется как минимум
utton
еще с одним таким же компонентом в группу. Щелчок по
переключателю приводит к автоматическому освобождению ранее
выбранного переключателя в той же группе.
ListBox
Список выбора. Содержит список предлагаемых вариантов
(опций) и дает возможность проконтролировать текущий выбор
Combo
Комбинированный список выбора. Представляет собой
Box
комбинацию списка выбора и текстового редактора.
ScrollB
Полоса управления. Представляет собой вертикальную или
ar
горизонтальную полосу, напоминающую полосы прокрутки по
бокам Windows-окна..
Group
Группа элементов. Этот компонент используется для
Box
группировки нескольких связанных по смыслу компонентов.
61
RadioG
Группа зависимых переключателей. Содержит специальные
roup
свойства для обслуживания нескольких связанных зависимых
переключателей
Panel
Панель. Этот компонент, как и GroupBox, служит для
объединения нескольких компонентов. Содержит внутреннюю и
внешнюю кромки, что позволяет создать эффекты «вдавленности»
и «выпуклости».
Action
Список действий. Служит для централизованной реакции
List
программы на действия пользователя, связанные с выбором одного
из группы однотипных управляющих элементов, таких как опции
меню, пиктографические кнопки и т.п.
Компонент ActionList впервые введен в версию Delphi 4.
4.2.2 Страница Additonal
В страницу Additonal помещены 13 дополнительных компонентов, с
помощью которых можно разнообразить вид диалоговых окон (табл. 4.3):
табл. 4.3
Имя
Назначение
BitBtn
Командная кнопка с надписью и пиктограммой.
SpeedBu
Пиктографическая кнопка. Обычно используется для быстрого
tton
доступа к тем или иным опциям главного меню.
MaskEdi
Специальный текстовый редактор. Способен фильтровать
t
вводимый текст, например, для правильного ввода даты.
StringGr
Таблица строк. Этот компонент обладает мощными
id
возможностями для представления текстовой информации в
табличном виде.
DrawGri
Произвольная таблица. В отличие от StringGrid, строки этого
d
компонента могут содержать произвольную информацию, в том
числе и рисунки.
Image
Рисунок. Этот компонент предназначен для отображения
рисунков, в том числе - пиктограмм и метафайлов.
Shape
Фигура. С помощью этого компонента вы можете вставить в
окно правильную геометрическую фигуру - прямоугольник,
эллипс, окружность и т.п.
Bevel
Кромка. Служит для выделения отдельных частей окна
трехмерными рамками или полосами.
ScrollBo
Панель с полосами прокрутки. В отличие от компонента
x
Panel, автоматически вставляет полосы прокрутки, если
размещенные в нем компоненты отсекаются его границами.
CheckLi
Список множественного выбора. Отличается от стандартного
stBox
компонента ListBox наличием рядом с каждой опцией
независимого переключателя типа CheckBox, облегчающего
62
выбор сразу нескольких опций.
Splitter
Граница. Этот компонент размещается на форме между двумя
другими видимыми компонентами и дает возможность
пользователю перемещать границу, отделяющую компоненты друг
от друга.
StaticTe
Статический текст. Отличается от стандартного компонента
xt
Label наличием собственного Windows-окна, что позволяет
обводить текст рамкой или выделять его в виде «вдавленной»
части формы.
Chart
Диаграмма. Этот компонент облегчает создание специальных
панелей для графического представления данных.
Компоненты CheckListBox, Splitter, StaticText и Chart впервые
появились в версии Delphi 3.
4.2.3 Страница Win32
Страница Win32 содержит интерфейсные элементы для 32-разрядных
операционных систем Windows 95/98/NT (в версии 2 эта страница
называется Win95) (табл. 4.4).
табл. 4.4
Имя
Назначение
TabControl
Набор закладок. Каждая закладка представляет собой прямоугольное поле с надписью и/или текстом. Выбор той или
иной закладки распознается программой и используется для
управления содержимым окна компонента.
PageControl
Набор панелей с закладками. Каждая панель может содержать свой набор интерфейсных элементов и выбирается
щелчком по связанной с ней закладке.
ImageList
Набор рисунков. Представляет собой хранилище для нескольких рисунков одинакового размера.
RichEdit
Многострочный редактор форматированного текста. В
отличие от компонента Memo страницы Standard, текст в
компоненте RichEdit подчиняется правилам Расширенного
Текстового Формата (RTF- Rich Text Format) и может изменять
такие свои характеристики, как шрифт, цвет, выравнивание и
т.д.
TrackBar
Регулятор. Используется для управления значениями
некоторых величин в программах. Например, с его помощью
удобно изменять громкость звучания в мультимедийных
программах.
ProgressBar
Индикатор процесса. С помощью этого компонента можно
отображать ход исполнения достаточно длительного по
времени процесса, например, процесса переноса данных на
63
дискету.
UpDown
Цифровой регулятор. Две кнопки этого компонента
предназначены для увеличения (верхняя) или уменьшения
(нижняя) связанной с компонентом числовой величины.
HotKey
Управляющая клавиша. Компонент используется для ввода
управляющих клавиш, таких как F1, Alt+A, Ctrl+Shift+1 и т.п.
Animate
Мультипликатор.
Предназначен
для
отображения
последовательно сменяющих друг друга кадров движущихся
изображений
(видеоклипов).
Компонент
не
может
сопровождать видеоклип звуком.
DateTimeСелектор времени/даты. Этот компонент предназначен для
Picker
ввода или отображения даты или времени.
TreeView
Дерево выбора. Представляет собой совокупность
связанных в древовидную структуру пиктограмм. Обычно
используется для просмотра структуры каталогов (папок) и
других подобных элементов, связанных иерархическими
отношениями.
ListView
Панель пиктограмм. Организует просмотр нескольких
пиктограмм и выбор нужной. Этот компонент способен
располагать пиктограммы в горизонтальных или вертикальных
рядах и показывать их в крупном или мелком масштабе.
HeaderУправляющий
заголовок.
Представляет
собой
Control
горизонтальную или вертикальную полосу, разделенную на ряд
смежных секций с надписями. Размеры секций можно менять
мышью на этапе работы программы. Обычно используется для
изменения размеров столбцов или строк в разного рода
таблицах.
StatusBar
Панель статуса. Предназначена для размещения разного
рода служебной информации в окнах редактирования.
Посмотрите на нижнюю часть рамки окна кода Delphi или
текстового редактора Word и вы увидите этот компонент в
действии.
ToolBar
Инструментальная панель. Этот компонент служит
контейнером для командных кнопок BitBtn и способен
автоматически изменять их размеры и положение при удалении
кнопок или при добавлении новых.
CoolBar
Инструментальная панель. В отличие от ToolBar,
используется как контейнер для размещения стандартных
интерфейсных компонентов Windows, таких как Edit, ListBox,
ComboBox и т.д.
PageScroller
Прокручиваемая панель. Служит для размещения узких
64
инструментальных панелей. При необходимости автоматически
создает по краям панели стрелки прокрутки.
Все компоненты этой страницы отсутствуют в версии 1, а Animate,
DateTime Picker, ToolBar и CoolBar - в версии 2. Компонент PageScroller
впервые введен в версии 4.
4.2.4 Страница SYSTEM
На этой странице представлены компоненты, которые имеют различное
функциональное назначение, в том числе компоненты, поддерживающие
стандартные для Windows технологии межпрограммного обмена данными
OLE (Object Linking and Embedding - связывание и внедрение объектов) и
DDE (Dynamic Data Exchange - динамический обмен данными) (табл. 4.5).
табл. 4.5
Имя
Назначение
Timer
Таймер. Этот компонент служит для отсчета интервалов
реального времени.
PaintB
Окно для рисования. Создает прямоугольную область,
ox
предназначенную для прорисовки графических изображений.
Media
Мультимедийный проигрыватель. С помощью этого компонента
Plyaer
можно управлять различными мультимедийными устройствами.
OleCo
OLE-контейнер. Служит приемником связываемых или
ntainer
внедряемых объектов.
DDEC
DDE-связь. Совместно с DDEClientltem используется для
lient-Conv создания клиентской программы в dDe-связи.
DDEC
DDE-тема. Определяет тему DDE-связи в клиентском
lientltem приложении.
DDES
DDE-связь. Совместно с DDEServerItem используется для
erver-Conv создания серверной программы в DDE-связи.
DDES
DDE-тема. Определяет тему DDE-связи в серверном
erver-Item приложении.
4.2.5 Страница DIALOGS
Компоненты страницы реализуют стандартные для Windows
диалоговые окна (табл. 4.6).
табл. 4.6
Имя
Назначение
Open
Открыть. Реализует стандартное диалоговое окно «Открыть
Dialog
файл».
SaveDi
Сохранить. Реализует стандартное диалоговое окно «Сохранить
alog
файл».
OpenPi
Открыть рисунок. Реализует специальное окно выбора
ctureграфических файлов с возможностью предварительного просмотра
65
Dialog
рисунков.
SavePi
Сохранить рисунок. Реализует специальное окно сохранения
ctureграфических файлов с возможностью предварительного просмотра
Dialog
рисунков.
FontDi
Шрифт. Реализует стандартное диалоговое окно выбора
alog
шрифта.
ColorD
Цвет. Реализует стандартное диалоговое окно выбора цвета.
ialog
PrintDi
Печать. Реализует стандартное диалоговое окно выбора
alog
параметров для печати документа.
Printer
Настройка принтера. Реализует стандартное диалоговое окно
Setupдля настройки печатающего устройства.
Dialog
FindDi
Поиск. Реализует стандартное диалоговое окно поиска
alog
текстового фрагмента.
Replac
Замена. Реализует стандартное диалоговое окно поиска и
e Dialog
замены текстового фрагмента.
Компоненты OpenPictureDialog и SavePictureDialog введены в версии
3, остальные имеются в предыдущих версиях. Разумеется, и нтерфейс окон
для Windows 16 (версия 1) отличается от интерфейса Windows 32 (версии 2
- 4).
4.2.6 Страница SAMPLES
Эта страница содержит компоненты разного назначения (табл. 4.7).
табл. 4.7
Имя
Назначение
Gauge
Индикатор состояния. Подобен компоненту ProgressBar
(страница Win32), но отличается большим разнообразием форм.
ColorGrid
Таблица цветов. Этот компонент предназначен для выбора
основного и фонового цветов из 16-цветной палитры.
SpinButto
Двойная кнопка. Дает удобное средство управления
n
некоторой числовой величиной.
SpmEdit
Редактор
числа.
Обеспечивает
отображение
и
редактирование целого числа с возможностью его изменения с
помощью двойной кнопки.
DirectoryСписок каталогов. Отображает в иерархическом виде
OutLine
структуру каталогов дискового накопителя.
Calendar
Календарь. Предназначен для показа и выбора дня в месяце.
IBEventA
Сторож
событий.
Этот
компонент
осуществляет
lerter
асинхронную связь с сервером БД InterBase. При возникновении
в сервере нужного события компонент активизирует свой
обработчик OnEventAlert и таким образом извещает программу о
66
новом состоянии БД.
В Палитре Компонентов имеется еще ряд страниц - Internet, Data
Access, Data Controls, Midas, Decision Cube, Qreport, Win31, ActiveX,
которые используются программистами высокой квалификации для
решения специальных задач и которые будут рассмотрены при изучении
соответствующих тем.
4.3 УПРАВЛЕНИЕ КОМПОНЕНТАМИ ПРИ ПРОЕКТИРОВАНИИ
4.3.1 Размещение компонентов на форме
Чтобы поместить на форму нужный компонент из Палитры
Компонентов, выполните следующие действия.
Установите курсор мыши на нужный значок компонента в Палитре
Компонентов и щелкните левой кнопкой мыши;
Переместите курсор в нужное место формы и еще раз щелкните
мышью. Выбранный компонент окажется на форме и готов к установке
свойств.
Часто требуется разместить в форме несколько компонентов одного и
того же типа, например, кнопок. Для этого:
Нажмите клавишу Shift и, не отпуская ее, щелкните левой кнопкой
мыши на нужном значке компонента в Палитре Компонентов и отпустите
клавишу Shift.
Переместите курсор в то место формы, где будет находиться первый
компонент, и щелкните левой кнопкой мыши.
Переместите курсор в точку, где будет размещен второй компонент и
щелкните левой кнопкой мыши. Повторите это действие столько раз,
сколько компонентов будете размещать.
Разместив последний компонент, переместите курсор на кнопку с
изображением стрелки курсора (она расположена в левой части Палитры
Компонентов), и - щелкните кнопкой мыши. Это будет сигнал визуальной
среде об окончании выбора однотипных компонентов.
Если необходимо убрать компонент с формы, просто выберите
(активизируйте) его с помощью мыши и нажмите клавишу Del.
4.3.2 Выбор рабочего компонента формы
На стадии проектирования любой компонент формы может быть в двух
состояниях: активном или пассивном. Когда он активен (другими словами выбран для работы), его свойства можно изменять в Инспекторе Объектов.
Когда компонент пассивен, на него можно только смотреть. Чтобы выбрать
рабочий компонент, достаточно установить на него курсор и щелкнуть
кнопкой мыши. Вокруг компонента тут же появятся так называемые
''точки растяжки'' (sizing handles) для изменения размеров компонента по
ширине и высоте (рис. 4.3).
67
Рис. 4.3
Когда вы установите свойства компонента, щелкните мышью на
незанятой области формы и компонент снова станет пассивным.
При проектировании сложных форм вы столкнетесь с ситуацией, когда
в нескольких компонентах нужно установить некоторое свойство в одно и
то же значение, например в нескольких кнопках установить свойство
Enabled в значение False. Быстрее всего это можно сделать, если выделить
несколько компонентов и выполнить установку общего свойства в окне
Инспектора Объектов за один раз. Выделить несколько компонентов
можно двумя способами:
Нажать клавишу Shift и, удерживая ее, отметить щелчками мыши все
требуемые компоненты, после чего клавишу Shift отпустить. В углах
каждого выделенного компонента появятся небольшие квадратикимаркеры.
Нажать кнопку мыши, когда курсор находится вне компонентов. Затем,
удерживая кнопку нажатой, протянуть курсор над выделяемыми
компонентами, включив их в пунктирный прямоугольник. Когда в
пунктирный прямоугольник попадут все требуемые компоненты, кнопку
мыши следует отпустить. Если выделяемые компоненты находятся внутри
компонента Panel или GroupBox, то эту операцию нужно выполнять с
нажатой клавишей Ctrl. После этого в углах всех компонентов, хотя бы
частично попавших в пунктирный прямоугольник, появятся небольшие
квадратики - маркеры, свидетельствующие о том, что компоненты
выделены.
Когда на форме выделено несколько компонентов, в окне Инспектора
Объектов отображаются лишь их общие свойства. Активизируйте нужное
свойство и установите в нем свое значение. Эта установка отразится на
всех выделенных компонентах (рис. 4.4).
Имейте в виду, что когда на форме выделено несколько компонентов,
некоторые свойства в окне Инспектора Объектов могут как бы не иметь
значения (в поле значения - пусто). Такие свойства имеют различные
значения в выделенных компонентах. Будьте с ''пустыми'' свойствами
предельно аккуратны, поскольку активизация и установка свойства
приведет к установке одинакового значения для этого свойства во всех
выделенных компонентах.
68
Рис. 4.4
4.3.3 Перемещение и изменение размеров компонента
Когда все компоненты помещены на форму, нужно оценить ее с точки
зрения эстетики. Посмотрите на форму со стороны. Наверняка что-то
захочется уменьшить, что-то увеличить, что-то переместить на другое
место.
Для перемещения компонента на другое место:
Поместите курсор на компонент, который хотите переместить, и
щелкните мышью - он активизируется.
Не отпуская кнопки мыши, отбуксируйте компонент на новое место.
Когда компонент будет на нужном месте, отпустите кнопку мыши.
Для изменения размера компонента:
Щелчком мыши активизируйте компонент, размер которого хотите
изменить.
Установите курсор на точке вертикальной или горизонтальной
''растяжки'', при этом форма курсора изменится на двунаправленную
стрелку. Нажмите кнопку мыши и перемещайте курсор в сторону
уменьшения или увеличения размера компонента.
Добившись желаемого размера, отпустите кнопку мыши и ''сойдите'' с
точки растяжки; курсор при этом примет обычную форму. Компонент
получит новые размеры.
Чтобы упростить позиционирование и изменение размеров
компонентов, форма отображает на этапе разработки сетку (grid).
Компоненты автоматически выравниваются на пересечении воображаемых
69
линий сетки, когда вы переносите их из Палитры Компонентов на форму.
Изначально шаг между горизонтальными и вертикальными линиями сетки
равен 8, но его легко изменить. Для этого выполните команду меню
Tools|Options... На экране появится диалоговый блок Environment Options
(рис. 4.5). Отыщите на странице Preferences поля ввода с метками Grid size
X и Grid size Y, а затем установите те параметры сетки, которые вам
нужны. Кстати, с помощью соседних переключателей можно указать
Delphi, следует ли вообще показывать сетку (Display grid) и следует ли
выравнивать на ней компоненты (Snap to grid).
Рис. 4.5
Иногда после первоначального размещения компонентов на сетке
необходимо подогнать их положение и размеры с точностью до пиксела.
Для этого выберите компонент на форме и действуйте следующим
образом:
Нажмите клавишу Ctrl и, удерживая ее нажатой, подвиньте компонент
на нужное количество пикселов с помощью клавиш со стрелками.
Отпустите клавишу Ctrl.
Нажмите клавишу Shift и, удерживая ее нажатой, измените размер
компонента на нужное количество пикселов с помощью клавиш со
стрелками. Отпустите клавишу Shift.
70
Рис. 4.6
4.3.4 Выравнивание компонентов на форме
Когда на форме много компонентов, ручное выравнивание становится
трудоемким.
Для
этого
в
Delphi
предусмотрены
средства
автоматизированного выравнивания компонентов. Алгоритм выравнивания
следующий:
Выделите компоненты, которые собираетесь выравнивать.
Обратитесь к главному меню и активизируйте режим Edit | Align. На
экране появится окно с различными параметрами выравнивания.
Выберите в списке нужный параметр и нажмите кнопку ОК. Окно
настройки закроется, и все компоненты будут выровнены согласно вашим
указаниям.
Рис. 4.7
Если компонентов на форме много и вам предстоит большая работа по
их выравниванию, откройте окно Align с помощью команды меню View |
Alignment Palette и используйте его на втором шаге выравнивания. Стрелки
- указатели поясняют алгоритм выравнивания для каждого режима (рис.
4.7).
71
4.3.5 Использование Буфера Обмена при работе с
компонентами
При работе с несколькими формами иногда встает задача копирования
и перемещения компонентов с одной формы на другую. Их перетаскивание
здесь не помогает. Задача решается с помощью Буфера Обмена:
Выделите на одной форме компоненты, которые вы хотите скопировать
или переместить.
Если вы собираетесь скопировать компоненты, выберите в меню
команду Edit | Copy. Если вы собираетесь переместить компоненты,
выберите в меню команду Edit | Cut. Компоненты окажутся в Буфере
Обмена.
Активизируйте форму, в которую вы хотите скопировать или
переместить компоненты и выберите в меню команду Edit | Paste. По этой
команде Delphi извлечет компоненты из Буфера Обмена и поместит их на
активную форму.
Команды работы с Буфером Обмена применяются не только для
копирования и перемещения компонентов с одной формы на другую, но и
для копирования и перемещения компонентов в пределах одной формы
между разными компонентами-владельцами, например для перемещения
кнопок с одной панели на другую. Необходимость использования Буфера
Обмена в этом случае вызвана тем, что компоненты твердо «знают» своего
владельца (например, кнопки «знают» панель, на которой они
расположены), поэтому обычная операция буксировки ни к чему не
приводит.
4.4 ПОРЯДОК ВЫПОЛНЕНИЯ РАБОТЫ.
 Изучить основные свойства компонентов в среде программирования
Delphi.
 Изучить основные события компонентов в среде программирования
Delphi.
 Изучить основной состав стандартных компонентов Палитры
Компонентов среды программирования Delphi.
 Изучить основные методы управления компонентами в среде
программирования Delphi.
 Ответить на контрольные вопросы.
 Пользуясь своим вариантом задания, разработайте спецификацию
проекта с изображением главной формы и всех компонентов со всеми
надписями.
 Пользуясь визуальными средствами Delphi и своим вариантом задания,
создайте проект, откомпилируйте его и проверьте в работе.
 Составить отчет по лабораторной работе.
72
В отчет должны входить следующие пункты:
 Цель работы.
 Описание основных свойств и событий компонентов, основного состава
стандартных компонентов Палитры Компонентовс и средств
управления ими.
 Описание процесса разработки алгоритма и программы по заданному
варианту.
 Результаты проверки программы.
 Вывод о проделанной работе.
4.5 КОНТРОЛЬНЫЕ ВОПРОСЫ
 Что такое компоненты, какие они бывают и для чего служат?
 Что такое управляющие элементы окна, какие они бывают и для чего
служат?
 Назовите общие свойства управляющих элементов.
 Назовите общие события управляющих элементов.
 Что такое Палитра Компонентов и как она используется?
 Как осуществляется управление компонентами в Delphi - проекте?
 Как установить основные свойства компонента в Delphi - проекте.
 Как установить основные события главной формы в Delphi - проекте.
4.6 ВАРИАНТЫ ЗАДАНИЙ.
1.Спроектировать форму с элементами управления и двумя окнами
ввода типа TEdit для ввода текста и одним окном вывода типа TMemo для
вывода сцепления текста окон ввода.
2.Спроектировать форму с элементами управления и двумя окнами
ввода типа TEdit для ввода текста и одним окном вывода типа TMemo для
вывода сцепления текста окон ввода с заменой строчных букв на
заглавные.
3.Спроектировать форму с элементами управления и двумя окнами
ввода типа TEdit для ввода текста и одним окном вывода типа TMemo для
вывода сцепления текста окон ввода с заменой заглавных букв на
строчные.
4.Спроектировать форму с элементами управления и двумя окнами
ввода типа TEdit для ввода текста и одним окном вывода типа TMemo для
вывода символов, повторяющихся в обоих окнах ввода.
5.Спроектировать форму с элементами управления и двумя окнами
ввода типа TEdit для ввода текста и одним окном вывода типа TMemo для
вывода символов, не повторяющихся в обоих окнах ввода.
73
6.Спроектировать форму с элементами управления и двумя окнами
ввода типа TEdit для ввода текста и одним окном вывода типа TMemo для
вывода сцепления текста окон ввода с изменением последовательности
символов на противоположную.
7.Спроектировать форму с элементами управления и двумя окнами
ввода типа TEdit для ввода текста и одним окном вывода типа TMemo для
вывода двукратного сцепления текста окон ввода с изменением
последовательности символов на противоположную.
8.Спроектировать форму с элементами управления и двумя окнами
ввода типа TEdit для ввода текста и одним окном вывода типа TMemo для
вывода двукратного сцепления текста окон ввода.
9.Спроектировать форму с элементами управления и двумя окнами
ввода типа TEdit для ввода текста и одним окном вывода типа TMemo для
вывода текста окон ввода, в котором строка второго окна ввода вставлена в
середину строки первого окна ввода.
10.Более сложные варианты по согласованию с преподавателем.
74
5 ИЗУЧЕНИЕ СРЕДСТВ СОЗДАНИЯ И ИСПОЛЬЗОВАНИЯ
МЕНЮ В DELPHI - ПРОЕКТАХ
Цель работы: изучение методов и средств создания и использования
меню в Delphi проектах
5.1 МЕТОДИКА ВЫПОЛНЕНИЯ РАБОТЫ
Практически любое Windows-приложение имеет меню, которое
приходится разрабатывать каждому программисту. Оно должно само
появляться на экране вашего компьютера после старта практически любого
Windows-приложения. Меню — это список возможностей, которые
программа предоставляет в ваше распоряжение пользователя и кототорые
вы можете выбирать по своему желанию Выбор пунктов меню
осуществляют как с помощью мыши, так и с клавиатуры.
Рис. 5.1.
Различают два типа меню:
• главное меню формы;
• вспомогательные всплывающие меню
75
Главное меню обычно расположено под заголовком формы. Выбор
пункта главного меню вызывает появление на экране выпадающего меню
(рис. 5.1).
Выпадающее меню содержит пользовательские команды. Среди них
могут встречаться пункты, выбор которых приводит к появлению
вложенных выпадающих меню. Уровень вложенности практически не
ограничен, но современное представление о хорошем пользовательском
интерфейсе требует, чтобы вложенность была минимальной.
Всплывающие меню не имеют постоянного места внутри формы. Они
не привязаны к главному меню и появляются (всплывают) лишь по
специальному требованию со стороны пользователя, как правило, по
щелчку правой кнопки мыши (рис. 5.2).
Рис. 5.2
Всплывающие меню идеально подходят для размещения команд,
специфичных для каждого отдельного управляющего элемента формы.
Поскольку доступ к командам всплывающего меню происходит быстрее,
чем к командам главного меню, использование всплывающих меню делает
пользовательский интерфейс более удобным.
Для главного и всплывающего меню Delphi имеет два разных
компонента: MainMenu и PopupMenu. Их установка происходит одинаково,
но результат будет разным.
76
5.1.1 Главное меню
Начните в Delphi новое приложение. Выберите команду File|New
Application. На экране появится чистая форма. В качестве примера
разработаем приложение, например для просмотра, редактирования и
сохранения файлов, и назовем форму Text Edit (можно дать и другое
название, на русском языке). Выберите в Инспекторе Объектов свойство
Caption и впишите там эту строку.
Найдите в Инспекторе Объектов свойство Name и впишите значение
EditForm (можно и другое, но обязательно латинское). Сохраните модуль
главной формы и весь проект, выполнив команду Меню File | Save. Модуль
назовите Main.pas, а проект — TextEdit.dpr.
Приступим к изучению средств создания меню на примере меню
работы с файлами.
Отображение в форме главного меню (main menu) обеспечивает
компонент MainMenu, расположенный в Палитре Компонентов на странице
Standard (рис. 5.3). Поместите компонент на форму и дайте ему имя
MainMenu (значение свойства Name).
Рис. 5.3
Рассмотрим самые важные свойства компонента MainMenu (см. табл.
5.1).
Табл. 5.1
Свойство
Описание
AutoMerg
Определяет, сливается ли главное меню вторичной
e
формы с главным меню главной формы. Способ слияния
определяется значением свойства Grouplndex каждого
пункта меню верхнего уровня.
Items
Обеспечивает доступ к пунктам меню верхнего уровня
Значок компонента MainMenu, который вы видите на форме,
отображается лишь на этапе разработки. Он нужен для того, чтобы вы
могли быстро активизировать компонент и перейти к установке его свойств
в Инспекторе Объектов. Однако компонент MainMenu является
невизуальным, и на этапе выполнения приложения его значок не
отображается. Пользователь видит результат работы компонента — строку
меню с пунктами.
77
Рис. 5.4
Пока в меню нет пунктов, нет и самого меню. Добавление новых
пунктов выполняется в специальном окне Дизайнера Меню.
5.1.2 Дизайнер меню
Дизайнер Меню вызывается из всплывающего меню компонента
MainMenu (рис. 5.4.)
Выберите команду MenuDesigner, и на экране появится окно Дизайнера
Меню с заголовком TextEdit MainMenu1 (рис. 5.5). Чтобы обеспечить
наиболее эффективный способ создания меню, Дизайнер Меню работает в
паре с Инспектором Объектов. Управление пунктами меню, в частности их
создание и удаление, осуществляется в окне Дизайнера Меню, а свойства
каждого пункта, например его текст и клавиатурное сокращение,
устанавливаются в Инспекторе Объектов.
Строка главного меню состоит из одного безымянного пункта. Дайте
пункту программный идентификатор (значение свойства Name) Fileltem
(система сама по умолчанию присваивает всем объектам идентификаторы,
но лучше их изменять на смысловые), впишите в значении свойства
Caption его текст &File (рис. 5.5). Символ & обеспечивает подчеркивание
следующего за ним символа F при отображении текста, поэтому пункт
меню будет виден как File. Подчеркнутая буква используется в
комбинации с клавишей Alt для прямого доступа к пункту меню с
78
клавиатуры. В данном случае активизация пункта File будет происходить
по комбинации клавиш Alt+F.
Рис. 5.5
Под пунктом File создадим выпадающее меню. Для этого щелкните в
Дизайнере Меню на пункте File, под пунктом File появится пустая ячейка заготовка первого пункта выпадающего меню. Дайте пункту программный
идентификатор Openltem, а в свойстве Caption впишите текст &0реn. В
пустой ячейке появится текст Open, а ниже - пустая ячейка.
Аналогично добавьте еще три пункга: Save As , Close и Exit. В
программе назовем их SaveAsltem, Closeltem и Exitltem соответственно
(рис. 5.6). Не пытайтесь удалить пустой пункт, завершающий список
команд - ничего не выйдет. Да это и не требуется, т.к. пустые висячие
пункты не отображаются в меню во время работы приложения.
Кроме этого в Дизайнере Меню для каждого пункта предусмотрено
локальное всплывающее меню (активизируется правой кнопкой мыши) с
набором команд вставки, удаления отдельных пунктов, создания
вложенных меню. Список команд - в табл. 5.2.
79
Рис. 5.6
Tабл. 5.2
Команда
Insert
Delete
Create
Submenu
Select Menu
Save
Template
Insert
Template
Delete
Templates
Insert
Resource
Описание
Вставляет в позиции курсора новый пункт.
Удаляет пункт в позиции курсора
Создает в позиции пункта выпадающее меню.
Предлагает выбрать для работы другой компонент
меню
As
Сохраняет текущую структуру меню в списке
шаблонов
From
Вставляет в позиции курсора меню, взятое из
списка шаблонов
Удаляет шаблон(ы) меню
From
Вставляет в позиции курсора меню, взятое из
файла ресурсов.
80
Бывает, спроектировав меню, вы обнаруживаете, что какой-то пункт
стоит не на своем месте. Проблема решается просто: захватите пункт меню
мышью и отбуксируйте его к новой позиции. Таким образом можно
переместить не только отдельный пункт, но и целое выпадающее меню со
всеми его пунктами и вложенными меню
5.1.3 Пункты меню
Пункты меню являются компонентами. Класс пункта меню называется
TMenultem, его самые важные свойства приведены в табл. 5.3.
Рис. 5.7.
В Палитре Компонентов нет компонента Menultem, т.к. пункты меню
не существуют сами по себе, а работают только в составе строки главного
меню или окна всплывающего меню. Тем не менее они во многом ведут
себя как настоящие компоненты, например настраиваются в Инспекторе
Объектов и помещаются в исходный текст формы в виде отдельных полей.
Чтобы в этом убедиться, активизируйте Редактор Кода и найдите
определение класса формы. Оно будет таким, как на рис. 5.7.
Табл. 5.3
Свойство
Описание
Break
Если равно mbBreak или mbBarBreak, то пункт меню
начинает
новую
колонку.
Значение
mbBarBreak
обеспечивает отделение новой колонки от старой
вертикальной чертой
Caption
Текст пункта меню
Checked
Если равно True, то пункт меню содержит метку:
81
Enabled
Groupind
ex
Hint
RadioIte
m
Shortcut
Visible
5.1.4
«птичку» или жирную точку в зависимости от значения
свойства RadioItem
Если True, пункт меню доступен пользователю
Работает по-разному в зависимости от того, находится
пункт в выпадающем меню или в строке главного меню.
Пункты выпадающего меню с одинаковым положительным
значением
GroupIndex
согласованно
переключают
«птичку» или жирную точку (вид метки определяется
свойством RadioItem). Пункты строки главного меню,
находящиеся в дочерней форме MDI, сливаются с
пунктами главного меню обрамляющей формы MDI при
активизации дочерней формы. При этом, если в строке
главного меню обрамляющей формы существуют пункты с
таким же значением свойства GroupIndex, то новый пункт
со своим списком пунктов полностью заменяет старый; в
противном случае новый пункт со своим списком пунктов
вставляется в строку главного меню. Более подробно
слияние меню изложено в справочнике Delphi.
Подсказка для пользователя, отображаемая в строке
состояния
Если равно True, то метка пункта имеет вид жирной
точки и несколько пунктов с одинаковым значением
GroupIndex работают как зависимые переключатели установка у одного пункта свойства Checked в True
снимает метку с другого пункта
Комбинация клавиш для выполнения команды, не
открывая меню
Определяет, виден ли пункт меню пользователю
Разделительные линии
Группы логически связанных между собой команды принято разделять
горизонтальной линией. Так, пункт Exit обычно отделяют от остальных.
Для этого вставьте новый пункт и запишите в значении его свойства
Caption символ минуса (-) (рис. 5.8).
Delphi знает, что одиночный символ минуса в имени пункта меню
означает разделитель и нарисует для пункта горизонтальную линию. Это
не запрещает создавать пункты, имена которых начинаются со знака
минус. Если записать что-нибудь после знака минус, то в имени пункта
отобразится весь введенный текст.
82
Рис. 5.8
5.1.5 Клавиатурные сокращения
Некоторым пунктам меню назначают клавиатурные сокращения.
Клавиатурное сокращение (shortcut) — это комбинация клавиш на
клавиатуре, дублирующая главное меню. Например, в некоторых
программах команде меню File | Exit назначают сокращение Alt+X. Текст
сокращения отображается в названии пункта справа от него. Сокращения
ускоряют работу с приложением и популярны среди опытных
пользователей.
Чтобы назначить пункту сокращение, активизируйте этот пункт в
Дизайнере Меню, переключитесь на Инспектор Объектов и выберите в
значении
свойства
Shortcut
требуемую
комбинацию
клавиш,
предварительно раскрыв таблицу их стандартных значений щелчком
мыши. Можно ввести текст сокращения с клавиатуры (рис. 5 9).
Имейте в виду, что Delphi не отслеживает дублирование одного и того
же сокращения для нескольких пунктов меню, за это отвечает
программист.
5.1.6 Обработка команд меню
Все пункты меню готовы, но для них пока нет обработчиков событий.
Реализуем закрытие формы по команде Exit. Эта задача сводится к
обработке события OnClick, генерируемого в компоненте ExitItem при
выборе пользователем пункта Exit.
Активизируйте в Дизайнере Меню пункт Exit, выберите в Инспекторе
Объектов страницу Events и сделайте двойной щелчок мышью на значении
события OnClick. В результате откроется Редактор Кода, в котором
83
появится заготовка обработчика события. Обработка команды Exit
сводится к вызову метода Close, закрывающего форму (а заодно и
приложение, поскольку это единственная форма). Запишем в позиции
курсора Close; - обработчик готов (рис. 5.10).
Рис. 5.9
Рис. 5.10
Подключение меню к форме выполняется с помощью свойства формы
Menu. Отыскав его в Инспекторе Объектов, вы обнаружите, что оно уже
содержит идентификатор спроектированного меню MainMenu1, поэтому в
данном случае для работы меню больше ничего не нужно.
84
Проверим работу меню. Откомпилируйте и запустите проект. На
экране появится форма со строкой меню под заголовком. Выбор в меню
любой команды кроме Exit безрезультатен. По команде Exit или
комбинации клавиш Alt+X окно закроется и приложение завершится.
Для создания обработчиков событий для пунктов меню Open и Save As
необходимо решить две задачи
• организовать выбор файла по командам меню Open и Save As ,
• реализовать загрузку и отображение текстового файла.
Первая задача решается с помощью диалоговых компонентов
OpenDialog, SaveDialog (страница Dialogs), вторая — с помощью
компонентов Edit, Memo, (страница Standard), RichEdit (страница Win32).
5.1.6.1 Диалоговые окна открытия и сохранения файла
Найдите компонент OpenDialog и SaveDialog в Палитре Компонентов
на странице Dialogs и поместите на форму. Первый компонент назовите
OpenDialog1, а второй — SaveDialog1. Важнейшие свойства этих
компонентов кратко описаны в табл. 5.4.
табл. 5.4
Свойство
Описание.
DefaultExt
Расширение, которое добавляется к имени файла, если
пользовать его пропустил
FileName
Начальное имя файла
FiIter
Фильтр имени файла
FiIterlndex
Номер активного фильтра
InitialDir
Начальный каталог, открываемый при первом
появлении окна диалога
Options
Параметры, определяющие внешний вид и поведение
окна диалога (см. табл. 5.5).
Title
Заголовок окна диалога. Если значение свойства не
указано, то заголовок будет стандартным - Open (Открыть)
или Save (Сохранить), в зависимости от типа компонента.
Компоненты OpenDialog и SaveDialog сходны между собой, оба
являются объектами стандартных диалоговых окон Windows Open è Save
(рис. 5.11).
Приблизительный сценарий работы с каждым из компонентов
OpenDialog и SaveDialog таков. Компонент помещается на форму и
конфигурируется для выбора тех или иных файлов. По команде меню
Open... или Save As... у соответствующего компонента вызывается метод
Execute, который выполняет диалог и возвращает значение True, если
пользователь выбрал файл. Полный маршрут к файлу запоминается в
значении свойства FileName. Ход дальнейших действий зависит от
85
прикладной задачи и, как правило, включает или чтение, или запись файла,
в зависимости от команды меню.
Приспособим компоненты OpenDialog и SaveDialog для текстовых
файлов с расширениями txt, pas, dpr. Чтобы пользователь мог
просматривать файлы выборочно, т.е. какого-то одного типа, в диалоговых
блоках имеется набор фильтров, оформленный в виде выпадающего списка
Files of type (тип файлов - см. рис. 5.11). Исходные данные для этого списка
устанавливаются в свойстве Filter (рис. 5.12). Номер активного в данный
момент фильтра записывается в свойстве FilterIndex.
Рис. 5.11
Приступим к формированию фильтров. Активизируйте на форме
компонент OpenDialog и сделайте двойной щелчок мыши на значении
свойства Filter в Инспекторе Объектов (рис. 5.12) При этом на экране
появится Редактор Фильтра (рис. 5.13), представляющий собой список с
двумя колонками. В левой колонке вводится текст, отображаемый в
выпадающем списке Files of type. В правой колонке через точку с запятой
записываются маски, на основании которых выполняется фильтрация
файлов в окне диалога. Для максимального удобства при выборе файлов
установите в компоненте OpenDialog фильтры, показанные на рис. 5.13.
Аналогично установите фильтры в компоненте SaveDialog,
86
Рис. 5.12
Рис. 5.13
Компоненты OpenDialog и SaveDialog имеют много булевских
параметров, организованных в виде флагов составного свойства Options.
Эти параметры влияют на то, как окно диалога выглядит и работает. По
87
умолчанию все параметры имеют значение False. Результат установки
параметров в значение True прокомментирован в табл. 5.5.
табл. 5.5
Параметр
Описание
ofAllowMultiSele
Если True, пользователь может выделить сразу
ct
несколько файлов
ofCreatePrompt
Если True и пользователь вводит имя
несуществующего файла, пользователю задается
вопрос, желает ли он создать новый файл с таким
именем
ofExtensionDiffer
Этот
параметр
устанавливается
после
ent
завершения диалога, если расширение в имени
файла отличается от начального расширения
ofFileMustExist
Если True, пользователь не сможет ввести имя
несуществующего файла
ofHideReadOnly
Если True, переключатель Read-only отсутствует
в окне диалога
ofNoChangeDir
Если True, пользователь не сможет сменить
каталог в окне диалога
ofNoDereference
Если True, ярлыки к каталогам трактуются как
Links
обычные файлы. В противном случае они
трактуются как каталоги.
ofNolongNames
Если True, длинные имена файлов запрещены
ofNoNetworkBut
Если True, кнопка Network отсутствует в окне
ton
диалога. Этот параметр работает только в паре с
параметром ofOldStyleDialog
ofNoReadOnlyR
Если True, пользователь не сможет ввести файл
eturn
с атрибутом read-only (только для чтения).
ofNoTestFileCre
Если True, проверка на возможность записи в
ate
каталог не выполняется.
ofNoValidate
Если True, пользователь может вводить в имени
файла любые символы, даже недопустимые
ofOldStyleDialog
Если True, окно диалога отображается в стиле
Windows 3.1
ofOverwriteProm
Если
True,
пользователю
выдается
pt
предупреждение при попытке сохранить файл с
именем, которое уже существует
ofReadOnly
Если True, переключатель Read-only в окне
диалога включен
ofPathMustExist
Если True, пользователь не сможет ввести для
файла несуществующий маршрут
88
ofShareAware
Если True, ошибки одновременного доступа к
файлу со стороны нескольких приложений
игнорируются
ofShowHelp
Если True, в окне диалога присутствует кнопка
Help
В нашем простом примере ограничимся тем, что установим в обоих
компонентах параметр ofHideReadOnly, а в компоненте SaveDialog — еще и
параметр ofOverwritePrompt.
5.1.6.2 Компоненты для ввода и отображения текста.
Для ввода неформатированного текста предназначены компоненты Edit
и Memo. Они представляют собой однострочный и многострочный
редакторы (кроме них существуют и другие компоненты сходного
назначения).
Однострочный редактор Edit служит для ввода различных слов, фраз и
другого короткого текста. Он не имеет полос прокрутки, но разрешает
прокручивать текст по горизонтали клавишами перемещения курсора влево
и вправо. Компонент Edit расположен в Палитре Компонентов на странице
Standard. Его основные свойства описаны в табл. 5.6.
Табл. 5.6
Свойство
Описание
AutoSele
Если True, при активизации редактора находящийся в
ct
нем текст автоматически выделяется
AutoSize
Если True, высота редактора автоматически подгоняется
по высоте текста
CharCase
Преобразует текст к прописным или строчным буквам:
ecUpperCase - к прописным буквам, ecLowerCase - к
строчным буквам, ecNormal -преобразование символов не
выполняется
HideSelec
Если True, при потере редактором активности выделение
tion
текста снимается
MaxLeng
Максимальное
количество
символов,
которое
th
пользователь может ввести. Если оно равно 0, то
пользователь может ввести текст неограниченной длины
OEMCon
Если True, символы текста преобразуются в кодовую
vert
таблицу OEM
Password
Если не равно #0, указанный в этом свойстве символ
Char
отображается вместо каждого символа текста. Применяется
для ввода пароля
ReadOnly
Если True, пользователь не сможет изменить текст в
редакторе
Text
Редактируемый текст
89
Редактируемый текст содержится в свойстве Text. Его максимальная
длина определяется значением свойства MaxLength.
Рис. 5.14
Иногда
компонент
Edit
используется
для
отображения
нередактируемого текста. Для этого свойство ReadOnly устанавливается в
True. В таком состоянии он лучше компонента Label тем, что может
получать фокус ввода. Кроме того, с помощью присутствующего в
редакторе текстового маркера можно выделить блок текста и поместить его
в Буфер Обмена
Компонент Edit легко приспособить для ввода паролей. Для этого
достаточно установить в свойстве PasswordChar вместо символа #0 какойнибудь другой символ, обычно символ звездочки (*). Символ, заданный в
свойстве PasswordChar, отображается вместо символов обычного текста,
что мешает подсмотреть пароль посторонним.
Многострочный редактор представлен компонентом Memo, основные
свойства которого описаны в табл. 5.7. Компонент Memo похож на Edit, но
в отличие от него хранит не одну строку текста, а множество строк. Доступ
к строкам обеспечивает свойство Lines, представляющее собой объект
класса TStrings. С помощью свойства Lines строки можно добавлять,
вставлять, удалять и т.д. Свойство Lines доступно из Инспектора Объектов,
поэтому на стадии проектирования вы можете заполнить компонент Memo
некоторым исходным текстом. Этот текст увидит пользователь при
90
появлении формы на экране. Ввод исходного текста осуществляется в
Редакторе Строк (String list editor), который вызывается щелчком мыши на
многоточии в поле значения свойства Lines (рис. 5.14)
Табл. 5.7.
Свойство
Align
Alignmen
t
HideSelec
tion
Lines
MaxLeng
th
OEMCon
vert
ReadOnly
ScrollBar
s
WantRetu
rns
WantTab
s
WordWra
Описание
Способ выравнивания многострочного редактора в
пределах владельца
Расположение текста в пределах редактора: taLeftJustify
- прижат к левой границе, taRightJustify - прижат к правой
границе, taCenter -центрирован
Если равно True, то при потере редактором активности
выделение текста снимается
Строки текста в многострочном редакторе
Максимальное
количество
символов,
которое
пользователь может ввести. Если оно равно 0, то
пользователь может ввести текст неограниченной длины
Если равно True, то символы текста преобразуются в
кодовую таблицу OEM.
Если равно True, то пользователь не сможет изменить
текст в редакторе
Управляет видимостью полос прокрутки: ssNone полосы прокрутки скрыты, ssBoth - полосы прокрутки
видны, ssHorizontal - видна лишь горизонтальная полоса
прокрутки, ssVertical - видна лишь вертикальная полоса
прокрутки
Если равно True, то клавиша Enter начинает в редакторе
новую строку
Если равно True, то клавиша Tab вставляет в текст
символ табуляции, вместо того чтобы передать фокус
ввода следующему управляющему элементу
Если равно True, то работает перенос слов
p
Компонент Memo часто имеет одну или две полосы прокрутки
(вертикальную и горизонтальную). Их появление зависит от значения
свойства ScrollBars.
5.1.7 Законченный Редактор текста.
Поместите на форму компонент Memo и дайте ему имя (Name) Memo1.
Установите свойства: MaxLength =0; HideSelection = True; ScrollBars =
ssBoth; WantReturns = True;
91
Проанализируйте эти значения по табл. 5.7.
Теперь создадим обработчики событий для пунктов главного меню
Open, Save As, Close. Для этого:
Активизируйте на форме пункт меню File | Open и в Инспекторе
Объектов на странице событий двойным щелчком мыши активизируйте
заготовку события OnClick - появится окно редактора кода с текстом
модуля Unit.pas - с активным указателем курсора в том месте заготовки
обработчика с именем OpenItemClick, в которое нужно дописать его код,
что и сделаем (рис. 5.15).
Рис. 5.15
Смысл добавленного кода такой: если из пункта меню Open вызван
метод Execute компонента OpenDialog1, и если пользователь выбрал файл,
в поле Lines компонента Memo1 загрузить (процедурой LoadFromFile) имя
выбранного в компоненте OpenDialog1 файла.
Командой Run откомпилируйте и проверьте правильность работы
программы.
Проделайте аналогичные действия для пункта меню File | SaveAs, имя
обработчика события для которого - SaveAsItemClick. После добавления
кода он выглядит так (рис. 5.16):
Смысл вставленного кода такой: если из пункта меню Save As вызван
метод Execute компонента SaveDialog1, и если пользователь выбрал имя
сохраняемого файла, содержимое из поля Lines компонента Memo1
записывается (процедурой SaveToFile) в файл, имя которого выбрано в
компоненте OpenDialog1.
Проделайте аналогичные действия для пункта меню File | Close, имя
обработчика события для которого - CloseItemClick. После добавления
кода он выглядит так (рис. 5.17):
92
Рис. 5.16
Здесь вставлена всего одна строка. Ее смысл - удаление всех элементов
(методом Clear) из поля Lines (тип TString) объекта Memo1.
Проверьте проект в работе во всех режимах: открытие файла, его
редактирование, сохранение с другим именем, закрытие файла и выход из
программы. Если все проделано правильно, указанные функции
выполняются правильно за исключением работы с русским текстом, для
работы с которым нужны другие компоненты, которые обеспечивают
функции выбора шрифтов и изменения их параметров. Но это более
сложная тема, которую изучим позже.
Рис. 5.17
5.1.8 Всплывающее меню
Всплывающее (локальное) меню (pop-up menu) представлено в Delphi
компонентом PopupMenu. Отыщите его в Палитре Компонентов на
странице Standard по всплывающей подсказке и поместите на форму. Дайте
новому компоненту имя PopupMenu1.
Рассмотрим наиболее важные свойства компонента PopupMenu (табл.
5.8).
табл. 5.8
Свойство
Alignment
Описание
Определяет
место,
93
в
котором
появляется
меню
относительно курсора мыши: paLeft - левый верхний угол
меню совпадает с позицией курсора мыши; paCenter середина верхнего края меню совпадает с позицией
курсора мыши; paRight - правый верхний угол меню
совпадает с позицией курсора мыши
AutoPopup
Если равно True, то меню всплывает автоматически
после щелчка правой кнопки мыши. Если равно False, то за
отображение меню отвечает программист
Items
Обеспечивает доступ к пунктам меню.
Всплывающее меню cоздается Дизайнером Меню. Двойным щелчком
мыши на компоненте PopupMenu1 откройте окно Дизайнера Меню и для
упрощения добавьте в меню те же пункты, что и в главном меню. Для
удобства идентификаторы (свойство Name) пунктов меню следует
снабдить смысловой приставкой, например PopSaveItem, PopOpenItem. Во
всех пунктах всплывающего меню установите следующие свойства:
Enabled = False;(пока всплывающее меню не активно, все его пункты
запрещены).
Grouplndex = 1;
Radioltem = False;
Таким образом, команды всплывающего меню дублируют некоторые
команды главного меню, обеспечивая пользователю дополнительные
удобства.
Когда
проектирование
меню
завершено,
перейдем
к
программированию обработчиков событий. В данном примере команды
всплывающего меню обрабатываются также, как и команды одноименных
пунктов главного меню. Поскольку для пунктов главного меню
обработчики написаны, то их просто нужно подключить к пунктам
всплывающего меню. Для этого активизируйте в Дизайнере Меню пункт, к
которому подключаете обработчик, и на странице Events Инспектора
Объектов в значении события OnClick откройте выпадающий список и
выберите обработчик одноименного пункта главного меню. To же самое
проделайте с остальными пунктами.
Всплывающее меню готово, осталось сделать так, чтобы оно
вызывалось по щелчку правой кнопки мыши в области формы. Для этого
активизируйте форму и запишите в значении свойства формы PopupMenu
имя разработанного ранее всплывающего меню PopupMenu1. Вы можете
ввести это значение с клавиатуры или выбрать из выпадающего списка.
Откомпилируйте и запустите проект. Щелчок правой кнопки мыши в
окне приложения вызовет появление всплывающего меню. После этого
удостоверьтесь, что выпадающее меню работает синхронно с главным
меню.
94
5.2 ПОРЯДОК ВЫПОЛНЕНИЯ РАБОТЫ.
 Изучить основные свойства компонента главного меню в программах
Delphi.
 Изучить основные средства создания главного меню в программах
Delphi.
 Изучить основные средства создания обработчиков событий для
пунктов главного меню в среде программирования Delphi.
 Изучить основные средства создания всплывающего меню в
программах Delphi.
 Проанализировать и проверить практически пример приложения,
приведенный в описании работы.
 Ответить на контрольные вопросы.
 Пользуясь своим вариантом задания, разработать спецификацию
проекта с изображением главной формы и всех компонентов со всеми
надписями.
 Пользуясь визуальными средствами Delphi и своим вариантом задания,
создайте проект, откомпилируйте его и проверьте в работе.
 Составить отчет по лабораторной работе.
В отчет должны входить следующие пункты:
 Цель работы.
 Описание основных свойств компонентов главного и всплывающего
меню, средств их создания и подключения к главной форме.
 Описание процесса разработки алгоритма и программы по заданному
варианту.
 Результаты проверки программы.
 Вывод о проделанной работе.
5.3 КОНТРОЛЬНЫЕ ВОПРОСЫ
 Что такое компоненты меню, какие они бывают и для чего служат?
 Что такое свойства пунктов меню, какие они бывают и для чего служат?
 Что такое Дизайнер Меню, какие функции и как он выполняет?
 Как создаются пункты меню?
 Как обрабатываются команды пунктов меню?
 Как осуществляется синхронизация событий одноименных пунктов
главного и всплывающего меню в Delphi - проекте?
5.4 ВАРИАНТЫ ЗАДАНИЙ.
1. Спроектировать однострочный редактор просмотра, редактирования
и сохранения коротких текстов с соответствующими командами главного и
всплывающего меню.
95
2. Спроектировать однострочный редактор просмотра, редактирования
и сохранения коротких текстов с соответствующими командами главного
меню и запретом на доступность команд Save As и Close в тех случаях,
когда содержимое редактора пусто..
3. Модифицировать многострочный редактор, приведенный в качестве
примера, с запретом на доступность команд Save As и Close в тех случаях,
когда содержимое редактора пусто.
4. Более сложные варианты по согласованию с преподавателем.
96
6 ИЗУЧЕНИЕ ОСНОВ ПЕЧАТИ ИЗ DELPHI - ПРОГРАММ
Цель работы: изучение основных средств программирования печати в
среде Delphi.
6.1 МЕТОДИКА ВЫПОЛНЕНИЯ РАБОТЫ
Процесс печати внутренне достаточно сложен. Это вызвано тем, что
существует множество разных принтеров с разными принципами действия,
а для их согласования с компьютером служат специальные подпрограммыдрайверы. Windows имеет драйверы на все случаи жизни, a Delphi ими
пользуется.
Вывод на печать напоминает вывод на экран, но существует ряд
принципиальных отличий:
 результат вывода на печать материален; это изображение на бумаге или
пленке;
 точки, из которых формируется изображение на бумаге, обычно
намного меньше, чем на экране, поэтому изображение получается более
четким.
 по сравнению с выводом на дисплей печать является длительным
процессом, который можно приостановить или вообще прервать.
Программируя печать, все эти особенности нужно учитывать.
В Delphi печать осуществляется из компонентов. Например, компонент
Memo имеет окно для просмотра текста; а этот текст можно распечатать.
Некоторые компоненты (RichEdit, ChartFX, QuickReport) в смысле печати
имеют специально предназначенные для этого методы (например, Print), в
других (Memo) программист должен сам организовать печать данных.
Программируя печать, прежде всего исследуйте материал, который
собираетесь печатать. Если вы имеете дело с печатью форматированного
текста, то используйте компонент RichEdit. А он уже умеет печатать свои
данные. Если ваше приложение показывает пользователю диаграмму, то
скорее всего это делается с помощью компонента ChartFX. В нем
поддержка печати тоже инкапсулирована. Если вы работаете с обычным
неформатированным ASCII-текстом, то лучше всего воспользоваться
компонентом Memo. Этот компонент печатать не умеет, и печать текста
следует программировать самостоятельно. Если задача в том, чтобы
печатать рисуемые на экране геометрические фигуры, то никакой
компонент вам не поможет и единственный выход—работать
непосредственно с объектом Printer, инкапсулирующим интерфейс печати
Windows.
97
6.1.1 Выбор и настройка принтера
Лучшие изображения и документы получаются на цветных лазерных
принтерах с высоким разрешением. На старых принтерах, которые выводят
только символы, графическое изображение вообще печатать не удастся.
Существует множество моделей принтеров, причем несколько из них
могут быть подключены к вашему компьютеру или доступны из локальной
сети. Поэтому вы должны сообщить Delphi (точнее Windows) данные о
конкретном принтере, на котором вы собираетесь печатать. Этот процесс
называется выбором и настройкой принтера. В Delphi этим занимается
компонент PrinterSetupDialog, размещенный в Палитре Компонентов на
странице Dialogs.
Рис. 6.1.
Для печати прежде всего следует организовать выбор принтера. Для
этого:
Начните новое приложение, выбрав команду меню File | New
Application. Задайте для формы приложения заголовок (Caption) —
например PrintDemo.
В Палитре Компонентов на странице Standard выберите компонент
Panel и поместите его на форму. Это будет панель для кнопки Printer Setup.
Установите свойства панели в следующие значения:
Align = alTop
BevelOuter = bvNone
Caption = <пусто>
98
В Палитре Компонентов на странице Additional выберите компонент
SpeedButton и поместите его на панель. Эта кнопка будет вызывать
процедуру настройки. Сделайте кнопку шире и установите ее свойства в
следующие значения
Name = PrinterSetupBtn
Caption = Printer &Setup...
В Палитре Компонентов на странице Dialogs выберите компонент
PrinterSetupDialog и поместите его на форму. Этот невизуальный
компонент будет выдавать на экран окно диалога настройки принтера.
Помните: на стадии проектирования значок компонента будет виден на
экране, а во время выполнения — нет.
Рис. 6.2.
Для кнопки Printer Setup... определите следующий обработчик события
OnClick
procedure TForm1.PrinterSetupBtnClick(Sender: TObject) ;
begin
PrinterSetupDialogl.Execute;
end;
При этом на экране должно получиться что-то подобное рис. 6.1.
99
Сохраните модуль с формой под именем. Main pas, а проект — под
именем PrnDemo.dpr. Выполните компиляцию проекта и запустите
приложение. В появившемся окне нажмите кнопку Printer Setup... — на
экране будет диалог выбора и настройки принтера (рис. 6.2).
Вам остается выбрать из списка соответствующий тип принтера,
указать формат бумаги и ее ориентацию. Если принтер требует более
тонкой настройки, щелкните по кнопке Properties (Свойства) и в
появившемся окне диалога установите параметры, зависимые от модели
принтера.
Рис. 6.3
Например, для принтера Oki ML182 Elite (IBM) в этом окне диалога на
странице Графика (рис. 6.3) можно задать разрешающую способность
(количество точек на один дюйм), качество печати полутонов точечных
рисунков, интенсивность расхода красителя и др., а на странице Бумага
(рис. 6.4) - размер бумаги, ее ориентация (книжная или альбомная), способ
ее подачи.
100
6.1.2 Установка параметров печати
После выбора принтера нужно вставить параметры печати: указать, с
какой страницы документа начать печать и какой закончить, сколько
делать копий и т.д. Это делается в диалоговом окне, которое создает
компонент PrintDialog, расположенный в Палитре Компонентов на
странице Dialogs.
Некоторые важные свойства компонента PrintDialog кратко описаны в
табл. 6.1., 6.2.
Табл. 6.1
Property
Collate
Description
Состояние
переключателя
Collate,
разделение по копиям.
Количество копий документа.
Диапазон всех печатаемых страниц.
задающего
Copies
FromPag
e, ToPage
PrintToFi
Состояние переключателя, задающего печать в файл на
le
диске, а не на принтер.
PrintRan
Тип диапазона печати prAllPages (печатать все
ge
страницы) или prSelection (печатать выборочные страницы).
Options
Множество флагов, задающих параметры диалога (см.
табл. 6.2).
MaxPage
Минимальное и максимальное значения номеров, в
, MinPage
пределах которых пользователь может задать диапазон
печатаемых страниц.
Табл. 6.2
Option
poPrintToFile
poPageNums
poSelection
poWarning
Description
Отображает переключатель PrintToFile, с
помощью
которого
пользователь
может
перенаправить печать в файл.
Разрешает
пользователю
использовать
зависимый переключатель Pages для указания
диапазона печатаемых страниц.
Разрешает
пользователю
использовать
зависимый переключатель Selection для печати
лишь выделенного блока текста.
Задает
выдачу
предупреждающего
сообщения в том случае, если пользователь
нажал в окне диалога кнопку ОК, но в системе не
установлено ни одного принтера.
101
poDisablePrintToFile
poHelp
Запрещает в окне диалога переключатель
Print to File.
Отображает в окне диалога кнопку Help.
Для того чтобы выполнить диалог установки параметров печати, у
компонента PrintDialog надо вызвать метод Execute. Этот метод является
булевской функцией, которая возвращает Тrue, если пользователь
завершил диалог по кнопке ОК. Внешний вид окна диалога,
отображаемого во время работы метода Execute, показан на рисунке (рис.
6.5).
Компонент PrintDialog не используется в отрыве от процесса печати,
поэтому мы рассмотрим его практическое использование в примерах
печати текста и графики.
Рис. 6.4
6.1.3 Печать форматированного текста
Проще всего организовать печать текста, украшенного всякими
шрифтами. Для работы с таким текстом обычно используют компонент
RichEdit. Печать из него покажем на примере создания небольшой
программы, которая может открывать, просматривать и печатать RTFфайлы (RTF — это один из самых популярных форматов для хранения
форматированного текста). Продолжим предыдущий пример.
102
Рис. 6.5
Рис. 6.6
103
В Палитре Компонентов со страницы Win32 возьмите компонент
RichEdit и поместите его на форму ниже панели. Установите значения
свойств:
Align =alClient
ScrollBars = ssBoth
Щелчком на кнопке с многоточием вызовите для свойства Lines окно
Редактора Строк (окно String list editor) и удалите в нем весь текст.
Компонент для отображения форматированного текста на экране готов.
Добавьте на инструментальную панель две кнопки типа SpeedButton,
взяв их из Палитры Компонентов со страницы Additional. Расширьте
кнопки, чтобы на них можно было написать текст. Первая кнопка будет
открывать файл для просмотра и загружать его в компонент RichEdit.
Установите в ней следующие свойства:
Name =OpenBtn
Caption = &0pen...
Вторая кнопка будет печатать содержимое компонента RichEdit,
сделайте ее такой:
Name = PrintBtn
Caption = &Print
Поместите на форму компоненты OpenDialog и PrintDialog, взяв их из
Палитры Компонентов со страницы Dialogs. Это средства для открытия
файла и настройки параметров печати. Дайте свойствам компонента
OpenDialog следующие значения:
DefaulExt = rtf
Filter = Rich Text (*.rtf)|*.rtf
Свойства компонента PrintDialog можете оставить без изменений. К
этому моменту форма будет такой (рис. 6.6):
Визуальная часть работы сделана, теперь напишем обработчики
событий для добавленных на панель кнопок. Выполните двойной щелчок
на кнопке Open... и напишите для нее обработчик события OnClick:
procedure TForm1.OpenBtnClick (Sender: TObject) ;
begin
if OpenDialog1.Execute then
begin
Caption:= ‘Print Demo - ‘ + OpenDialog1.FileName;
RichEditl.Lines.LoadFromFile(OpenDialog1.FileName);
end;
104
end;
Выполните двойной щелчок на кнопке Print... и напишите для нее
обработчик события OnClick:
procedure TForm1.PrintBtnCIick (Sender: TObject) ;
begin
if PrintDialog1.Execute then
RichEdit1.Print(OpenDialog1.FileName) ;
end;
Проект готов. Выполните его компиляцию и запустите приложение.
Нажмите кнопку Open..., отыщите какой-нибудь RTF-файл и загрузите его.
Когда в окне редактора покажется текст, подготовьте принтер, нажмите
кнопку Print... и распечатайте текст.
6.1.4 Печать простого текста
Если по условию задачи требуется просматривать и печатать простой
текст, то используют компонент Memo. Он не имеет методов печати,
поэтому программист должен написать их сам, используя процедуры
работы с файлами. Специально для организации такого рода печати в
модуле Printers существует процедура AssignPrn(var F:Text), которая
связывает текстовую файловую переменную F с текущим принтером, что
позволяет направить на принтер текстовые данные с помощью
традиционных процедур Write и Writeln. Чтобы показать суть данного
метода, давайте переработаем предыдущий пример:
Замените в форме компонент RichEdit на Memo, взяв его в Палитре
Компонентов со страницы Standard и установите для него значения
свойств:
Align = alClient
ScrollBars = ssBoth
Для свойства Lines вызовите Редактор Строк и удалите в нем весь текст
так, как это было сделано для компонента RichEdit.
Поскольку нам предстоит работать с обычными текстовыми файлами,
скорректируйте некоторые свойства компонента OpenDialog:
DefaulExt = txt
Filter = Text (*.txt)|*.txt
Теперь скорректируем исходный текст модуля формы.
Подключите в секции implementation модуль Printers:
uses Printers;
В этом модуле объявлена процедура AssignPrn, которая понадобится
при печати текста.
105
Скорректируйте для кнопки Open... обработчик события OnClick,
заменив в нем идентификатор RichEdit1 на Меmо1:
procedure TForm1 .OpenBtnClick (Sender: TObject) ;
begin
if OpenDialog1.Execute then
begin Caption := ‘Print Demo - ‘ + OpenDialog1.FileName;
Меmо1.Lines.LoadFromFile(OpenDialog1.FileName);
end;
end;
Перепишите для кнопки Print... обработчик события OnClick:
procedure TForml.PrintBtnClick (Sender: TObject) ;
var
Prn: TextFile;
I: Integer;
begin
if PrintDialogl.Execute then
begin
AssignPrn(Prn);
Rewrite(Prn);
for I := 0 to Memol.Lines.Count-1 do
Writeln(Prn, Memol.Lines[I]);
CloseFile(Prn);
end;
end;
Выполните приложение и распечатайте какой-нибудь текст. Если вам
не понравится печатный шрифт, скорректируйте приведенный выше
обработчик событий, поместив перед оператором AssignPrn(Prn)
следующие две строки:
Prinег.Canvas.Font.Name := ‘Arial’;
Printer.Canvas.Font.Size := 10;
Они установят шрифт Arial с размером 10 пит.
6.1.5 Печать графики
Задачи подобного рода решаются просто: графическое изображение
рисуется на принтере так же, как на экране, — с помощью свойств и
методов объекта TCanvas. Однако при печати объект TCanvas берется у
объекта Printer.
106
Табл.6.3
Свойство
Aborted
PageHeigh
Описание
Показывает, прервана ли печать.
Высота страницы в пикселах.
PageNumb
Номер печатаемой страницы.
t
er
Printing
Title
Показывает, выполняется ли печать.
Текстовая строка, идентифицирующая печатаемый
документ в окне Мененжера Печати (PrintManager)
PageWidth
Ширина страницы в пикселах
Для начала печати у объекта Printer вызывается метод BeginDoc, а для
завершения — метод EndDoc. Для преждевременной остановки печати
вызывается метод Abort. Перевод страниц выполняет метод NewPage.
Параметры печати хранятся в свойствах объекта Printer, которые описаны в
табл 6.3.
Покажем, как выполняется печать графических фигур на примере
вывода квадрата.
Возьмите за основу предыдущий проект. Удалите с формы кнопку
Open и компонент OpenDialog (мы будем рисовать перед печатью, а не
открывать файл). Оставшиеся кнопки сместите влево. Поскольку кнопки
Open .. уже нет, обработчик ее события тоже не нужен - сделайте его
пустым. (Delphi сама удалит его)
Замените на форме компонент Memo на PaintBox, взяв последний в
Палитре Компонентов со страницы System. Установите для нового
компонента свойство Align в значение alClient. Компонент PaintBox
используется для вывода графики на экран. В его окне мы нарисуем
изображение, которое потом повторим на принтере.
Определите для компонента PaintBox обработчик события OnPaint:
procedure TForm1.PaintBox1Paint (Sender: TObject);
begin
DoPaint (PaintBoxl.Canvas);
end;
DoPaint — это еще не написанный метод, который будет рисовать
какую-нибудь графическую фигуру. Объявите его в классе TForm1:
type
TForm1= class(TForm)
107

рublic
procedure DoPaint(Canvas: TCanvas);
end;
и запишите код метода в секции implementation программного модуля:
procedure TForm1.DoPaint (Canvas: TCanvas) ;
begin
Canvas.Brush.Color := clBlack;
Canvas.Rectangle(50, 50, 150, 150);
end;
Теперь переделайте у кнопки Print... обработчик события OnClick:
procedure TForm1. PrintBtnClick(Sender:TObject) ;
begin
if PrintDialog1 .Execute then
begin
Printer.BeginDoc; { начать печать }
DoPaint(Printer.Canvas) ; { рисование на бумаге }
Printer.EndDoc; { закончить печать }
end;
end;
Выполните компиляцию и запустите приложение. Нажмите кнопку
Print... и распечатайте квадрат.
6.2 ПОРЯДОК ВЫПОЛНЕНИЯ РАБОТЫ.
 Изучить основы программирования печати в Delphi - программах.
 Изучить основные свойства компонент печати среды Delphi.
 Изучить основы создания обработчиков событий.
 Изучить основы компиляции и проверки работоспособности программ.
 Ответить на контрольные вопросы.
 Пользуясь визуальными средствами Delphi и своим вариантом задания,
создайте проект с установкой заданного принтера, откомпилируйте его
и проверьте в работе.
 Составить отчет по лабораторной работе.
 В отчет должны входить следующие пункты:
 Цель работы.
 Описание основных средств программирования печати.
 Описание процесса разработки программы по заданному варианту.
 Результаты проверки программы.
 Вывод о проделанной работе.
108
6.3 КОНТРОЛЬНЫЕ ВОПРОСЫ
 Какие компоненты используются для установки принтеров в Delphi приложении?
 Как выбрать принтер?
 Как настроить принтер?
 Как установить параметры печати?
 Охарактеризуйте основные свойства компонента PrintDialog.
 Как осуществляется печать форматированного текста?
 Как осуществляется печать графики?
6.4 ВАРИАНТЫ ЗАДАНИЙ.
Для своего варианта задания лаб. №5 создайте подменю печати и
встройте в проект разработанный модуль печати.
109
7 СОЗДАНИЕ СОБСТВЕННЫХ КОМПОНЕНТОВ В СРЕДЕ
DELPHI
Цель работы: изучение основных средств создания собственных
компонентов в среде Delphi.
7.1 МЕТОДИКА ВЫПОЛНЕНИЯ РАБОТЫ
7.1.1 Основные этапы создания компонента
Процесс создания нового компонента является невизуальным и
включает следующие этапы:
 программирование компонента;
 создание значка компонента, представляющего его в Палитре
Компонентов;
 создание файла справки с описанием свойств, методов и событий
компонента;
 инсталляция нового компонента в Палитру Компонентов.
Разработаем в соответствии с этим сценарием один простой компонент,
позволяющий создавать на форме рельефные надписи (3D labels). Новый
компонент так и назовем — Label3D.
Рельефные надписи требуется создавать постоянно, поэтому имеет
смысл расширить свой инструментарий.
7.1.1.1 Программирование компонента
Для получения нового компонента необходимо выполнить следующие
шаги:
• создать новый модуль и определить в нем класс компонента,
порожденный от одного из стандартных классов VCL;
• определить в компоненте новые свойства, методы и события;
• определить процедуру регистрации модуля.
7.1.1.2 Создание нового компонента
1. Для создания нового компонента выберите в строке главного меню
команду Component | New. На экране появится окно Component Expert. В
нем вас попросят указатьимя класса для нового компонента, класс предка и
страницу Палитры Компонентов, на которую новый компонент будет
помещен при инсталляции (рис.7.1).
Имя класса компонента должно быть легко читаемым, отражать
назначение компонента и начинаться с буквы Т. Использование буквы Т в
качестве первого символа — вопрос принятых соглашений. Хотя это не
110
обязательно, лучше придерживаться данного правила ради единообразия с
уже имеющимися классами.
Класс нового компонента никогда не разрабатывается с нуля, а
наследуется от одного из существующих классов VCL. Так, компонент
Label3D расширяет возможности стандартного компонента Label, который
и будет его предком Если вы решили создать совершенно новый
компонент, то в качестве предка выбирается один из следующих
абстрактных классов Delphi:
• TComponent, если создаваемый компонент невизуальный;
• TCustomControl, если создаваемый компонент должен обладать
способностью содержать другие компоненты или получать фокус ввода;
TGraphControl в остальных случаях.
Рис. 7.1
Местом размещения компонента Label3D в Палитре Компонентов
выберем страницу Samples. Заметим, что если в Палитре Компонентов нет
заданной вами страницы, она будет создана при инсталляции нового
компонента.
2.Установите в окне Component Expert показанные на рисунке значения
параметров и завершите ввод щелчком мыши на кнопке ОК. В результате
будет создан новый программный модуль, содержащий скелет компонента.
Unit Unit1;
interface
uses
111
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls;
type
TLabel3D = class(TLabel)
private
{ Private declarations }
protected
{ Protected declarations }
public
{ Public declarations }
published
{ Published declarations }
end;
procedure Register;
implementation
procedure Register;
begin
RegisterComponents('Samples', [TLabel3D]);
end;
end.
3. С помощью команды меню File | Save As... сохраните модуль с
именем Labe3D.pas.
Проанализируем содержимое модуля. В нем объявлен новый класс
TLabel3D и задана процедура Register, предназначенная для регистрации
компонента в среде Delphi. Класс TLabel3D порожден от класса TLabel,
поэтому он уже обладает почти всеми свойствами, которые должна иметь
надпись. Наша задача состоит в том, чтобы добавить свойство, а с ним
вспомогательные поля и методы, которые придадут надписи новое
качество - рельефность.
7.1.1.3 Добавление в компонент новых свойств и методов
4. Рельефность надписи можно bмитировать двумя способами: сделать
ее “вдавленной” или “выпуклой”. Для представления такого набора
значений рельефности удобно ввести перечислимый тип TLabel3DStyle:
type
TLabel3DStyle = (IsLowered, IsRaised) ;
5. Используя этот тип, определим новое свойство надписи Style и
добавим ряд вспомогательных полей и методов (ниже мы объясним их
смысл и назначение):
TLabel3D =class(TLabel)
private
112
FStyle: TLabel3DStyle;
procedure SetStyle(AStyle: TLabel3DStyle) ;
procedure DoDrawText;
protected procedure Paint; override;
public
constructor Create (AOwner: TComponent) ; override;
published
property Style: TLabel3DStyle read FStyle write SetStyle default
IsLowered;
end;
Обратите внимание на описание свойства Style. Оно объявлено в
секции published и имеет перечислимый тип (TLabel3DStyle), поэтому
будет представлено в Инспекторе Объектов в виде выпадающего списка.
Значение свойства читается из поля FStyle, a вписывается методом SetStyle.
По умолчанию надпись считается вдавленной (IsLowered), на это
указывает директива default в описании свойства Style (не спутайте ее с
одноименной директивой, используемой для объявления массива как
основного свойства объектов). В данном случае директива default
указывает компилятору значение свойства по умолчанию, т.е. то значение,
которое устанавливает конструктор объекта. Это помогает Delphi более
эффективно работать со свойством. Если значение свойства, установленное
в Инспекторе Объектов, совпадает со значением по умолчанию, то оно не
сохраняется в DFM-файле и за инициализацию свойства отвечает
конструктор.
6. Для инициализации свойства определите следующий конструктор в
классе TLabel3D
constructor TLabel3D.Create(AOwner: TComponent);
begin
inherited Create (AOwner) ;
FStyle := IsLowered;
end;
7. Для того чтобы при установке нового стиля происходила
перерисовка надписи, определите метод SetStyle следующим образом:
procedure TLabel3D. SetStyle (AStyle: TLabel3DStyle) ;
begin
FStyle := AStyle;
Invalidate;
end,
8. Когда возникает необходимость отобразить компонент, у него
вызывается виртуальный метод Paint. В классе TLabel3D он перекрыт для
113
отображения рельефной надписи. В этот метод можно поместить все
связанные с выводом операции, но для большей простоты мы разобьем
этот процесс на две стадии подготовительные операции (выполняемые
методом Paint) и собственно вывод рельефного текста (выполняемый
служебным методом DoDrawText, который будет вызываться из Paint).
Определите метод Paint:
procedure TLabelSD. Paint;
begin
with Canvas do begin
if not Transparent then
begin { Заполнить область надписи цветом фона } Brush.Color :=
Self.Color;
Brush.Style := bsSolid;
FillRect(ClientRect) ;
end;
{ Обеспечить прозрачный фон }
Brush.Style := bsClear;
{ Отобразить текст надписи, используя функции Windows API }
DoDrawText;
end;
end;
Метод Paint проверяет значение свойства Transparent и, если оно равно
False, заполняет фон надписи цветом, заданным в свойстве Color (в
противном случае фон остается незаполненным). После этого в объекте
Canvas устанавливается прозрачная кисть и вызывается метод DoDrawText
— служебный метод, выполняющий непосредственный вывод текста с
помощью функций Windows API.
9. Определите метод DoDrawText :
procedure TLabelSD. DoDrawText;
const
{ Массив флагов выравнивания для API-функции DrawText }
Alignments: array[TAlignment] of Word = (DT_LEFT, DT_ RIGHT,
DT__CENTER) ;
var
Rect: TRect; { прямоугольник для вывода надписи }
Flags: Word; { флаги для API-функции DrawText }
SaveColor: TColor;
begin
Rect := ClientRect;
{ Установить флаги вывода: преобразовывать табуляции в
пробелы,
перенос слов, выравнивание }
114
Flags
:=
DTJ3XPANDTABS
or
DT_WORDBREAK
or
Alignments[Alignment];
if not ShowAccelChar then
{ Выводить символ '& ' }
Flags := Flags or DT_NOPREFIX;
{ Установить шрифт в объекте Canvas }
Canvas. Font := Font;
if Enabled then
{ Вывести темные и светлые участки надписи }
begin
/ Сохранить исходный цвет надписи }
SaveColor := Canvas.Font.Color;
if FStyle = IsLowered then { Вывести темный участок }
Canvas.Font.Color := clBtnShadow
else
{ Вывести светлый участок }
Canvas.Font.Color := clBtnHighlight;
{ Вывести текст выше и левее исходного положения }
OffsetRect(Rect, -1, -1) ;
DrawText(Canvas.Handle,PChar(Caption),Length(Caption), Rect,Flags)
;
if FStyle = IsRaised then
{ Вывести темный участок }
Canvas.Font.Color := clBtnShadow
else
/ Вывести светлый участок }
Canvas-Font.Color := clBtnHighlight;
{ Вывести текст ниже и правее исходного положения }
OffsetRect(Rect, 2, 2);
DrawText(Canvas.Handle,PChar(Caption),Length(Caption), Rect,Flags)
;
[ Восстановить исходное положение надписи }
OffsetRect(Rect, -1, -1) ;
{ Восстановить исходный цвет надписи }
Canvas.Font.Color := SaveColor;
end
else { Надпись запрещена }
( Вывести цветом для запрещенных надписей } Canvas.Font.Color :=
cIGrayText;
{ Вывести надпись в исходном положении }
DrawText(Canvas.Handle, PChar(Caption), Length(Caption) , Rect,
Flags) ;
115
end;
Метод DoDrawText достигает эффекта рельефности за счет вывода
одного и того же текста три раза. Например, для вдавленной надписи
выполняется следующая последовательность действий:
для получения темных участков текст выводится цветом clBtnShadow
со сдвигом от указаееой позиции вверх и влево.
для получения светлых участков текст выводится цветом
clBtnHighlight со сдвигом вниз и вправо.
наконец, текст выводится установленным цветом (например, светлосерым) исходном положении.
В результате получается эффект оттиска
7.1.1.4 Процедура регистрации компонентов
Один модуль может содержать несколько классов компонентов, кроме
того, некоторые классы могут быть чисто вспомогательными. Среда Delphi
ничего не знает об этом заранее, поэтому для решения этого вопроса
используется механизм регистрации классов компонентов. Для
регистрации классов компонентов среда Delphi вызывает у программного
модуля процедуру Register, тем самым предоставляя ему возможность
сделать это самому. В нашем модуле Label3D эта процедура состоит лишь
из одного оператора:
procedure Register;
begin
Register-Components (' Samples ', [TLabel3D]);
end;
Вызывая процедуру RegisterComponents, модуль сообщает Delphi, какие
компоненты надо добавить в Палитру Компонентов. Первый параметр —
'Samples' — указывает, на какой странице должны появляться компоненты.
Если указанной страницы не существует, Delphi создаст ее. Второй
параметр — [TLabel3D] — открытый массив, содержащий имена классов
компонентов. Если классов компонентов в модуле несколько, их имена
перечисляются через запятую.
Модуль с определением компонента готов. Займемся теперь значком
компонента, который он будет иметь в Палитре Компонентов.
7.1.1.5 Создание значка компонента
Значки компонентов хранятся в специальных файлах, называемых
ресурсами компонентов. Эти файлы имеют расширение DCR (сокращкеие
от Delphi Component Resource) и представляют собой обычные
компилированные файлы ресурсов Windows. Во время инсталляции
компонента Delphi открывает DCR-файл и берет из него значок
компонента. DCR-файл должен находиться в том же каталоге, что и
соответствующий программный модуль компонента; имя DCR-файла
116
должно совпадать с именем модуля. В ресурсе определяется точечный
рисунок компонента (bitmap), которому назначается имя, совпадающее с
именем класса компонента. Если модуль содержит несколько компонентов,
DCR-файл должен содержать несколько точечных рисунков с
соответствующими именами.
Например, если вы создали модуль Label3D.pas с компонентом
Label3D, то соответствующий файл ресурса должен называться Labe3D.dcr
и содержать точечный рисунок с именем TLABEL3D (имя ресурса должно
быть записано большими буквами).
10. Файлы ресурсов могут создаваться с помощью приложения Image
Editor, входящего в состав Delphi и доступного из меню Tools, или любым
редактором ресурсов Windows. Для создания значка компонента Label3D
запустите Image Editor и создайте новый проект, выбрав команду меню File
| New | Delphi Component Resource File (.dcr). Определите в нем новый
точечный рисунок (команда меню Resource | New | Bitmap) и задайте его
свойства: размер — 24 х 24, количество цветов — 16. Дайте рисунку имя
TLABEL3D.
11. Изобразите значок компонента Label3D как выпуклую букву.
12. Закончив рисование, сохраните файл ресурса с именем LabeBD.dcr.
Разработка компонента завершена, далее необходима инсталляция
компонента.
7.1.1.6 Инсталляция созданного компонента
13. Для того, чтобы инсталлировать компонент, выберите в визуальной
среде Delphi команду меню Component | Install. Появится окно диалога
Install Components (рис. 7.2).
Рис. 7.2
Щелкните мышью на кнопке Add. В появившемся диалоге Add Module
укажите полное имя программного модуля Label3D без расширения (для
117
поиска файла можно воспользоваться кнопкой Browse) Завершите ввод
щелчком мыши на кнопке ОК.
Затем щелчком по кнопке ОК диалогового окна Install Components
завершите инсталляцию. Через некоторое время, необходимое для
компиляции компонента и добавления его в Палитру Компонентов,
компонент будет установлен (рис.7.3).
Рис.7.3
Обратите внимание, что инсталляция компонентов заключается в
инсталляции модулей, содержащих компоненты. Когда вы инсталлируете
модуль, Delphi его компилирует, добавляет компилированный модуль в
свою библиотеку компонентов и помещает в Палитру Компонентов значки
компонентов. Как вы понимаете, значки берутся из прилагаемого к модулю
файла ресурсов. В целом механизм понятен, остается выяснить вопрос, что
такое библиотека компонентов Delphi.
Среда Delphi позволяет программисту иметь несколько Палитр
Компонентов. Все компоненты одной палитры хранятся в файле с
расширением DCL (сокр. от англ. Delphi Component Libraгу), называемом
библиотекой компонентов. Стандартная библиотека компонентов
называется CompLib.dcl и находится в каталоге Delphi 2.0\Bin. В каждый
момент времени Delphi может держать открытой лишь одну библиотеку
компонентов. Чтобы открыть другую библиотеку, нужно выбрать команду
меню Component | Open Library... и ввести ее имя. В результате Палитра
Компонентов сменится на новую.
7.1.1.7 Испытание созданного компонента
Теперь в нашем инструментарии появилось новое средство для
выполнения рельефных надписей. А давайте-ка его испытаем!
16. Откройте новый проект и поместите на форму компонент Label3D.
Установите свойства компонента в следующие значения:
Caption = Text of the Label3D Font.Name = Times New Roman
Font.Size = 36
FontColor = clBtnFace
Style = IsRaised
Получилась красивая выпуклая надпись.
Заметьте, как органично новый компонент вписался в ряды других
компонентов.
Благодаря
технологии
объектно-ориентированного
программирования разработка нового компонента оказалась довольно
простым занятием. Это яркий пример того, как наследование и
118
полиморфизм экономят время, обеспечивая максимальное использование
одних компонентов при построении других
7.2 ПОРЯДОК ВЫПОЛНЕНИЯ РАБОТЫ.
 Изучить основные этапы создания компонент в среде Delphi.
 Изучить основы создания нового модуля и определения в нем класса
компонента.
 Создать новый компонент и определить в нем новые свойства, методы и
события;
 Зарегистрировать новый компонент
 Создать значок компонента.
 Инсталлировать новый компонент.
 Испытать новый компонент.
 Оформить отчет
7.3 КОНТРОЛЬНЫЕ ВОПРОСЫ
 Какие основные этапы создания компонентов Вы знаете?
 Какие средства являются основой создания компонентов в среде
Delphi?
 Как зарегистрировать новый компонент?
 Как создать значок компонента?
 Как инсталлировать новый компонент?
 Как испытать новый компонент?
119
8 ИЗУЧЕНИЕ СРЕДСТВ ОТЛАДКИ ПРОГРАММ В СРЕДЕ
DELPHI
Цель работы: изучение
программирования Delphi.
средств
отладки
программ
в
среде
8.1 МЕТОДИКА ВЫПОЛНЕНИЯ РАБОТЫ
8.1.1 Типы ошибок
В процессе разработки любой программы может возникнуть ошибка..
Ошибок может быть много, но борьба идет с каждой ошибкой в
отдельности. Delphi значительно упрощает процесс программирования, но
не исключает появление ошибок.. Рассмотрим все типы ошибок и методы
их устранения.
Все возможные ошибки можно подразделить на три группы:
• синтаксические ошибки;
• ошибки времени выполнения программы (run-time errors);
• логические (смысловые) ошибки.
Все эти ошибки попадаются даже у великих программистов. Вы
научитесь справляться с любой из них.
8.1.1.1 Синтаксические ошибки
Синтаксические ошибки часто появляются из-за опечаток, допущенных
при наборе исходного кода программы. Такие ошибки встречаются у
новичков и тех, кто не знает правил написания операторов языка Object
Pascal. Вы не сможете запустить программу до тех пор, пока не исправите
все синтаксические ошибки.
Если при компиляции в исходном тексте программы обнаруживаются
синтаксические ошибки, их список выводится на Панель Сообщений
Редактора Кода. При этом курсор помещается в то место, где возникла
первая ошибка и эта строка выделяется цветом.
Описание каждой ошибки в списке включает полное имя модуля и
номер строки, где обнаружена ошибка, а также краткое объяснение ее
причины. Выбрав сообщение в списке и нажав клавишу F1, вы можете
получить более подробную информацию об ошибке, включая примеры
схожих ошибочных ситуаций и пути их устранения. Чтобы перейти на
следующую из обнаруженных в исходном коде ошибок, сделайте двойной
щелчок мыши на сообщении или выберите во всплывающем меню Панели
Сообщений команду Edit Source.
120
Язык Object Pascal вырос из простого Pascal, значительно обогатив
синтаксис последнего. Расширяя язык новыми возможностями,
разработчики стремились к компромиссу между увеличением гибкости и
сохранением строгости языка. Они решили проблему на уровне директив
компилятора, обеспечив настройку синтаксического контроля. Для
настройки синтаксического контроля выберите из меню Project команду
Options и в появившемся окне диалога Project Options активизируйте
страницу Compiler (рис. 8.1).
Рис. 8.1
Переключатели из группы Syntax options позволяют указать, какого
рода проверка синтаксиса должны производиться и насколько строго.
Strict var-strings. Этот переключатель определяет, как осуществляется
контроль совместимости типов для строковых параметров при вызове
процедур и функций. При включенном состоянии директивы требуется
строгое совпадение типу формального и фактического параметров.
Complete boolean eval. Управляет вычислением булевских выражений.
Если директива выключена, то вычисление булевских выражений
прерывается, как только результат становится предопределен. Если же
директива включена, то в булевских выражениях всегда вычисляются все
термы (рекомендуется использовать лишь в особых случаях).
121
Extended syntax. Разрешает компилятору использовать набор
расширенных синтаксических правил. Он позволяет вызывать функции
подобно процедурам (с игнорированием результатов функций) и работать с
переменными типа PChar. Вы всегда должны оставлять эту опцию
включенной.
Typed @ operator. Определяет, как осуществляется контроль
совместимости типов для указателей, полученных с помощью применения
оператора @. При включенном состоянии переключателя результат
применения оператора @ к переменной типа Т есть указатель с типом ^Т. В
выключенном
состоянии
опции
результатом
всегда
является
нетипизированный указатель (тип Pointer). Лучше оставлять этот
переключатель выключенным, чтобы избежать несовместимости
указателей.
Open parameters. Позволяет компилятору рассматривать строковые
параметры процедур и функций как открытые строки, не обращая
внимания на их формальный тип. Лучше оставлять его включенным, так
как работа с открытыми строками происходит более безопасно. Например,
при присваивании длинной строки короткой, память запорчена не будет, а
произойдет усечение строки.
Huge strings. Позволяет рассматривать переменные типа string как
длинные строки (тип string считается эквивалентным AnsiString). Если
переключатель выключен, то тип string рассматривается как ShortString.
Object Pascal рекомендует отдавать предпочтение длинным строкам, кроме
того, длинные строки используются всеми классами библиотеки VCL,
поэтому оставляйте этот переключатель включенным.
Assignable typed constants. Позволяет компилятору рассматривать
типизированные константы как инициализированные переменные и
обеспечивает совместимость с ранней версией Delphi 1.0. Если этот
переключатель включен, то типизированные константы можно изменять
при выполнении программы. Если же переключатель выключен, то
типизированные константы считаются настоящими константами и попытка
их изменить вызывает ошибку компиляции. Лучше выключать этот
переключатель и пользоваться нормальными инициализированными
переменными.
Обычно устранение синтаксических ошибок не вызывает особых
трудностей. Намного больше неприятностей доставляют ошибки времени
выполнения.
8.1.1.2 Ошибки времени выполнения
Ошибки времени выполнения (run-time errors) дают о себе знать
исключительными ситуациями, которые приостанавливают работу
приложения. При стандартной обработке этих исключительных ситуаций
122
выдается сообщение, в котором указывается тип ошибки, адрес, по
которому она случилась, другая информация. Например, выполнение
следующей процедуры вызывает ошибку выполнения (точнее,
исключительную ситуацию).
рrocedure TForm1. FormCreate (Sender: TObject) ;
var
List: TStringList;
begin
List :=nil; { должно быть: List := TStringList.Create; }
List.Add('Этот оператор вызывает исключительную ситуацию');
{…}
end;
Рис. 8.2
Программа, содержащая такую процедуру, прекрасно проходит
компиляцию, но создает исключительную ситуацию при выполнении.
Причина ошибки — обращение к несуществующему в памяти объекту
(значение переменной List равно nil). Если приложение запущено из среды
Delphi, то его работа приостанавливается и вам выдается следующее
сообщение (рис. 8.2):
Это сообщение выдает среда Delphi, которая перехватывает обработку
исключительной ситуации. После нажатия ОК вы попадете в Редактор
Кода с исходным текстом процедуры. Курсор будет установлен на строку,
вызвавшую исключительную ситуацию (рис. 8.3).
Среда Delphi имеет много средств, помогающих обнаруживать ошибки
выполнения и устранять их. С одним из них вы только что познакомились.
Обратите внимание, что приложение не зависло, не прекратило работу, а
лишь приостановилось. Вы можете продолжить работу приложения с
помощью команды меню Run | Run или действительно прервать его,
выбрав команду меню Run | Program Reset. Если вы выберете команду Run,
то обработкой исключительной ситуации займется ваше приложение. Оно
выдаст следующее сообщение (рис. 8.4):
123
Рис. 8.3
Это же сообщение выдается, если приложение запущено не из среды
Delphi, а непосредственно из системы Windows.
Рис. 8.4
Преобразуя ошибки времени выполнения в исключительные ситуации,
среда Delphi задействует мощнейший механизм, позволяющий
приложению самому обрабатывать эти ошибки, осуществлять
восстановление и работать дальше. Хотя Delphi всегда встраивает в
приложения средства защиты от ошибок выполнения, помните, что
коммерческое приложение не должно шокировать пользователя
сообщениями вроде Access violation … .
Контроль ошибок времени выполнения является настраиваемым.
Откройте окно Project Options на странице Compiler (рис. 8.5).
Переключатели из группы Runtime errors позволяют указать, в каких
ситуациях должны генерироваться ошибки выполнения.
Range checking. Этот переключатель позволяет включить контроль
того, чтобы индексы массивов и строк, а также переменные интервальных
124
типов не выходили за границы объявленных пределов. Контроль следует
включать только на время отладки.
Stack checking. Позволяет включить контроль переполнения стека при
вызове процедур и функций. Этот переключатель всегда следует включать.
I/O checking. Позволяет включить контроль ошибок ввода-вывода.
Если контроль выключен, то чтобы узнать, была ли ошибка ввода-вывода,
необходимо проверить значение переменной lOResult: (lOResult <> 0). Этот
переключатель следует включать только на время отладки.
Overflow checking. Позволяет включить контроль переполнения целых
чисел при выполнении арифметических операций. Этот переключатель
следует включать только на время отладки.
Рис. 8.5
Чаще всего ошибка времени выполнения является симптомом
логической ошибки.
8.1.1.3 Логические (смысловые) ошибки
Логические (смысловые) ошибки — самые сложные и трудноуловимые.
Они проявляются в том, что программа делает не то, что надо.
Последствия логических ошибок могут быть самыми разными:
125
неправильное содержимое окна, невыполнение или неверное выполнение
команд пользователя, неправильное содержимое выходных файлов, может
возникнуть ошибка времени выполнения и многое другое.
8.1.1.4 Предупреждения и подсказки компилятора
На этапе компиляции Delphi умеет обнаруживать не только
синтаксические ошибки, но и просто потенциально опасные ситуации,
которые могут вызвать ошибки времени выполнения или логические
ошибки. Delphi сообщает о таких ситуациях с помощью предупреждений и
подсказок, которые выдаются в Панели Сообщений Редактора Кода.
Чтобы включить выдачу предупреждений и подсказок (по умолчанию
эти возможности недоступны), откройте окно диалога Project Options на
странице Compiler и включите в группе Messages переключатели Show hints
и Show warnings.
Предупреждения (warnings) генерируются компилятором при
обращении к неинициализированным переменным, обнаружении функций
с пропущенным результатом, при конструировании объектов абстрактных
классов и в других ситуациях, которые могут привести к ошибкам времени
выполнения.
Подсказки (hints) генерируются компилятором при обнаружении
неиспользуемых переменных, бесполезных присваиваний, никогда не
выполняющихся циклов for или while и в других случаях бестолкового или
неоптимального программирования.
8.1.2 Методика отладки
Отладка приложения является интерактивным процессом обнаружения
и исправления ошибок, который обычно требует последовательного
выполнения трех этапов:
 выявление ошибки;
 установление причины ошибки;
 исправление ошибки.
8.1.2.1 Выявление ошибки
Процесс целенаправленного выявления ошибок иначе называют
тестированием. Некоторые ошибки проявляются после первого же
запуска приложения и заметны «невооруженным» глазом»; для их
обнаружения не надо прибегать к специальным средствам. Но некоторые
ошибки проявляются в абсолютно случайные моменты работы
приложения. С такими ошибками справиться труднее всего. Если вы не
можете зафиксировать условия возникновения ошибки, вы не сможете
понять причину ошибки и устранить ее.
Программисты говорят, что каждая найденная в программе ошибка
является предпоследней. Из этого следует, что процесс тестирования
может продолжаться бесконечно, однако рано или поздно приложение
126
должно выйти в свет. Поэтому производители программного обеспечения
применяют так называемое бета-тестирование. До выпуска коммерческой
версии приложение появляется в виде бета-версии и предлагается
потенциальным пользователям для предварительной эксплуатации и
тестирования. При этом срабатывает известный принцип, что лучше всего
ошибки находит тот, кто не причастен к разработке приложения. Ошибки,
выявленные на этапе бета-тестирования, фиксируются и устраняются в
коммерческой версии продукта. Еще одним положительным моментом
бета-тестирования является то, что оно позволяет оценить приложение с
точки зрения удобства его использования, собрать критические замечания
пользователей и учесть их в конечном варианте.
8.1.2.2 Установление причины ошибки
После того как ошибка зафиксирована, необходимо определить ее
причину. В общем случае причина ошибки может быть связана с
недопониманием задачи, недостатками проектирования, ошибками,
допущенными при кодировании.
Недопонимание проблемной области приводит к самым тяжелым и
трудноустранимым ошибкам — ошибкам спецификации. Помните, что чем
больше времени потрачено на разработку спецификации и проектирование,
тем меньше времени будет потрачено на отладку. Если приложение
хорошо спроектировано, то запрограммировать его, как правило, не
составляет особого труда. При этом возрастает его надежность, т.е.
уменьшается вероятность обнаружения ошибок.
8.1.2.3 Исправление ошибки
При исправлении ошибки самое главное — не внести в программу
новых ошибок,
8.1.3 Встроенный отладчик Delphi
Когда в приложении возникает «непонятная» с вашей точки зрения
ошибка, которая становится для вас головоломкой, на помощь приходит
встроенный отладчик. Delphi предоставляет все возможности, которые
программист ожидает получить от профессионального отладчика, включая
средства трассировки, контрольные точки, просмотр значении переменных
и т.д. Не пожалейте времени на изучение этих средств — и оно окупится с
лихвой.
8.1.3.1 Настройка проекта для отладки
Прежде чем приступить к отладке приложения, надо позаботиться о
том, чтобы средства встроенного отладчика были доступны. На работу
отладчика влияют как параметры среды (environment options), так и
параметры проекта (project options). Прежде всего убедитесь, что
встроенный отладчик доступен и настроен правильно. Для этого откройте
127
окно Environment Options (выбрав команду Options... в меню Tools) и
активизируйте страницу Preferences (рис.8.6).
Рис. 8.6
Переключатели из группы Debugging управляют работой отладчика:
Integrated debugging. Обеспечивает работу интегрированного
отладчика Delphi.
Break on exception. Обеспечивает остановку приложения при
возникновении исключения. При этом выдается информация о классе,
причине и месте возникновения исключения.
Step program block. Позволяет отлаживать главный программный блок
DPR-файла, а также блоки инициализации модулей, для которых была
сгенерирована отладочная информация.
Hide designers on run. Позволяет спрятать на время отладки все
неиспользуемые при отладке окна (например, окно Инспектора Объектов и
окно формы).
Minimize on run. Обеспечивает минимизацию Delphi на время работы
приложения.
Кроме установки опций среды, вы должны заставить компилятор
генерировать специальную информацию, необходимую для работы
отладчика. Для этого откройте окно Project Options на странице Compiler
(рис.8.7).
128
Рис. 8.7
Переключатели из группы Debugging сообщают компилятору, какого
рода отладочную информацию он должен генерировать:
Debug information. Заставляет компилятор генерировать отладочную
информацию и записывать ее в объектные модули. Эта информация
содержит таблицы, сопоставляющие выполняемые команды с номерами
строк исходного модуля. Этот переключатель всегда следует включать на
этапе разработки приложения. Он никак не влияет на скорость работы и
размер выполняемого ЕХЕ-файла.
Local symbols. Заставляет компилятор сохранять в DCU-модулях
информацию об используемых в программе переменных. Информация
содержит таблицы, сопоставляющие имена переменных с их положением в
памяти. Если эти таблицы доступны отладчику, вы получаете возможность
контролировать значения переменных и даже изменять их во время работы
приложения. Этот переключатель всегда следует включать на этапе
разработки приложения, его состояние никак не влияет на скорость работы
и размер выполняемого ЕХЕ-файла.
Symbol info. Заставляет компилятор сохранять в DCU-модулях
ссылочную информацию об используемых в программе идентификаторах
(констант, переменных, типов). Благодаря этому вы можете использовать
Браузер Объектов для глубокого анализа данных и кода. Однако
129
переключатель сильно «раздувает» DCU-модули, поэтому его следует
включать только на время отладки приложения.
8.1.3.2 Управление процессом отладки
Управление процессом отладки осуществляется с помощью команд
выпадающего меню Run. Для запуска приложения под присмотром
отладчика выберите в меню Run команду Run или нажмите клавишу F9 на
клавиатуре. В результате приложение начнет выполняться с обычной
скоростью, как будто нет никакого отладчика.
Для прерывания работы приложения и перехода в режим отладки
используется команда Program Pause. При этом вы получаете возможность
использовать любые средства отладчика. (Чтобы продолжить выполнение
программы, надо снова выбрать команду Run.). Если во время отладки вы
обнаружите, что программа зашла слишком далеко, с помощью команды
Program Reset или комбинации клавиш Ctri+F2 можно вообще прервать ее
работу.
С помощью команды Run to Cursor или клавиши F4 вы можете
выполнить программу до строки, в которой в данный момент
располагается текстовый курсор. Эта команда очень удобна при
выполнении циклов. Если программа попала в цикл, то, чтобы не
выполнять все его итерации по шагам, поместите курсор на следующую
строку после тела цикла и нажмите F4. Точно так же можно пропустить ту
часть отлаживаемой программы, детальный анализ которой не требуется.
С помощью команды Trace Into или клавиши F7 вы можете выполнять
программу по шагам, т е. трассировать ее. При выборе данной команды
выполняется одна строка исходного кода. Если в строке записан вызов
подпрограммы, начинается трассировка по тексту подпрограммы
(библиотечные процедуры и функции выполняются без трассировки за
одно нажатие клавиши F7). При необходимости можно выполнить строку
программы за один шаг без захода в вызываемые подпрограммы. Это
делается с помощью команды Step Over или клавиши F8. В режиме
трассировки очередная выполняемая строка исходного кода отмечается
цветом, а слева от нее на полях рисуется стрелка (рис. 8.8).
При трассировке подпрограмм, для которых отладочная информация
отсутствует, удобной оказывается команда Trace to Next Source Line
(клавиши ускоренного набора Shift+F7). Представьте, что программа
выполняет некоторое действие, в результате которого генерируется
событие. Допустим также, что в приложении определен обработчик этого
события. Тогда трассировка оператора установки свойства с помощью
команды Trace to Next Source Line передаст управление на метод обработки
события , т.е. на первые операторы, для которых была обнаружена
130
отладочная информация. Этого не позволяют команды Trace Into и Step
Over.
Рис. 8.8
8.1.3.3 Контрольные точки
Windows-приложения имеют событийно-управляемую архитектуру,
поэтому для поиска их ошибок чаще всего используют контрольные точки
(breakpoints) с трассировкой только отдельных участков. Контрольные
точки устанавливаются на методы обработки событий и позволяют
остановить выполнение программы в нужном месте, а затем изучить ее
состояние в надежде понять ошибку.
Чтобы установить контрольную точку, нужно перейти в Редактор Кода
и щелкнуть мышью на левом поле выбранной вами строки (то же самое
можно было бы сделать с помощью клавиши F5). Delphi покажет
маленький знак STOP на полях и подсветит строку программы (рис.8.9).
Расставив контрольные точки в интересующих вас местах, нажмите
клавишу F9. Когда процесс выполнения программы достигнет какой-нибдь
контрольной точки, отладчик прервет ее выполнение и вы получите
возможность просмотреть данные и код, установить другие контрольные
точки, а также продолжить выполнение программы по шагам (клавиши F7
и F8) или до следующей контрольной точки (клавиша F9). Так работают
безусловные контрольные точки. В действительности возможности
контрольных точек гораздо шире
131
Рис. 8.9
Список всех расставленных в программе контрольных точек можно
просмотреть в окне Breakpoint list, появляющемся после выбора команды
меню View | Breakpoints (рис. 8.10).
Рис. 8.10
Контрольная точка может быть либо разрешена, либо запрещена.
Очевидно, что отладчик проверяет только те контрольные точки, которые в
данный момент разрешены, и игнорирует запрещенные. Чтобы разрешить
или запретить контрольную точку, надо отметить ее в окне Breakpoint list,
вызвать всплывающее меню щелчком правой кнопки Мыши и выбрать
команду Enabled (рис. 8.10).
Для ускорения отладки Delphi позволяет задать для контрольной точки
условие (condition) и число проходов (pass count), при которых она
срабатывает. Чтобы это сделать, выберите во всплывающем меню команду
Properties Появится окно Edit breakpoint, в котором можно изменить
параметры контрольной точки (рис 8.11).
132
Рис. 8.11
С контрольной точкой может быть связано условие. Условная
контрольная точка позволяет программе выполняться без остановок до
того момента, пока условие не станет истинным. Условие задается как
выражение, результат которого имеет булевский тип Вы можете задать
несколько условий, остановка программы произойдет, только когда все
условия станут истинными. Представьте, например, что некоторая функция
вашей программы работает неправильно при отрицательных значениях
своих аргументов На эту функцию можно установить безусловную
контрольную точку, но тогда вы устанете нажимать клавишу F9 в
ожидании отрицательных значений параметров функции Лучше задать
условную контрольную точку, возложив эту работу на отладчик.
Очень полезен параметр контрольной точки, задающий число
проходов. Если в цикле 100 итераций и ошибка возникает на пятидесятый
раз, то нет нужды выполнять по шагам все 50 итераций, лучше просто
установить в теле цикла контрольную точку с числом проходов 50.
Отметим, что для контрольной точки можно одновременно задать и
условие, и число проходов. В этом случае учитываются только те проходы,
во время которых условие истинно.
8.1.3.4 Просмотр значений переменных
Простая остановка программы сама по себе бессмысленна, поэтому
наряду с контрольными точками Delphi предлагает средство просмотра
переменных — окно Watch List. Оно открывается при выборе команды
Watches в меню View (рис. 8.12.).
При пошаговом выполнении программы содержимое окна
динамически обновляется, поэтому вы можете наблюдать все
производимые программой изменения. В окне Watch List могут
отображаться значения переменных и выражений, причем они могут иметь
133
различные типы, в том числе массивы, записи и объекты. Если выражение
содержит переменную, находящуюся вне поля видимости текущего
оператора программы, вместо значения выводится сообщение Undeclared
identifier с указанием имени недоступной переменной.
Рис. 8.12
При первом вызове окна Watch List список переменных пуст. Чтобы
добавить переменную в окно Watch List, откройте всплывающее меню окна
и выберите команду Add Watch. Если вы находитесь в Редакторе Кода, то
это можно сделать, отметив переменную и выбрав команду Add Watch at
Cursor. (или нажав на клавиатуре Ctrl+F5). При этом открывается
диалоговое окно Watch Properties (рис. 8.13).
Рис. 8.13
В этом окне задается просматриваемая переменная или выражение и
тип, к которому ее надо преобразовать при просмотре. Для массивов
задается еще количество элементов, а для вещественных чисел количество значащих цифр. Среда Delphi умеет автоматически определять
тип переменных и выражений, поэтому в группе зависимых
переключателей обычно оставляют включенной кнопку Default.
8.1.3.5 Модификация переменных
Кроме постоянного просмотра переменных с помощью окна Watch List,
существует возможность краткосрочного просмотра переменных и
134
модификации их значений с помощью окна Evaluate/Modify. Оно
вызывается во время пошагового выполнения программы. Поместите
курсор в редакторе кода на переменную, которая вас интересует, а затем
выберите во всплывающем меню команду Evaluate/Modify... Delphi покажет
окно Evaluate/Modify с переменной, на которой находился курсор (рис.
8.14).
Рис. 8.14
В поле Expression вы можете ввести любое допустимое в Object Pascal
выражение, не содержащее вызова функций. Переменные, участвующие в
выражении, должны находиться в области видимости текущего оператора
программы.
Рис. 8.15
В большинстве случаев значение отображается в удобном для чтения
виде, однако формат результата можно изменить, добавляя в конце
выражения запятую и форматный символ. Чтобы изменить значение
переменной, надо ввести новое значение в поле New value и щелкнуть
кнопкой мыши на кнопке Modify.
135
8.1.3.6 Просмотр стека
При отладке подпрограмм, особенно рекурсивных, трудно держать в
голове всю цепочку вложенных вызовов и значения параметров. Эту задачу
значительно облегчает окно Call Stack, которое вызывается при выборе в
меню View команды Call Stack (рис. 8.15).
В окне Stack отображаются активные в данный момент процедуры и
функции вместе со значениями их параметров. Просматривая окно Stack,
вы можете определить, какая цепочка вызовов процедур и функций
привела к текущему месту программы. Подпрограммы расположены в
порядке, обратном порядку вызова, таким образом верхний элемент —
текущая подпрограмма. Двойной щелчок мыши на имени подпрограммы
устанавливает курсор на строку, которая выполнялась в этой
подпрограмме.
8.1.4 Отладка без отладчика
Ошибки вашего приложения могут проявляться самым различным
образом. Вы можете попасть в ситуацию, когда приложение, казалось бы,
корректно работает при запуске из среды Windows, однако под отладчиком
Delphi ведет себя неправильно. Значит это следствие какой-то
невыявленной ошибки приложения. Чтобы ее обнаружить, иногда
приходится ставить «чистый» эксперимент, отказываясь от отладчика
Delphi. Мы рекомендуем для этого пользоваться функцией Веер, которая
генерирует звуковой сигнал. Если требуется проверить, проходит ли
приложение через определенную точку, вставьте в этой точке вызов
функции Веер, запустите приложение и послушайте, что оно вам «скажет».
Кроме этого, для поиска ошибки используется также метод упрощения
логики работы приложения. Комментируйте, взяв в фигурные скобки, те
участки программы, которые могут быть причастны к ошибке, лишив ее
некоторых возможностей. Запустите программу и убедитесь, что в
усеченном варианте она работоспособна. Постепенно убирайте
комментарии, усложняя поведение программы и проверяя ее работу на
каждом шаге. На одном из таких шагов ошибка себя проявит. В последнем
добавленном фрагменте программы и следует искать ошибку.
8.2 ПОРЯДОК ВЫПОЛНЕНИЯ РАБОТЫ.
 Изучить основные типы ошибок в программах.
 Изучить основные методы и средства отладки программ в среде Delphi.
 . Изучить методику использования интегрированного отладчика в среде
Delphi..
 Изучить методику отладки без отладчика.
 Испытать методику отладки для одного из ранее созданных проектов.
 Оформить отчет
136
8.3 КОНТРОЛЬНЫЕ ВОПРОСЫ





Какие основные типы ошибок в программах Вы знаете?
Какие средства отладки программ существуют в среде Delphi?
Как включить режим отладки?
Как установить контрольную точку?
Как отладить программу без отладчика?
137
9 ИЗУЧЕНИЕ СТРУКТУРЫ И ПРИНЦИПОВ ПОСТРОЕНИЯ
ПРИЛОЖЕНИЙ С МНОГОДОКУМЕНТАЛЬНЫМ ИНТЕРФЕЙСОМ
MDI
Цель работы: изучение методов и средств создания Delphi –
приложений с многодокументальным интерфейсом.
9.1 МЕТОДИКА ВЫПОЛНЕНИЯ РАБОТЫ
9.1.1 Однодокументные и многодокументные приложения
Основное назначение Windows-приложений — это работа с
документами. Термин «документ» здесь употребляется в самом широком
смысле и подразумевает данные, хранящиеся в виде файлов на диске.
Примеры документов: текстовый документ, электронная таблица, проект
приложения и т.д. Создание и редактирование документов этих типов
обеспечивается с помощью соответствующих приложений. Например, для
работы с текстовыми документами служит Word, с электронными
таблицами — Excel, с проектами приложений — Delphi. Существует два
различных стандарта интерфейсов для таких приложений:
Однодокументные приложения (Single Document Interface — SDI)
Многодокументные приложения (Multiple Document Interface — MDI)
Суть различий между ними состоит в организации одновременной
работы с несколькими документами.
Однодокументные приложения обеспечивают одновременную работу
только с одним документом. Для работы с несколькими документами
необходимо
запустить
несколько
копий
одного
приложения.
Однодокументные приложения обычно состоят из одного, реже —
нескольких окон, которые вы можете свободно перемещать в пределах
всего рабочего стола. Примером однодокументного приложения является
Delphi. Легко догадаться, что все приложения, которые мы до сих пор
разрабатывали, тоже относятся к категории однодокументных. В общем,
Однодокументные приложения - это обычные Windows-приложения, их
альтернативой являются многодокументные приложения.
Многодокументные приложения обеспечивают одновременную работу
с любым количеством документов в рамках одного экземпляра
приложения. Они имеют главное окно, называемое обрамляющим окном
многодокументного приложения (MDI frame window). внутри рабочей
области
обрамляющего
окна
располагаются
дочерние
окна
многодокументного приложения (MDI child windows), содержащие
138
документы. Дочерние окна не могут выходить за границы обрамляющего
окна, которое выступает в качестве их локальной рабочей области. При
передвижении обрамляющего окна дочерние окна перемещаются вместе с
ним. Дочерние окна могут быть свернуты, развернуты на всю рабочую
область или приведены к необходимому размеру и размещены в любом
месте внутри обрамляющего окна. Типичные операции многодокументного
приложения включают расположение дочерних окон мозаикой и каскадом,
а также упорядочивание свернутых окон. Управление всеми дочерними
окнами осуществляется из главного меню обрамляющего окна (дочерние
окна многодокументных приложений не имеют своих меню). Примерами
многодокументных приложений являются Word, Excel и другие
приложения из пакета Microsoft Office.
Если отвлечься от понятия документа, то стандарт однодокументного
приложения — это что-то вроде «свободного стиля». Стандарт
многодокументных приложений наоборот вводит программиста в жесткие
рамки, но зато приложения имеют более привычный для пользователей
классический стиль. Так как с однодокументными приложениями вы уже
практически
знакомы,
мы
сейчас
рассмотрим
разработку
многодокументных приложений.
9.1.2 Обрамляющая форма многодокументного приложения
Проект многодокументного приложения всегда состоит из двух и более
типов форм и включает обрамляющую форму многодокументного
приложения (MDI frame form) и хотя бы одну дочернюю форму
многодокументного приложения (MDI child form). Количество дочерних
форм никак не ограничено и соответствует числу видов документов, с
которыми предполагается работать. Следующие шаги показывают, как с
нуля быстро организовать многодокументное приложение.
Первый шаг построения многодокументного приложения — это
создание обрамляющей формы.
1. Начните в Delphi новое приложение с помощью команды меню File |
New Application. Назовите главную форму FrameForm и дайте ей заголовок
(Caption) — MDI Application. Сделайте главную форму обрамляющей
формой многодокументного приложения, установив свойство FormStyle в
значение fsMDIForm (рис. 9.1).
9.1.3 Дочерняя форма многодокументного приложения
Второй шаг построения многодокументного приложения — создание
дочерней формы.
2. Добавьте в проект новую форму с помощью команды меню File /
New Form. Дайте форме имя ChildForm и впишите заголовок (Caption) —
MDI Child. Сделайте форму дочерней формой многодокументного
приложения, установив свойство FormStyle значение fsMDIChild (рис. 9.2).
139
Рис. 9.1
Сохраните проект с именем MDIApp.dpr, модуль обрамляющей формы
назовите MDIFrame.pas, а модуль дочерней — MDIChild.pas.
Рис. 9.2
140
Во время разработки дочерняя форма многодокументного приложения
ведет себя как обычная форма, однако во время работы приложения она
будет появляться внутри рабочей области обрамляющей формы,
По умолчанию попытка пользователя закрыть дочернее окно
(например, с помощью команды Close управляющего меню) приводит к
сворачиванию окна, а не к его уничтожению. Таким поведением управляет
переменный параметр Action в событии OnClose, Для обычных окон он
имеет значение caFree, а для дочерних окон многодокументного
приложения — caMinimize.
3. Если вы желаете, чтобы по команде Close дочерние окна
действительно закрывались, определите следующий обработчик события
OnClose для дочерней формы:
procedure TChildForm. FormClose (Sender: TObject);
var Action: TCloseAction; begin
Action := caFree;
end;
Поскольку из обрамляющей формы нам придется обращаться к
дочерним формам и наоборот, необходимо обеспечить взаимную
видимость модулей, в которых объявлены обрамляющая и дочерняя
формы. Это делается с помощью команды File | Use Unit.
4. Выберите форму FrameForm и, используя команду File | Use Unit,
подключите модуль MDIChMpas. Затем выберите форму ChildForm и
подключите модуль MDIFrame.pas.
9.1.4 Меню многодокументного приложения
Для управления документами обрамляющее окно должно содержать
строку главного меню. Это меню разделяется всеми дочерними окнами,
которые не могут иметь своего собственного главного меню.
В главном меню можно выделить три типа выпадающих меню:
меню, в котором команды должны обрабатываться обрамляющей
формой (например, меню Window);
меню, в котором команды должны обрабатываться дочерней формой,
обладающей фокусом ввода (например, меню Edit);
меню, в котором одни команды должны обрабатываться обрамляющей
формой, а другие — активной дочерней (например, меню File).
Динамическое управление таким меню — занятие не слишком
приятное, поэтому для создания меню многодокументного приложения
используется механизм объединения меню (menu merging). Суть данного
подхода в том, что с помощью компонентов МainMenu одни меню
создаются в обрамляющей форме, а другие — в дочерней. Затем с
помощью свойств Grouplndex, имеющихся в компонентах TMenultem,
141
определяются правила объединения меню, которые автоматически
применяются во время работы приложения.
Объединение применяется лишь к целым выпадающим меню, но не к
их элементам. Например, вы можете целиком добавить меню Edit или
полностью заменить меню File.
Рис. 9.3
При установке свойства Grouplndex учитывайте следующие правила
объединения меню:
 объединенные меню упорядочиваются в порядке возрастания значений
свойства Grouplndex;
 меню дочерней формы заменяет меню обрамляющей формы с тем же
значением Grouplndex;
 несколько подряд расположенных меню в дочерней или в обрамляющей
форме могут иметь одинаковые значения Grouplndex, образуя группу.
При объединении меню группы с одинаковыми Grouplndex добавляются
или заменяются целиком.
Покажем, как обеспечивается объединение меню в многодокументном
приложении.
5. Поместите на обрамляющую форму компонент MainMenu и вызовите
у него окно Дизайнера Меню. Создайте меню File, состоящее из пунктов
New, Open..., Exit. Затем создайте меню Window, состоящее из пунктов
Tile, Cascade, Arrange All. Пусть Delphi сама назначит имена
соответствующим компонентам класса TMenultem (рис. 9.3).
142
6. Переключитесь на дочернюю форму и тоже поместите на нее
компонент MainMenu. Вызовите Дизайнер Меню и вставьте из шаблона
расширенный вариант меню File и меню Edit. Для выбора шаблона
используйте команду всплывающего меню Insert From Template... (рис. 9.4).
7. Меню обрамляющей и дочерней форм созданы, теперь надо
обеспечить их правильное объединение. Как мы уже говорили, эта задача
решается путем соответствующей установки свойства Grouplndex в
компонентах TMenultem самого верхнего уровня. В форме FrameForm это
компоненты File1 и Windowl, а в форме ChildForm — File1 и Edit1.
Установите свойства указанных компонентов следующим образом:
В форме FrameForm:
File1.Grouplndex = 0
Windowl.Grouplndex = 9
В форме ChildForm:
File1.Grouplndex = 0
Edit1.Grouplndex = 1
Рис. 9.4
Объединение меню будет происходить следующим образом. Меню File
дочерней формы заменит меню File обрамляющей формы. На это
указывают одинаковые значения свойства Grouplndex (0). Следом за меню
File будет вставлено меню Edit, в котором свойство Grouplndex имеет
143
следующий по порядку номер (1). В конце главного меню окажется меню
Window, в котором свойство Grouplndex имеет наибольшее значение (9).
Шаг 8. Выполните компиляцию и запустите приложение. На экране
появится обрамляющее окно, содержащее одно дочернее окно. Строка
меню обрамляющего окна будет состоять из расширенного меню File,
меню Edit, и меню Window (рис. 9.5).
Закройте дочернее окно. Строка меню перестроится и будет состоять
из сокращенного меню File и меню Window (рис. 9.6).
Вы больше не сможете открыть ни одного дочернего окна, так как мы
еще не занимались обработкой команд меню и, следовательно, не
обеспечили этого. Дальше мы покажем, как создавать дочерние окна и как
манипулировать ими.
Рис. 9.5
9.1.5 Создание дочерних форм
По умолчанию все добавляемые в проект формы создаются
автоматически. Однако нам необходимо самостоятельно управлять этим
процессом, поэтому дочернюю форму необходимо исключить из списка
автоматически создаваемых форм. Это делается в окне диалога Параметры
Проекта (Project Options).
9. Откройте указанный диалог, выбрав пункт меню Project | Options...,
переключитесь на страницу Forms и перетяните пункт ChildForm из списка
144
Auto-create forms в список Available forms. Завершите диалог щелчком на
кнопке ОК.
10. Экземпляры дочерней формы должны создаваться при выборе
команды New из меню File, поэтому перейдите к форме FrameForm и
определите следующий обработчик события OnClick для пункта меню
New1:
procedure TFrameForm.NewlClick (Sender: TObject) ;
begin
with TChildForm. Create (Self) do
Caption := Caption + ' ' + IntToStr (Self.MDIChildCount);
end;
Рис. 9.6
Заметьте, что при формировании Caption новой формы используете»
свойство обрамляющего окна MDIChildCount. Оно содержит количество
открытых дочерних форм.
11. При создании хотя бы одной дочерней формы меню File
обрамляющей формы заменяется на меню File дочерней, в которой
обработчик команды New еще не определен. Очевидно, что этот
обработчик должен выполнять те же действия, что и рассмотренный выше.
145
Поэтому определите следующий обработчик событий OnClick для пункта
меню New1 в форме ChildForm:
procedure TChildForm.NewlClick (Sender: TObject) ;
begin
FrameForm.New1.Click;
end;
Этот обработчик просто переадресует вызов к соответствующему
пункту меню обрамляющей формы (метод Click генерирует в элементе
меню, к которому он применяется, событие OnClick).
9.1.6 Управление дочерними формами
По стандарту многодокументное приложения меню обрамляющего
окна должно включать меню управления дочерними окнами. Это меню
обычно называется Window и содержит такие команды как Tile, Cascade,
Arrange All. Заголовок каждого открытого документа автоматически
добавляется после всех пунктов меню Window, а активное дочернее окно в
этом списке отмечается «галочкой». В меню Window отображаются до
девяти названий документов. Если же одновременно открыто более девяти
документов, то в конец списка добавляется команда More Windows... . При
ее выборе на экране появляется окно диалога с заголовком Select Window,
с помощью которого пользователь может активизировать любой из
документов;
12. Для расположения дочерних окон каскадом, мозаикой и
упорядочивания свернутых дочерних окон, определите обработчики
события OnClick для команд меню Tile, Cascade, Arrange All. В
обработчиках событий вызовите соответственно методы формы Tile,
Cascade и Arrangelcons:
Procedure TFrameForm.TilelClick (Sender: TObject) ;
begin
Tile;
end;
Во время работы приложения результат выполнения команды
будет такой (рис. 9.7).
procedure TFrameForm.CascadelClick (Sender: TObject);
begin
Cascade;
end;
Во время работы приложения результат выполнения команды
будет такой (рис. 9.8).
procedure TFrameForm.ArrangeAlllClick (Sender; TObject) ;
begin
Arrangelcons;
146
end;
Во время работы приложения результат выполнения команды будет
иакой (рис. 9.9)
Рис. 9.7
Рис. 9.8
147
Рис. 9.9
13. Чтобы список открытых документов добавлялся в конец
выпадающего меню Window, активизируйте обрамляющую форму и
установите в свойстве WindowMenu значение Windowl. Во время работа
приложения откройте меню Window — в нем вы увидите список открытых
документов (рис. 9.10).
При управлении дочерними формами из программы вам могут
пригодиться некоторые свойства формы, которые не видны в Инспекторе
Объектов. Вы должны знать эти свойства, поэтому ниже мы их приводим
(см. табл. 9.1).
Табл 9.1 Свойства используемые при управлении дочерними формами
многодокументного приложения.
Свойство
Описание
MDIChildren
Массив дочерних форм, в порядке их
создания.
MDIChildCount
Количество открытых дочерних форм.
ActiveMDIChild
Указывает активную дочернюю форму.
Мы рассмотрели общие принципы создания многодокументных
приложений. Наполнение конкретного приложения смыслом и
содержанием — это задача разработчика конкретного приложения.
9.1.7 Шаблон для многодокументных приложений
Перед тем как закончить тему многодокументных приложений,
обратим внимание на возможность использования собственного шаблона
148
Delphi для быстрой организации многодокументного приложения. Этот
шаблон хранится в Хранилище Объектов. Для того чтобы его
задействовать, необходимо выбрать команду меню File | New..., в
диалоговом окне New Items активизировать страницу Projects и выбрать
пункт MDI Application (рис. 9.11).
Вам будет предложено задать маршрут для исходных файлов проекта, а
затем будет создан скелет многодокументного приложения.
Кстати, на рисунке видно, что Delphi предоставляет еще два шаблона,
один из них предназначен для ускоренной организации однодокументного
приложения.
Рис. 9.10
9.2 ПОРЯДОК ВЫПОЛНЕНИЯ РАБОТЫ.
 Изучить структуру многодокументального приложения в среде Delphi.
 Изучить основы многодокументального приложения в среде Delphi.
 Изучить основные способы создания и управления дочерних форм.
 Ответить на контрольные вопросы.
 Пользуясь своим вариантом задания, создайте многодокументальное
приложение.
 Пользуясь средствами Delphi, создайте проект, откомпилируйте его и
проверьте в работе.
149
 Составить отчет по лабораторной работе.
Рис. 9.11
9.3 КОНТРОЛЬНЫЕ ВОПРОСЫ
 Из каких компонент состоит многодокументальное приложение?
 Как создать многодокументальное приложение?
 Как создать дочерние формы многодокументального приложения?
 Как
осуществляется
управление
дочерними
формами
многодокументального приложения?
9.4 ВАРИАНТЫ ЗАДАНИЙ.
Для своего варианта задания темы №5 создайте многодокументальное
приложение.
150
10
ИЗУЧЕНИЕ ОСНОВ СОЗДАНИЯ СПРАВОЧНОЙ
СИСТЕМЫ ПРИЛОЖЕНИЯ В DELPHI
Цель работы: изучение основных средств создания справочной системы
приложения в Delphi.
10.1 МЕТОДИКА ВЫПОЛНЕНИЯ РАБОТЫ
Желательно, чтобы каждая программа имела справочную систему.
Физически справочная система представляет собой набор файлов
определенной структуры, используя которые, программа Winhelp,
являющаяся составной частью Windows, выводит справочную информацию
в стандартном виде.
Каждый файл справки создается из трех физических файлов:
 файла проекта справки с расширением hpj;
 файла содержания справки с расширением cnt;
 файла форматированного текста с расширением rtf, который содержит
текст справочной системы.
Файлы типа hpj и cnt - это обычные текстовые файлы.
Файлы типа rtf (формат Rich - Text Format) поддерживаются
большинством современных текстовых редакторов, прежде всего Word 7.0,
Word 97 и т.п. (кроме WordPad).
При создании файла справки эти три файла (а, при необходимости
также и другие файлы), соединяются в один файл, генерируемый с
помощью компилятора файлов справки, в качестве которого используется
утилита Microsoft Help Workshop, поставляемая вместе с Delphi
Каждый из упомянутых файлов содержит специальные инструкции,
которые определяют вид и поведение создаваемых справочных систем
Процесс создания справочной системы можно представить как
последовательность следующих шагов:
 создание файла документа справочной системы (файла с расширением
rtf);
 файла содержания справки (с расширением cnt);
 создание файла справочной системы (с расширением hpj).
Кроме того, любая профессионально созданная программа должна
иметь диалоговое окно About - о программе. В этом окне выводится самая
общая информация о программе - ее название, версия, авторы разработки,
телефоны, адреса для технической поддержки и т. п.
151
10.1.1 Основные принципы создания файлов справки.
10.1.1.1 Создание файла документа справочной системы
Файл документа справочной системы представляет собой rtf-файл,
созданный, например, при помощи текстового процессора типа Microsoft
Word, который должен иметь средства связи отдельных разделов, тем,
подтем с оглавлением, с предметным указателем, средства реализации
ссылок на другие разделы. Эти средства реализуются с помощью
специальных сносок, которыми помечаются соответствующие темы в
файле.
Сначала следует набрать текст разделов справки, оформив заголовки
разделов и подразделов одним из стилей "Заголовок", например "Заголовок
1". Лучше всего ввести иерархическую нумерацию разделов, подразделов и
тем (например 1, 1.1, 1.2, ...2, 2.1, 2.2,...). Эти номера в дальнейшем могут
быть применены как индексы, используемые в качестве идентификаторов,
используемых как ссылки на конкретные темы из общего содержания, как
контекстные ссылки, а также как ссылки для связи между разделами и
темами.
Текст каждого раздела справки должен находиться на отдельной
странице документа - заканчиваться символом "разрыв страницы", который
вводится с помощью клавиш «Ctrl - Enter» и который можно увидеть на
экране монитора, включив в текстовом редакторе режим «непечатаемые
символы».
После набора текста следует при помощи сносок пометить заголовки
разделов справки (сноски используются компилятором справочной
системы для преобразования rtf-файла в hlp-файл - файл справки). Один
заголовок может быть помечен несколькими сносками.
Наиболее часто используемые сноски приведены в табл. 10.1
Табл. 10.1
Сноска
Назначение
#
Задает идентификатор раздела справки, который может
использоваться в других разделах как ссылка для перехода к
помеченному этой сноской разделу.
$
Задает имя раздела, которое будет использоваться для
идентификации раздела справки в оглавлении, в списке
поиска и в списке просмотренных тем во время
использования справочной системы.
К
Задает список ключевых слов, при выборе которых из
списка диалога поиска осуществляется переход к разделу
справки, заголовок которой помечен этой сноской.
+
Определяет порядок следования разделов при просмотре
справки с помощью кнопок просмотра справочной системы.
152
Чтобы пометить заголовок раздела справки, необходимо установить
курсор перед первой буквой текста заголовка раздела справки и из меню
Вставка выбрать команду Сноска. В открывшемся диалоговом окне Сноски
(рис.1) в группе Вставить сноску нужно установить переключатель в
положение Обычную, а в группе Нумерация - в положение Другая. В поле
ввода сноски следует ввести, например, символ «#» и нажать кнопку ОК.
Рис. 10.1
В результате в документ будет вставлена сноска «#» и в нижней части
окна документа появится окно ввода текста сноски, в котором рядом со
значком сноски следует ввести идентификатор помечаемого раздела
справки. На рис. 10.2 показан пример, где тема 1 Раздел помечена
сносками всех указанных в табл. 1 типов, а у сноски «+» стоит
идентификатор
auto,
который
сообщает
компилятору,
что
соответствующему разделу нужно присвоить очередной номер из
последовательности номеров порядка просмотра тем с помощью кнопок «
, », появляющихся на странице, содержащей требуемый материал при
вызове справки.
Желательно, чтобы идентификатор раздела справки начинался с
префикса idh_ (idh_1, idh_1.1,... idh_2, ......). В этом случае во время
компиляции rtf - файла будет проверена корректность ссылок на разделы
справки. Компилятор выведет список идентификаторов, которые
перечислены в разделе [MAP] файла проекта (см. ниже), но которых нет в
rtf - файле.
Как правило, разделы справки содержат ссылки на другие разделы.
Понятия (слова), выбор которых вызывает переход к другому разделу
справки, выделяются отличным от основного текста справки цветом и
подчеркиваются.
При подготовке текста справки слово, выбор которого должен
обеспечить вход к другому разделу справки, следует подчеркнуть двойной
153
линией и сразу за ним, без пробела, поместить идентификатор раздела
справки, к которому должен быть выполнен переход. Вставленный
идентификатор необходимо оформить как скрытый текст.
Рис. 10.2.
На рис. 10.2 приведен пример файла документа справочной системы со
словом "2 Раздел", помеченным как ссылка на другой раздел справки
(подчеркнут двойной линией), и без пробела - идентификатор IDH_2,
помеченный как скрытый текст (подчеркнут одинарной линией). Здесь
предполагается, что раздел справки "2 Раздел", в котором находятся
нужные сведения, помечен сноской «#», имеющей идентификатор IDH_2.
Чтобы подчеркнуть фрагмент текста двойной линией, необходимо
сначала выделить этот фрагмент, затем из меню Формат выбрать команду
Шрифт и в открывшемся диалоговом окне Шрифт (рис. 10.3) на вкладке
154
Шрифт выбрать в раскрывающемся списке Подчеркивание вариант
двойное.
Для того чтобы фрагмент текста оформить как скрытый текст,
необходимо сначала выделить этот фрагмент, а затем на вкладке Шрифт в
группе Эффекты установить флажок Скрытый.
Помимо ссылки, обеспечивающей переход к другому разделу справки,
в документ можно вставить ссылку на комментарий - текст, появляющийся
в всплывающем окне. Во время работы справочной системы ссылки на
комментарии выделяются цветом и подчеркиваются пунктирной линией.
При подготовке документа справочной системы комментарии, как и
разделы справки, располагают на отдельной странице, однако текст
комментария не должен начинаться заголовком, оформленным одним из
стилей "Заголовок".
Сноска «#» должна быть поставлена перед текстом комментария.
Ссылка на комментарий оформляется следующим образом: сначала надо
подчеркнуть одинарной линией слово, выбор которого должен вызвать
появление комментария, затем сразу после этого слова вставить
идентификатор комментария и оформить его как скрытый текст.
Создайте в rtf - файле все сноски, идентификаторы тем и ссылки, после
чего можно приступить к созданию файлов справочной системы.
Сохраните файл в каком - либо отдельном каталоге например с именем
HelpPr.rtf.
Рис. 10.3.
155
10.1.2 Программа для создание файлов справочной системы
После того как создан файл документа справочной системы (rtf-файл)
со всеми сносками, их идентфикаторами и ссылками, можно приступить
непосредственно к созданию справочной системы. Для этого удобно
воспользоваться программой Microsoft Help Workshop, которая
поставляется вместе с Delphi и находится в файле Hcw.exe, путь к
которому: C:\Program Files\Borland\Delphi\Help\Tools\Hcw.exe.
Запустить Microsoft Help Workshop можно из Windows или, выбрав
команду Help Workshop, из меню Tools.
Рис. 10.4
Если в меню Tools нет команды Help Workshop, то надо выбрать
команду Configure Tools, затем в открывшемся диалоговом окне Tool
Options (рис. 10.4) нажать кнопку Add и в следующем диалоговом окне
Tool Properties (рис. 10.5) ввести в поле Title название программы — "Help
Workshop", а в поле Program— полное имя исполняемого файла программы
Microsoft Help Workshop, т. е. с указанием пути к нему. Для поиска имени
файла можно воспользоваться кнопкой Browse.
Рис. 10.5.
156
После нажатия кнопки ОК становится доступным диалоговое окно
Configure;Tools, в списке которого появляется строка Help Workshop.
Процесс настройки меню Tools заканчивается нажатием кнопки Close.
После запуска программы Help Workshop на экране появляется главное
окно программы.
Рис. 10.6
Чтобы приступить к созданию новой справочной системы, следует из
меню File включить режим Help Author, после чего он становится
помеченым. В этом режиме можно получить дополнительную информацию
о создаваемом файле справки, например, номер создаваемого раздела.
Кроме того, в этом режиме можно перемещаться по разделам независимо
от того, используете вы кнопки просмотра, с помощью клавиш
«Ctrl+Shift+» и «Ctrl+Shift+». Для перемещения на первый и последний
разделы можно использовать комбинации клавиш «Ctrl+Shift+Home» и
«Ctrl+Shift+End».
10.1.2.1 Создание файла содержания.
Для создания файла содержания следует выбрать команду New, а затем
в открывшемся диалоговом окне выбрать тип создаваемого файла — Help
Contents (рис. 10.6).
157
В строке Default filename появившегося окна диалога (рис. 10.7) введите
имя файла, например HelpPr.hlp. В строке Default title введите имя системы,
например Справочная система 1.
Для ввода имени раздела с помощью кнопки Add Above (добавить
выше) откройте окно Edit Contents Tab Entry и включите режим Heading режим ввода имени раздела, который может содержать только другие
подразделы и темы с текстом. В окно Title введите имя раздела (рис. 10.8)
и нажмите ОК - в окне диалога появится первая строка формируемого
содержания -«1 Раздел» (рис. 10.9) со значком «открытая книга»,
указывающим на то, что в «1 Раздел» можно иерархически вкладывать
другие подразделы и темы. Сам «1 Раздел» текста не содержит и не с
какими частями rtf - файла не связан. С помощью кнопки Edit можно
вызвать окно редактора, с помощью которого можно отредактировать
помеченную строку в окне создаваемого содержания.
Рис. 10.7
Для включения в содержание тем с текстом с помощью кнопки Add
Belov (добавить ниже) откройте окно Edit Contents Tab Entry, включите
режим Topic (тема) - режим ввода имени темы, которая должна содержать
текст, в окно Title введите название темы с текстом, например «1 Раздел», а
в окно TopicID - идентификатор темы - в данном случае IDH_1 (рис. 10.10),
с помощью которого будет вызываться текст, имеющийся в «1 Раздел», и
нажмите ОК - в окне диалога появится следующая строка формируемого
содержания -«1 Раздел» (рис. 10.11) со значком «знак вопроса»,
указывающим на то, что «1 Раздел» содержит текст справки. Смещение
158
второй строки относительно первой вправо говорит о том, что она
включена как составная часть верхнего иерархического уровня
содержания.
Рис. 10.8
Рис. 10.9
159
Рис. 10.10
Рис. 10.11
160
Если сформированную строку - тему необходимо сделать
самостоятельной, т. е. не входящей в какой - либо раздел, ее следует
пометить и щелкнуть мышкой по кнопке Move Levt - строка сместится
влево. Если сформированную строку - тему необходимо включить в какой либо раздел, ее следует пометить и щелкнуть мышкой по кнопке Move
Right - строка сместится вправо. Если строку - тему необходимо поместить
выше уже сформированной строки, следует пометить строку - тему или
строку - раздел, выше которой осуществляется вставка, и щелкнуть
мышкой по кнопке Add Above (добавить выше). При этом откроется окно
Edit Contents Tab Entry, в котором следует ввести все данные по
рассмотренной выше методике.
Сформируйте таким образом все оглавление, сохраните файл
содержания с тем же именем, но с расширением cnt (в нашем случае HelpPr.cnt), в том же каталоге, где находится и rtf - файл (с помощью
пунктов меню File | Save as..), после чего перейдите к созданию файла
проекта и добавлению в проект файлов с расширениями rtf и cnt.
10.1.2.2 Создание файла проекта.
Как и файл содержания, файл проекта является текстовым файлом,
который можно создать как вручную, так и с помощью программы Help
Workshop. После настройки файла проекта можно воспользоваться
программой Help Workshop для компиляции проекта.
Рис. 10.12
161
Выберите команду File | New и щелкните дважды на элементе Help
Project в открывшемся окне Project File Name. Программа Help Workshop
попросит указать имя файла проекта. Перейдите в каталог с файлами с
расширениями rtf и cnt и введите имя сохраняемого файла HelpPr, а затем
щелкните по кнопке сохранить. Расширение hpj к имени файла будет
добавлено автоматически.
10.1.2.3
Добавление в проект файлов rtf и cnt, кнопок просмотра и
установка характеристик окна справочной системы.
Щелкните на кнопке Options открывшегося после сохранения файла
проекта окна проекта справочной системы (рис. 10.12), а затем в строке
Default topic открывшегося окна на странице General введите
идентификатор темы, текст которой должен появиться первым при запуске
готовой справочной системы - в нашем случае это IDH_1 - , а в строке Help
title - «Справочная система 1» (рис. 10.13). Щелкните на вкладке
Compression и выберите переключатель Maximum и ОК. Щелкните на
вкладке Files и в строке Rich Text Format появившегося диалогового окна с
помощью кнопки Change, появившегося далее диалогового окна Topic Files
и кнопки Add в стандартном окне Открытие файла найдите каталог файлов
справочной системы и введите файл HelpPr.rtf. В строке Contents file с
помощью кнопки Browse и открывшегося после этого окна выбора файлов
введите файл HelpPr.cnt и закройте окно Options.
Рис. 10.13
162
Щелкните на кнопке Windows, а далее - на кнопке Add на странице
GENERAL в открывшемся диалоговом окне Window Properties. При этом
открывается диалоговое окно Add a New Window Type (рис. 10.14), где в
поле Create a window named следует ввести слово "main" (основной) — тип
создаваемого окна - и ОК.
Рис. 10.14
Возвратившись в окно Window Properties, щелкните по вкладке Buttons
и установите флажок Browse группы параметров Buttons. Теперь в окне
программы HelpPr при отображении файла справочной системы можно
будет использовать кнопки просмотра « , », с помощью которых можно
перемещаться от темы к теме, используя ранее определенный порядок
просмотра (в нашем случае - режим auto).
Возвращаемся в диалоговое окно Window Properties.
На вкладке General этого окна в поле Title bar text следует ввести
заголовок главного окна создаваемой справочной системы.
На вкладке Position диалогового окна Window Properties можно задать
положение и размер окна справочной системы (рис. 10.15).
На этой же вкладке находится кнопка Auto-Sizer, при нажатии которой
открывается окно Help Window Auto-Sizer (рис. 10.16), размер и положение
которого определяются содержимым полей вкладки Position. При помощи
163
мыши можно менять размер и положение этого окна После нажатия
кнопки ОК координаты и размер окна Help Window Auto-Sizer будут
записаны в поля вкладки Position.
Рис. 10.15
На вкладке Color можно задать цвет фона области заголовка раздела
справки (Nonscrolling area color) и области текста справки (Topic area color).
Для этого следует нажать соответствующую кнопку Change и в
стандартном окне Цвет выбрать нужный цвет.
10.1.2.4
Назначение числовых значений идентификаторам разделов
справки.
Эти значения будут использоваться для поиска нужного раздела
справки той программой, для которой создается справочная система.
После установки характеристик окна справочной системы нужно
определить идентификаторы разделов справочной системы. Для этого в
окне проекта справочной системы нажмите кнопку Map и в открывшемся
диалоговом окне Map (рис. 10.17) добавьте идентификатор раздела в
список. Для этого нажмите кнопку Add и в поле Topic ID открывшегося
диалогового окна Add Map Entry (рис. 10.18) введите идентификатор
164
раздела справки, а в поле Mapped numeric value — соответствующее
идентификатору числовое значение. В нашем случае это IDH_1 и 1.
Проделайте это для всех тем rtf - файла. Все темы rtf - файла следует
нумеровать по возрастанию номеров начиная с первой темы. Допускается
пропуск отдельных цифр последовательности, например, можно
номеровать так: 10, 20, 30, 50, и т. д., что дает возможность легко вставлять
новые темы без серьезного редактирования всей справочной системы.
Рис. 10.16
Рис. 10.17
165
Рис. 10.18.
В окне проекта справочной системы отражаются все изменения,
добавления, установки характеристик окна справочной системы и
назначения числовых значений идентификаторам разделов.
10.1.2.5 Компиляция и тестирование справочной системы.
Первый раз компиляцию проекта справочной системы лучше
выполнить выбором из меню File команды Compile, в результате
выполнения которой вызывается диалоговое окно Compile a Help File (рис.
10.19).
Рис. 10.19
166
В этом окне следует установить флажок Automatically display Help file in
WinHelp when done (Автоматически показывать созданную справочную
систему по завершении компиляции), а затем нажать кнопку Compile.
По завершении компиляции на экране появляется окно с
информационным сообщением о результатах компиляции и, если
компиляция выполнена успешно, — то и окно созданной справочной
системы.
Компиляцию можно также выполнить, нажав находящуюся на панели
инструментов кнопку Compile.
Программа Help Workshop позволяет не только создавать, но и
тестировать файлы справки. Выберите команду File | Run WinHelp или
щелкните на кнопке панели инструментов, на которой изображен
вопросительный знак. В списке Mapped Topic Ids появившегося
диалогового окна View Help File выберите элемент IDH_1, являющийся
идентификатором первой темы разработанной справочной системы.
Щелкните на кнопке View Help, чтобы открыть созданный файл
справки. На экране должно появиться окно с текстом, имеющим
идентификатор IDH_1.
Щелкните на ярлыке «Содержание» - будет выдано окно, содержащее
вкладки «Содержание», «Предметный указатель» и «Поиск» с открытой
страницей «Содержание».
Проверьте работу ссылок содержания на темы справочника.
Щелкните на вкладке «Предметный указатель». Проверьте работу
ссылок «Предметного указателя» на темы справочника.
Щелкните на вкладке «Поиск». Вам будет предложено окно,
использование которого позволяет создать базу данных, содержащую все
слова из файла справки. Создайте эту базу данных и проверьте работу
вкладки «Поиск» по нахождению тем, содержащих эти слова.
10.1.3 .Использование справочной системы
Для того чтобы во время работы программы пользователь, нажав
клавишу <F1>, мог обратиться к справочной системе, надо чтобы свойство
HelpFile главного окна приложения содержало имя файла справочной
системы, а свойство HelpContext — число, соответствующее номеру того
раздела справочной системы, который должен быть выведен.
Файл справочной системы приложения лучше всего поместить в ту
папку, в которой находится файл исполняемой программы.
Для каждого компонента можно задать свой раздел справки. Раздел
справки, который появляется, если фокус находится на компоненте, и
пользователь нажимает клавишу <F1>, определяется значением свойства
HelpContext этого компонента. Если значение свойства HelpContext
элемента управления равно нулю, то при нажатии клавиши <F1>
167
появляется тот раздел справки, который задан для формы приложения или
родительского компонента.
Другой способ вывода справки используется, когда в диалоговом окне
есть кнопка Справка. В этом случае для данной командной кнопки
создается процедура обработки события Onciick, которая обращением к
функции winhelp запускает программу Windows Help (winhlp32.exe). При
вызове функкции winhelp в качестве ее параметров указываются:
идентификатор окна, которое запрашивает справочную информацию; имя
файла справочной системы; константа, определяющая действие, которое
должна выполнить программа Windows Help и уточняющий действие
параметр.
Идентификатор окна определяет свойство Handle, которое доступно
только во время работы программы.
Если необходимо вывести раздел справки, то используется константа
HELP_CONTEXT. В этом случае уточняющий параметр задает раздел
справки, который будет выведен на экран.
Добавьте в строку главного меню разработанного ранее программного
проекта, для которого разработана справочная система, выпадающее меню
«Помощь», в которое включите пункт Справка (имя HelpPr) с процедурой
обработки события Onclick, текст которой приведен ниже.
Procedure TForm1.HelpPrClick(Sender: TObject);
begin
winhelp(Forml.Handle,'HelpPr.hlp',HELP_CONTEXT,1);
end;
При активизации данного пункта меню на экран монитора будет
выведена разработанная справочная система с оглавлением и предметным
указателем.
10.1.3.1 Добавление в проект окна About.
Запустите Delphi и откройте разработанный ранее программный
проект. Добавьте в выпадающее меню «Помощь» главной формы проекта
пункт «О программе». Обработчиком этого пункта, который разработаем
позже, будет вызываться окно диалога About, которое мы дальше добавим
в проект.
Выведите на экран с помощью команд File|New диалоговое окно New
Items и на странице Forms выберите форму AboutBox. Добавьте в проект
эту форму, переименуйте ее в AboutForm и сохраните модуль под именем
About.pas. Придайте форме нужные размеры и установите ее заголовок
(свойство Caption) в значение «О программе».
По умолчанию форма имеет много свойств, которые не нужны окну
диалога, например раздвижную границу, меню управления окном, кнопки
168
сворачивания и разворачивания окна. Чтобы их убрать, установите
свойство BorderStyle в значение bsDialog.
Результат сделанного изменения проявится только во время работы и
будет выражаться в следующем:
• у формы будет нераздвижная граница;
• у формы не будет кнопок сворачивания и разворачивания;
• в управляющем меню будут лишь два пункта: Move и Close.
Большинство модальных окон диалога появляются в центре экрана. За
это отвечает свойство формы Position. По умолчанию оно равно poDesigned
— форма появляется точно в том же месте, где она видна во время
разработки. Чтобы сцентрировать форму на экране, установите свойство
Position в значение poScreenCenter.
Окно About обычно содержит красивую картинку, название
программного продукта, замечания по поводу авторских прав или чтонибудь в этом роде и, конечно же, кнопку ОК.
Кнопка ОК имеется на AboutForm. Для нее следует сделать обработчик
так, чтобы окно закрывалось при нажатии этой кнопки. С методикой
написания таких обраьотчиков Вы уже знакомы. Все остальные требуемые
действия также не должны вызвать затруднений.
10.2 ПОРЯДОК ВЫПОЛНЕНИЯ РАБОТЫ.
 Изучите структуру справочника в Delphi - программах
 Изучите основы создания rtf - файла справочника.
 Изучите основные режимы программы Help Workshop.
 Изучите основы создания файла содержания справочника.
 Изучите основы создания файла проекта справочника.
 Изучите методику добавления в проект файлов rtf и cnt, кнопок
просмотра и установки характеристик окна справочной системы.
 Изучите методику назначения числовых значений идентификаторам
разделов справки.
 Изучить основы компиляции и тестирования справочной системы.
 Изучите методику подключения справочника к Delphi - приложению.
 Ответить на контрольные вопросы.
 Пользуясь программой Help Workshop, создайте проект справочной
системы для своего приложения, откомпилируйте его и проверьте в
работе.
 Составить отчет по лабораторной работе.
В отчет должны входить следующие пункты:
Цель работы.
 Описание основных средств создания справочной системы.
 Описание процесса разработки справочной системы.
169
 Результаты проверки программы.
 Вывод о проделанной работе.
10.3 КОНТРОЛЬНЫЕ ВОПРОСЫ
 Какие компоненты используются для создания справочной системы?
 Как создать rtf - файл для справочной системы?
 Как создать файл содержания для справочной системы?
 Какие основные режимы программы Help Workshop Вы знаете?
 Как создать файл проекта справочника?
 Как добавить в проект файлы rtf и cnt, кнопки просмотра и установить
характеристики окна справочной системы?
 Как назначить числовые значения идентификаторам разделов справки?
 Как осуществляется компиляция и тестирование справочной системы?
 Как осуществляется подключение справочника к Delphi - приложению
170
11
ПРИЛОЖЕНИЕ. СТРУКТУРА ПРОГРАММЫ И
КОНСТРУКЦИИ ЯЗЫКА OBJECT PASCAL
Цель приложения: изучение конструкций языка, структуры программы
Object Pascal, основных ее разделов, консольных приложений Delphi и
обработки исключительных ситуаций.
11.1 СТРУКТУРА ПРОГРАММЫ
Синтаксически программа на языке Object Pascal состоит из заголовка,
списка подключаемых к программе модулей и программного блока (табл.
11.1):
Табл. 11.1
Компонент программы
Общий вид
Заголовок программы
program <имя программы>;
Директивы компилятора
{$<директивы>}
Список подключаемых модулей
uses<имя1>, ..., <имяN>;
Программный блок
Раздел описания констант
const....;
Раздел описания типов данных
type . ..;
Раздел описания переменных
var .. .;
Раздел описания процедур
procedure <имя>; begin . . .
end;
Раздел описания функций
function <имя>; begin . . . end;
Тело программы
begin <операторы> end.
Любая секция в программном блоке, кроме тела программы, может
отсутствовать. Секции описания констант, типов данных, переменных,
процедур и функций могут встречаться в программе любое количество раз
и следовать в произвольном порядке. Главное, чтобы все описания были
сделаны до того, как они будут использованы (иначе компилятор просто не
поймет того, что вы написали).
11.1.1 Заголовок программы
Заголовок программы должен совпадать с именем программного
файла. Он формируется автоматически при сохранении файла на диске и
его не следует изменять вручную.
Например, заголовок программы в файле Console.dpr выглядит так:
program Console;
Для подробного пояснений о назначении программы, особенностях
алгоритма и других вещах применяют комментарий, например:
171
{ Демонстрационный пример }
После сведений о программе и разработчиках принято размещать
директивы компилятора. Например, следующая директива всегда
включается в текст консольного приложения (используется для написания
в Delphi обычных Pascal - программ):
{$АРРТУРЕ CONSOLE)
11.1.2 Подключение модулей
Секция подключения модулей предназначена для встраивания в
программу стандартных и разработанных программистом библиотек
подпрограмм и классов (см. ниже). Эта секция состоит из
зарезервированного слова uses и списка имен подключаемых
библиотечных модулей. При написании программ, эмулирующих
текстовый режим, подключается по крайней мере модуль SysUtils. В нем
содержатся определения часто используемых типов данных и
подпрограмм:
uses SysUtils;
С момента подключения все ресурсы модуля (типы данных, константы,
переменные, процедуры и функции, классы) становятся доступны
программисту.
11.1.2.1 структура программного модуля
Логически обособленные группы типов данных, процедур и функций
удобно объединять в специализированные библиотеки — модули Object
Pascal. Общая структура программного модуля - в табл. 11.2.
После слова unit записывается имя модуля. Оно должно совпадать с
именем дискового файла, где находится исходный текст модуля.
Например, если файл называется MATHLIB.PAS, то модуль должен иметь
имя MathLib. Заголовок модуля формируется автоматически при
сохранении файла на диске, поэтому его не следует изменять вручную.
Чтобы дать модулю другой заголовок, просто сохраните его на диске под
другим именем.
В секции interface модуля описываются глобальные данные, процедуры
и функции, доступные для использования в основной программе и других
модулях.
В секции implementation реализуется программный код глобальных
процедур и функций и описываются локальные данные, процедуры и
функции, недоступные основной программе и другим модулям.
Секция initialization является необязательной. Она состоит из блока
операторов и выполняется автоматически непосредственно перед запуском
основной программы. Блоки инициализации подключенных к программе
модулей выполняются в том порядке, в котором они упоминаются в секции
uses программы, в которую включается модуль.
172
Секция finalization тоже является необязательной. Она состоит из блока
операторов и выполняется автоматически непосредственно после
завершения основной программы.
Табл. 11.2
Компонент
Общий вид
модуля
Заголовок
unit<имя модуля>;
модуля
Директивы
{$<директивы>}
компилятора
Интерфейсная
interface
часть
Подключение
uses<иия>, ..., <имя>;
модулей
Константы
const...;
Типы данных
type . .. ;
Переменные
var ... ;
Заголовки
procedure
процедур
<имя>(<параметры>);
Заголовки
function
функций
<имя>(<параметры>)
:
<тип>;
Часть
implementation
реализации
Подключение
uses <имя>, ..., <имя>;
модулей
Константы
const. ..;
Типы данных
type . .. ;
Переменные
var ... ;
Реализация
procedure <имя>; begin
процедур
. . . end;
Реализация
function <имя>; begin .
функций
. . end;
Код
initialization
инициализации
<операторы>
Код завершения
finalization
<операторы>
Конец модуля
end.
Блоки завершения подключенных к программе модулей выполняются в
порядке, обратном порядку подключения модулей в секции uses.
173
Если модуль не нуждается в инициализации и завершении, секции
initialization и finalization можно опустить.
11.1.2.2 Стандартные модули
В состав Delphi входит великолепный набор модулей, возможности
которых удовлетворяет практически всех программистов и которые можно
разбить на три группы: системные модули, модули Windows API и модули
Visual Component Library.
К системным модулям относятся System, SysUtils, ShareMem, Math. В
них содержатся наиболее часто используемые в программах типы данных,
константы, переменные, процедуры и функции. Модуль System — это
сердце Delphi: содержащиеся в нем подпрограммы обеспечивают работу
всех остальных модулей системы. Модуль System подсоединяется
автоматически к каждой программе и его не указывают в операторе uses.
Исходный текст системных модулей находится по маршруту
\Borland\Delphi 2.0\Source\RTL\SYS.
К модулям Windows API относятся следующие: COMMCtrl, CommDlg,
DDEML, Dlgs, LZExpand, MAPI, Messages, MMSystem, OLE2, OleCtl,
OleDlg, RichEdit, ShellAPI, TLHelp32, Windows, WinSock и WinSpool.
Базовый программный интерфейс обеспечивает модуль Windows:
остальные подключаются по мере необходимости и содержат всякого рода
расширения Windows API. Модули Windows API находятся по маршруту
\Borland\Delphi 2.0\Source\RTL\WIN.
Модули Visual Component Librari (VCL) используются для визуальной
разработки полнофункциональных Windows- приложений. VCL - это
высокоуровневая
объектно
ориентированная
библиотека
со
всевозможными элементами пользовательского интерфейса: кнопками,
надписями, меню, панелями и т.д. Кроме того, модули этой библиотеки
содержат простые и эффективные средства доступа к базам данных.
Модули VCL подключаются автоматически при помещении компонентов
на форму, поэтому вам об этом заботиться не надо. Модули VCL находятся
по маршруту
\Borland\Dephi 2.0\Source\VCL. Свойства компонент
подробно рассматриваются в лабораторном практикуме по изучению среды
Delphi.
11.1.2.3 Область действия идентификаторов
При программировании необходимо соблюдать ряд правил,
регламентирующих использование идентификаторов:
- каждый идентификатор должен быть описан перед тем, как он будет
использован;
- областью действия идентификатора является блок, в котором он
описан;
174
- все идентификаторы в блоке должны быть уникальными, т.е. не
повторяться;
- один и тот же идентификатор может быть по разному определен в
каждом отдельном блоке, при этом блоки могут быть вложенными;
- если один и тот же идентификатор определен в нескольких
вложенных блоках, то в пределах вложенного блока действует вложенное
описание;
- все глобальные описания полученного модуля видны программе
(подключающему модулю), как если бы они были сделаны в точке
подключения;
- если подключается несколько модулей, в которых по разному
определен один и тот же идентификатор, то определение, сделанное в
последнем подключенном модуле, перекрывает все остальные;
- если один и тот же идентификатор определен и в подключенном
модуле, и в программе (подключающем модуле), то первый игнорируется,
а
используется
идентификатор,
определенный
в
программе
(подключающем модуле); доступ к идентификатору подключенного
модуля возможен с помощью уточненного имени; уточненное имя
формируется из имени модуля и записанного через точку идентификатора;
например, чтобы получить доступ к стандартному значению числа, нужно
записать System.Pi, где Pi - стандартное число, записанное в разделе
констант интерфейсной части модуля System.
11.1.3 Программный блок
Важнейшим понятием в языке Object Pascal является так называемый
блок. По своей сути блок — это программа в целом или логически
обособленная
часть программы,
содержащая описательную и
исполнительную части. В первом случае блок называется глобальным, во
втором — локальным. Глобальный блок — это основная программа, он
присутствует всегда; локальные блоки — это необязательные
подпрограммы. Локальные блоки могут содержать в себе другие
локальные блоки (т.е. одни подпрограммы могут включать в себя другие
подпрограммы). Объекты программы (типы, переменные и константы)
называют глобальными или локальными в зависимости от того, в каком
блоке они объявлены.
С понятием блока тесно связано понятие области действия
программных объектов. Область действия трактуется как допустимость
использования объектов в том или ином месте программы. Правило здесь
простое: объекты программы можно использовать в пределах блока, где
они описаны, и во всех вложенных в него блоках. Отсюда следует вывод —
с глобальными объектами можно работать в любом локальном блоке.
175
11.1.3.1 Раздел описания констант
Константы описываются с помощью зарезервированного слова const.
За ним идет список имен констант, каждому из которых с помощью знака
равенства присваивается значение. Одно присваивание отделяется от
другого точкой с запятой. Тип константы распознается компилятором
автоматически, поэтому его не надо указывать при описании. Примеры
констант:
const
DelphiLanguage = 'Object Pascal';
Yard = 914.4;
Foot = 304.8;
После такого описания для обращения к нужному значению достаточно
указать лишь имя соответствующей константы.
Значение константы можно задавать и выражением. Эту возможность
удобно использовать для комплексного представления какого-либо
понятия. Например, временной промежуток, равный одному месяцу,
можно задать так:
const
Minute == 60;
Hour = Minute*60;
Day = Hour *24;
Month = Day*31;
Очевидно, что изменив базовую константу Minute, можно изменить
значение Month.
При объявлении константы можно указать ее тип:
const
Percent: Double = 2.46;
FileName: String = ‘Win.com’;
Такие константы называются типированньши, они незаменимы при
объявлении константных значений структурированных типов.
11.1.3.2 Раздел описания новых типов данных
Кроме стандартных типов данных Object Pascal поддерживает типы,
определенные программистом. Новый тип данных определяется с
помощью зарезервированного слова type, за которым следует
идентификатор типа, знак равенства и описание. Описание завершается
точкой с запятой. Например, можно определить тип, тождественный
существующему типу:
type
176
TUnicode = WideChar; { тип TUnicode тождествен типу WideChar }
TFloat = Double; { тип TFloat тождествен типу Double }
Идентификаторы новых типов в примере начинаются заглавной буквой
Т (первая буква слова type). Такое соглашение о типах программиста
принято разработчиками Delphi, но оно не является строгим. Тем не менее
мы рекомендуем его придерживаться, так как оно способствует
понимаемости программ.
Синтаксическая конструкция type позволяет создавать новые
порядковые типы: перечисляемые типы, интервальные типы, а также
структурированные типы, особенности работы с которыми рассмотрены в
соответствующих разделах описания языка Object Pascal.
11.1.3.3 Раздел описания переменных
Переменные могут менять свое значение в процессе работы программы
и описываются с помощью зарезервированного слова var. За ним
перечисляются идентификаторы переменных и через двоеточие
указывается их тип, после которого ставится точкой с запятой. Например:
var
Index: Integer;
{ переменная целого типа }
FileName: string; { переменная строкового типа }
Sum, Profit: Double; { группа переменных вещественного типа }
В теле программы переменной можно присвоить значение. Для
этого используется составной символ :=, например:
Sum := 5000.0;
{ переменной Sum присваивается 5000 }
Percent := 0.15;
{ переменной Percent присваивается 0.15)
Profit := Sum*Percent; { вычисляется произведение двух
переменных и его результат присваивается переменной Profit }
Вы можете присвоить значение переменной непосредственно при
объявлении:
var
Index: Integer = 1;
Delimiter: Char = ';';
Объявленные
таким
образом
переменные
называются
инициализированными.
На
инициализированные
переменные
накладывается ограничение: они не могут объявляться в подпрограммах
(процедурах и функциях). Если переменная не инициализируется при
объявлении, то по умолчанию она заполняется нулем.
Заметим, что в Borland Pascal и ранних версиях Delphi не существовало
инициализированных
переменных,
вместо
них
использовались
типизованные константы. В Delphi 2.0 - 4.0 типизованные константы
являются настоящими константами, а для совместимости с ранними
версиями компилятора используется директива $WRITEABLECONST.
177
Чтобы типизованные константы можно было изменять по ходу работы
программы, эту директиву нужно установить в значение ON.
11.1.3.4 Описание процедур программиста
Очевидно, что встроенных процедур и функций для решения
большинства прикладных задач недостаточно, поэтому приходится
разрабатывать собственные процедуры и функции. По своей структуре они
напоминают программу и состоят из заголовка и блока. Заголовок
процедуры состоит из зарезервированного слова procedure, имени
процедуры и необязательного заключенного в круглые скобки списка
формальных параметров, Имя процедуры — это идентификатор,
уникальный в пределах программы. Формальные параметры — это данные,
которые вы передаете в процедуру для обработки, и данные, которые
процедура возвращает (подробно параметры описаны ниже). Если
процедура не получает данных извне и ничего не возвращает, формальные
параметры (в том числе круглые скобки) не записываются. Тело процедуры
представляй собой локальный блок, по структуре аналогичный программе:
procedure <имя процедуры> ( <формальные параметры> ) ;
const...;
type ...;
var . ..;
begin
<операторы>
end;
Описания констант, типов данных и переменных действительны только
в пределах данной процедуры. В теле процедуры можно использовать
любые глобальные константы и переменные, а также вызывать любые
подпрограммы (процедуры и функции).
Вызов процедуры для выполнения осуществляется по ее имени, за
которым в круглых скобках следует список фактических параметров, т.е.
передаваемых в процедуру данных:
<имя процедуры> ( <список фактических параметров> );
Если процедура не принимает данных, то список фактических
параметров (в том числе круглые скобки) не указывается.
11.1.3.5 Описание функций программиста
Функции программиста применяются в тех случаях, когда надо создать
подпрограмму, участвующую в выражении как операнд. Как и процедура,
функция состоит из заголовка и блока. Заголовок функции состоит из
зарезервированного слова function, имени функции, необязательного
заключенного в круглые скобки списка формальных параметров и типа
возвращаемого функцией значения. Функции возвращают значения любых
178
типов данных, кроме Text и file of (см. раздел «Файлы»). Тело функции
представляет собой локальный блок, по структуре аналогичный программе.
function <имя функции> ( <формальные параметры> ) :<тип
результата>;
const. .;
type .. .;
var . ..;
begin
<операторы>
end;
В теле функции должен находиться по крайней мере один оператор,
присваивающий значение имени функции или неявной локальной
переменной Result. Если таких присваиваний несколько, то результатом
функции будет значение последнего из этих операторов. Преимущество от
использования переменной Result состоит в том, что она может участвовать
в выражениях как операнд.
11.1.3.6 Тело программы
Тело программы является исполнительной частью глобального блока.
Именно из него вызываются для выполнения описанные выше процедуры
и функции. Программный блок начинается зарезервированным словом
begin (начало), далее следуют операторы языка, отделенные друг от друга
точкой с запятой. Завершают раздел зарезервированное слово end (конец) и
точка. Программный блок простейшего консольного приложения выглядит
так:
begin
Writeln( ' Press Enter to exit ...');
Readln;
end.
11.1.4 Операторы
Основная часть программы на языке Pascal представляет собой
последовательность операторов, выполняющих некоторые действия над
данными, объявленными в секции описания данных. Операторы
выполняются строго последовательно в том порядке, в котором они
записаны в тексте программы и отделяются один от другого точкой с
запятой.
Все операторы принято в зависимости от их назначения разделять на
две группы:
 простые;
 структурные.
Простые операторы не содержат в себе никаких других операторов. К
ним относятся операторы присваивания, вызова процедуры и безусловного
179
перехода. Структурные операторы содержат в себе простые или другие
структурные операторы и подразделяются на составной оператор,
условные операторы и операторы повтора.
11.1.4.1 Оператор присваивания
Оператор присваивания (:=) выполняет выражение, заданное в его
правой части, и присваивает результат переменной, идентификатор
которой - в левой части. Например:
Y := 6;
Z — (X + Y) / 2;
Для исключения ошибок необходимо следить, чтобы переменная и
выражение имели один тип; исключение составляет случай, когда
переменная имеет вещественный тип, а выражение — целочисленный.
11.1.4.2 Оператор вызова процедуры
Оператор вызова процедуры представляет собой имя стандартной или
пользовательской процедуры. Примеры вызова процедур:
Writeln; { вызов стандартной процедуры }
МуРгос; { вызов процедуры, определенной программистом }
11.1.4.3 Составной оператор
Составной оператор представляет собой группу из произвольного
числа операторов, отделенных друг от друга точкой с запятой и
заключенных в операторные скобки begin и end:
begin
<оператор 1>;
<оператор 2>;
<оператор N>
end;
Составной оператор может находиться в любом месте программы, где
разрешен простой оператор. Он широко используется с условными
операторами и операторами повтора.
11.1.4.4 Условные операторы
Условные операторы обеспечивают выполнение или невыполнение
некоторого оператора, группы операторов или блока в зависимости от
заданных условий. Допускается использование двух условных операторов:
if и case.
11.1.4.4.1
Оператор if
Условный оператор if — одно из самых популярных средств,
изменяющих естественный порядок выполнения операторов программы.
Вот его общий вид:
180
if <условие> then <оператор 1>
else <оператор 2>;
Условие — это выражение булевского типа, оно может быть простым
или сложным.
Сложные условия образуются с помощью логических операций и
операций отношения.
Логика работы оператора if очевидна: выполнить оператор 1, если
условие истинно, и оператор 2, если условие ложно. Поясним сказанное на
примере:
program Console;
{$APPTYPE CONSOLE}
uses SysUtils;
var
A, B, C: Integer;
begin
A := 2;
В := 8;
if A > В then
С := A
else
С := В;
Writeln('C=', С);
Writeln ( ' Press Enter to exit ...');
Readln;
End.
В данном случае значение выражения А > В ложно, следовательно на
экране появится сообщение С=8.
У оператора if существует и вторая форма, в которой else отсутствует:
if <условие> then <оператор>;
Логика работы этого оператора if еще проще: выполнить оператор,
если условие истинно, и пропустить оператор, если оно ложно.
Один оператор if может входить в состав другого оператора if. В таком
случае говорят о вложенности операторов. При вложенности операторов
каждое else соответствует тому then, которое непосредственно ему
предшествует. Например:
program Console;
{$APPTYPE CONSOLE)
uses
SysUtils;
var
181
A: Integer;
begin
Readln (A);
if A >= 0 then
if A <= 100 then
Writeln ('А попадает в диапазон 0 — 100.')
else
Writeln('А больше 100.')
else
Writeln('А меньше 0');
Writeln('Press Enter to exit. . . ');
Readln;
End.
11.1.4.4.2
Оператор case
Оператор ветвления case является обобщением оператора if и позволяет
сделать выбор из произвольного числа имеющихся вариантов. Он состоит
из выражения, называемого селектором, и альтернативных операторов,
каждому из которых предшествует свой список допустимых значений
селектора:
case <селектор> of
<список значений селектора 1>: <оператор 1>;
<список значений селектора 2>: <оператор 2>;
<список значений селектора М>: <оператор N>
else <оператор N+l>
end;
Оператор case вычисляет значение селектора (селектор может быть
выражением), затем последовательно просматривает списки допустимых
значений селектора в поисках вычисленного значения и, если значение
найдено, выполняет соответствующий ему оператор. Если селектор не
попадает ни в один из списков, выполняется оператор, стоящий за словом
else. Если часть else отсутствует, управление передается на следующий
оператор за словом end.
Селектор должен принадлежать порядковому типу данных.
Вещественные и строковые типы в качестве селектора запрещены.
Список значений селектора может состоять из произвольного
количества значений, нетипированных констант и диапазонов, отделенных
друг от друга запятыми. Границы диапазонов записываются двумя
константами через разграничитель в виде двух точек (..). Все значения
182
селектора должны быть уникальными, а диапазоны не должны
пересекаться, иначе компилятор сообщит об ошибке. Тип значений должен
быть совместим с типом селектора. Например:
program Console;
($APPTYPE CONSOLE}
uses SysUtils;
var
Day: 1 ..31.•
begin
Readln(Day);
case Day of
20..31 : Writeln('День попадает в диапазон 20 — 31.');
1,5..10:Writeln('День попадает в диапазон 1,5—10');
else Writeln('День не попадает в заданные диапазоны');
end;
Writeln('Press Enter to exit. . . ');
Readln;
end.
11.1.4.5 Операторы повтора
Алгоритм решения многих задач требует многократного повторения
одних и тех же операций. Для неоднократного выполнения одних и тех же
действий предназначены операторы повтора (циклы). К ним относятся
операторы for, repeat и while. Каждый из них используется для организации
цикла своего особого рода.
Любой оператор повтора состоит из условия повтора и повторяемого
оператора (тела цикла). Тело цикла представляет собой простой или
структурный оператор. Оно выполняется столько раз, сколько
предписывает условие повтора. Различие среди операторов повтора
связано с различными способами записи условия повтора.
11.1.4.5.1
Оператор for
Оператор for используется в том случае, если заранее известно
количество повторений цикла. Приведем наиболее распространенную его
форму:
for <параметр цикла> := значение 1> to <значение 2> do
<оператор>;
где for... do — это условие повтора; <параметр цикла> — переменная
любого порядкового типа, кроме вещественного; <значение 1> и <значение
2> — выражения, определяющие соответственно начальное и конечное
значения параметра цикла (они вычисляются один раз перед началом
выполнения оператора for); <оператор> — тело цикла.
183
После каждого повтора значение параметра цикла увеличивается на
единицу. Например, в результате выполнения следующей программы на
экран будут выведены все значения параметра цикла 1(от 1 до 10), причем
каждое значение будет находиться в отдельной строке:
program Console;
{$APPTYPE CONSOLE}
uses SysUtils;
var
I: Integer;
begin
for I: = I to 10 do Writeln(I);
Writeln('Press Enter to exit. . . ');
Readln;
end.
Заметим, что если конечное значение параметра цикла больше
начального значения, цикл не выполняется ни разу.
Вторая форма записи оператора for обеспечивает перебор значений
параметра цикла не по возрастанию, а по убыванию:
for <параметр цикла> := значение 1>downto значение 2>
do <оператор>;
11.1.4.5.2
Оператор repeat
Оператор repeat используют в тех случаях, когда тело цикла должно
быть выполнено перед тем, как произойдет проверка условия завершения
цикла. Он имеет следующий формат:
repeat
<оператор 1>;.......;
<оператор N>
until <условие завершения цикла>;
Тело цикла выполняется до тех пор, пока условие завершения цикла
(выражение булевского типа) не станет истинным. Оператор repeat имеет
две характерные особенности, о которых нужно всегда помнить:
 между словами repeat и until может находиться произвольное число
операторов без операторных скобок begin и end;
 так как условие завершения цикла проверяется после выполнения
операторов, цикл выполняется по крайней мере один раз.
В следующем примере показано, как оператор repeat применяется для
суммирования вводимых с клавиатуры чисел, которое прекращается, когда
пользователь вводит число 0:
program Console;
{$APPTYPE CONSOLE)
uses
184
SysUtils;
var
S,X:Integer;
begin
S := 0;
repeat
Readln(X);
S:=S+X;
until X = 0;
Writeln('S=', S);
Writeln('Press Enter to exit...');
Readln;
end.
Часто бывает, что условие цикла нужно проверять до начала цикла. В
этом случае применяется оператор while.
11.1.4.5.3
Оператор while
Оператор while является альтернативой оператору repeat и содержит
условие выполнения цикла, а не условие завершения:
while <условие> do <оператор>;
Перед каждым выполнением тела цикла происходит проверка условия.
Если оно истинно, цикл выполняется и условие вычисляется заново; если
оно ложно, происходит выход из цикла, т.е. переход к следующему за
циклом оператору. Если первоначально условие ложно, то тело цикла не
выполняется ни разу. Следующий пример показывает использование
оператора while для вычисления суммы S = 1+2+ ...+ N, где N задается с
клавиатуры:
program Console;
($APPTYPE CONSOLE}
uses
SysUtils;
var
S, N: Integer;
begin
Readln (N) ;
S := 0;
while N > 0 do
begin
S :=S+N;
N := N- 1;
end;
Writeln('S=', S);
185
Writeln('Press Enter to exit. . . ');
Readln;
end.
11.1.5 Консольный ввод-вывод
Рассмотрим средства консольного ввода-вывода данных. Консоль - это
клавиатура + монитор. С клавиатуры данные вводятся в программу, а на
монитор выводятся результаты ее работы. Консольная модель вводавывода, при которой данные представляются потоком символов, не
позволяет использовать графические средства Windows и используется
лишь для совместимости с текстовым режимом MS DOS. Но она удобна
для изучения языка Object Pascal, т.к. не загромождает примеры программ
излишней информацией о среде и библиотеках программирования. В среде
Delphi такой ввод - вывод используется в основном для работы с
программами, созданными в старых версиях Pascal преимущественно для
работы в среде MS DOS.
Для создания консольного приложения проделайте следующие
действия:
Запустите Delphi и выберите в главном меню команду File/New и на
странице New диалогового окна New Items выберите тип создаваемого
файла Text.
В открывшемся пустом окне наберите с клавиатуры исходный текст
простого консольного приложения:
Program Console;
{$APPTYPE CONSOLE}
Uses
SysUtils;
begin
Writeln(‘Press Enter to Exit’);
Readln;
end.
Сохраните текст с помощью команды главного меню File|Save As с
именем Console.dpr. Имейте в виду, что в Delphi главный файл программы
имеет расширение dpr, а его имя должно совпадать с именем программы.
Скомпилируйте и выполните эту программу, щелкнув на пункте Run |
Run главного меню Delphi. На экране появится черное окно, в левом
верхнем углу которого будет содержаться текст Press Enter to exit...
(Нажмите клавишу Enter...).
11.1.5.1 Консольный вывод
Инструкции Write и Writeln служат для вывода данных на экран
монитора. Они имеют следующий формат:
186
Write(Yl,Y2,...,Yn);
Writeln(Yl,Y2,...,Yn);
где Yl,Y2,...,Yn — константы, переменные и результаты выражений.
Инструкция Writeln аналогична Write, но после выполнения вывода
переводит курсор в начало следующей строки.
Если инструкции Write и Writeln записаны без параметров:
Write;
Writeln;
то это вызывает пропуск на экране соответственно одной позиции и
одной строки.
11.1.5.2 Консольный ввод
Команды ввода обеспечивают ввод данных для последующей
обработки в программе и имеют формат:
Read(XI,Х2,...,Хп);
Readln(XI,Х2,...,Хп);
где Х1, Х2,...,Хn — переменные, для которых осуществляется ввод
значений. Пример:
Read(А);
{ вводится значение переменной А }
Readln(В); { вводится значение переменной В }
Если одна инструкция вводит несколько значений:
Read(А, В);
то все эти значения надо набрать на клавиатуре, отделяя одно значение
от другого пробелом, и нажать клавишу Enter.
Если вводится одно значение:
Read(С);
то его следует набрать и нажать клавишу Enter. С этого момента
программа может обрабатывать введенное значение в соответствии с
алгоритмом решаемой задачи.
Инструкция Readln отличается от Read одним свойством: каждое
выполнение инструкции Readln переводит курсор в начало новой строки, а
после выполнения Read курсор остается в той же строке.
В простейшем случае в инструкциях Read и Readln параметры можно
вообще не указывать:
Read;
Readln;
Оба этих оператора останавливают выполнение программы до нажатия
клавиши Enter.
Имейте в виду, что для организации ввода-вывода при работе в среде
Windows Delphi предлагает мощные средства объектно-ориентированного
программирования, которые изучаются в других работах лабораторного
практикума.
187
11.2 ВСТРОЕННЫЙ АССЕМБЛЕР
В процессе разработки программы вы можете неожиданно обнаружить,
что средств Object Pascal для решения некоторых задач явно недостаточно.
Например, организация критичных по времени вычислений требует
использования ассемблера или машинного кода. Кроме того, часто
возникает необходимость включать в программу на Object Pascal
откомпилированные ранее процедуры и функции, написанные на
ассемблере. Object Pascal имеет необходимые средства решения таких
задач.
Пользователю предоставлена возможность делать вставки на
встроенном ассемблере в паскалевский текст. Встроенный ассемблер
поддерживает все множество операций процессора 80386 с сопроцессором
80387 и почти все операторы Turbo Assembler, реализует большое
количество директив Turbo Assembler и Microsoft Macro Assembler.
К встроенному ассемблеру можно обратиться с помощью
зарезервированного слова asm, за которым следуют команды ассемблера и
слово end:
asm
<оператор ассемблера>
<оператор ассемблера>
end;
На одной строке можно поместить несколько операторов ассемблера,
разделенных двоеточием. Если каждый оператор размещен на отдельной
строке, двоеточие не ставится.
В Object Pascal имеется возможность не только делать ассемблерные
вставки, но и писать процедуры и функции полностью на ассемблере. В
этом случае тело подпрограммы ограничивается словами asm и end (а не
begin и end), между которыми помещаются инструкции ассемблера. Перед
словом asm могут располагаться объявления локальных констант, типов и
переменных. Например, вот так могут быть реализованы функции
вычисления минимального и максимального значения из двух целых чисел:
function Min (А, В: Integer): Integer; register; asm
CMP
EDX, ЕАX
JGE @ @ 1
MOV
EAX, EDX
@ @ 1:
end;
function Max (A, В: Integer): Integer; register; asm
CMP
EDX, EAX
JLE
@@1
188
MOV
EAX, EDX
@@1:
end;
Обращение к этим функциям имеет привычный вид:
Writeln(Min(10, 20) );
Writeln(Max(10, 20));
11.3 ПОДКЛЮЧЕНИЕ ВНЕШНИХ ПОДПРОГРАММ
Программисту предоставляется возможность подключать к программе
или модулю отдельно скомпилированные процедуры и функции,
написанные на языке ассемблера или С. Для этого используется директива
компилятора $LINK и зарезервированное слово external. Директива {$LINK
<имя файла>} указывает подключаемый объектный модуль, a external
сообщает компилятору, что подпрограмма внешняя.
Предположим, что на ассемблере написаны и скомпилированы
функции Min и Мах, их объектный код находится в файле MINMAX.OBJ.
Подключение функций Min и Мах к программе на Object Pascal будет
выглядеть так:
function Mm (X, Y: Integer): Integer: external;
function Max (X, Y: Integer): Integer, external;
{$LINK MINMAX. OBJ}
В модулях внешние подпрограммы подключаются в разделе
implementation.
11.4 ИСКЛЮЧИТЕЛЬНЫЕ СИТУАЦИИ И НАДЕЖНОЕ ПРОГРАММИРОВАНИЕ
Когда программист после компиляции получает готовый к исполнению
файл, он искренне верит, что программа будет работать именно так, как он
хочет. Пока она в его заботливых руках, так оно обычно и бывает. Когда
же программа попадает в более суровые условия - к новому пользователю
и на другой компьютер — с ней может произойти все, что угодно. “Новый
хозяин” может вместо ожидаемых цифр ввести буквы, извлечь корень из
отрицательного числа, делить на ноль и выполнять множество других
необдуманных, часто случайных действий. Особенно это касается
интерактивных (диалоговых) приложений, а таких — громадное
большинство. Из этого следует, что программист должен организовать
защиту программы в процессе ее выполнения от подобных действий.
11.4.1 Ошибки и исключительные ситуации
Вы должны отдавать себе отчет в том, что в любом работающем
приложении могут происходить ошибки. Причины ошибок бывают
разными. Некоторые ошибки носят субъективный характер и вызваны
неграмотными действиями программиста. Но существуют и объективные
189
ошибки, их нельзя избежать при проектировании приложений, но можно
обнаружить во время его работы. Примеров таких ошибок сколько угодно:
недостаточный объем свободной памяти, отсутствие файла на диске, выход
значений исходных данных из допустимого диапазона и т.д.
Хорошее приложение должно справляться со своими ошибками и
работать дальше, не зацикливаясь и не зависая ни при каких
обстоятельствах. Для обработки ошибок можно, конечно, пытаться
использовать структуры вида if <ошибка> then Exit. Однако в этом случае
ваш стройный и красивый алгоритм решения основной задачи обрастет
уродливыми проверками так, что через неделю вы сами в нем не
разберетесь. ”з этой почти тупиковой ситуации Delphi предлагает простой
и элегантный выход — механизм обработки исключительных ситуаций.
Исключительная ситуация (ехсерtiоn) — это термин, которым
обозначается любая ошибка или ошибочное условие, возникающие в
процессе выполнения программы. Когда программа обнаруживает ошибку,
она генерирует исключительную ситуацию. При этом нормальный ход
выполнения программы прерывается и управление передается специальной
части кода, которая выполняет обработку исключительной ситуации. После
обработки исключительной ситуации возврат в точку его возникновения не
происходит, а выполняются действия, следующие за телом обработчика.
Этот механизм успешно работает даже тогда, когда исключительные
ситуации генерируют вызываемые подпрограммы, а обрабатывают
вызывающие (чаще всего так и происходит). В итоге удается отделить
смысловую часть алгоритма от обработчиков ошибок, в результате
программа становится более простой, понятной и отказоустойчивой.
Для практической реализации описанной схемы в Object Pascal введены
специальные языковые конструкции try...ехсерt...end, try...finally...end и
оператор raise, которые здесь рассмотрены.
11.4.2 Классы исключительных ситуаций
Исключительные ситуации в Object Pascal описываются классами.
Каждый класс соответствует определенному типу исключительных
ситуаций. Когда в программе возникает исключительная ситуация,
создается объект соответствующего класса, который переносит
информацию об этой ситуации из места возникновения в место обработки.
Классы исключительных ситуаций образуют иерархию, корнем
которой является класс Ехсерtion. Класс Ехсерtion описывает самый общий
тип исключительной ситуации, а его наследники — конкретные виды таких
ситуаций (табл. 11.3). Например, класс ЕОutМеmory порожден от Ехсерtion
и описывает ситуацию, когда свободная оперативная память исчерпана.
В следующей таблице приведены стандартные классы исключительных
ситуаций, объявленные в модуле SysUtils. Они покрывают практически
190
весь спектр возможных ошибок. Если их все-таки окажется недостаточно,
вы можете объявить новые классы исключительных ситуаций,
порожденные от класса Ехсерtion или его наследников.
Tабл. 11.3
Класс
Описание
исключительных
ситуаций
EAbort
“Безмолвная” исключительная ситуация, используемая в
программе для выхода из нескольких уровней вложенных
блоков или подпрограмм. При этом приложение не выдает
на экран никаких сообщений об ошибке. Для генерации
исключительной ситуации класса EAbort вы должны
вызвать стандартную процедуру Abort.
ElnOutЕггог
Ошибка доступа к файлу или устройству ввода-вывода.
Код ошибки содержится в поле ЕггогСоdе.
ЕОutOfМеmor
Свободная оперативная память исчерпана.
y
EIntЕггог
Общий класс исключительных ситуаций целочисленной
арифметики, от которого порождены классы ЕDivByZero,
ЕRangeЕггог и EIntOverflow.
EDivByZero
Попытка деления целого числа на нуль.
ERangeЕггог
Выход за границы диапазона целого числа или
результата целочисленного выражения.
EIntOverflow
Переполнение в результате целочисленной операции.
EMathError
Общий класс исключительных ситуаций вещественной
математики, от которого порождены классы EInvalidOp,
EZeroDivide, EOverflow и EUnderflow
EInvalidOp
Неверный код операции вещественной математики.
EZeroDivide
Попытка деления вещественного числа на нуль.
EOverflow
Потеря старших разрядов вещественного числа в
результате переполнения разрядной сетки
EUnderflow
Потеря младших разрядов вещественного числа в
результате переполнения разрядной сетки.
EInvalidPointe
Попытка освободить недействительный указатель.
r
Обычно это означает, что указатель уже освобожден.
ElnvalidCast
Неудачная попытка приведения объекта к другому
классу с помощью оператора as.
EConvertError
Ошибка преобразования данных с помощью функций
IntToStr, StrToInt, StrToFloat, StrToDateTime.
EVariantError
Невозможность
преобразования
варьируемой
переменной из одного формата в другой.
191
EAccessViolat
ion
EPrivilege
EStackOverflo
Приложение осуществило доступ к неверному адресу в
памяти. Обычно это означает, что программа обратилась за
данными по неинициализированному указателю.
Попытка выполнить привилегированную инструкцию
процессора, на которую программа не имеет права.
Стек приложения не может быть больше увеличен.
w
EControlC
Во время работы консольного приложения пользователь
нажал комбинацию клавиш Ctrl+C.
EPropReadOnl
Попытка установки значения свойства в объекте OLE
y
Automation, которое доступно только по чтению.
EPropWriteOn
Попытка получения значения свойства в объекте OLE
ly
Automation, которое доступно только по записи.
EExternalExce
Исключительная ситуация операционной системы,
ption
которая не соответствует ни одному из стандартных классов
исключительных ситуаций Delphi|. Это, например, может
быть исключительная ситуация, возникшая в DLL библиотеке, разработанной на С++.
Наследование классов позволяет создавать семейства родственных
исключительных ситуаций. Примером такого семейства являются классы
исключительных ситуаций вещественной математики, которые объявлены
в модуле SysUtils следующим образом.
type
EMathError=class(Exception);
EInvalidOp=class(EMathError);
EZeroDivide=class(EMathError);
EOverflow=class(EMathError);
EUnderflow=class(EMathError) ;
Класс исключительных ситуаций EMathError является базовым для
классов ElnvalidOp, EZeroDivide, EOverflow и EUnderflow, поэтому,
обрабатывая исключительные ситуации класса EMathError, вы будете
обрабатывать все ошибки вещественной математики, включая EInvalidOp,
EZeroDivide, EOverflow и EUnderflow.
Нетрудно заметить, что имена классов исключительных ситуаций
начинаются с буквы E (от слова Exception). Этого правила полезно
придерживаться при объявлении собственных классов исключительных
ситуаций, например:
type
EMyException = class (Exception)
MyErrorCode: Integer;
end;
192
Как описываются классы исключительных ситуаций,
рассмотрим теперь, как такие ситуации обрабатываются.
понятно,
11.4.3 Обработка исключительных ситуаций
11.4.3.1 Генерация исключительной ситуации
Идея обработки исключительных ситуаций состоит в следующем.
Когда некоторая подпрограмма сталкивается с неразрешимой проблемой,
она генерирует исключительную ситуацию соответствующего класса в
надежде на то, что ее сможет обработать какая-нибудь вызывающая
подпрограмма. Например:
raise EOutOfMemory.Create ('Маловато памяти’);
Данный оператор прекращает нормальное выполнение программы и
генерирует исклю-чительную ситуацию класса EOutOfMemory. Какаянибудь вызывающая подпрограмма может эту ситуацию отловить и
обработать. Для этого в ней организуется так называемый защищенный
блок:
try
{защищенные от ошибок операторы }
except
{операторы обработки исключительной ситуации}
end;
Между словами try и except помещаются смысловые операторы,
которые пишутся в предположении, что все исходные данные и
возвращаемые значения функций корректны. Если при выполнении любого
из этих операторов возникает исключительная ситуация, то управление
передается на оператор, следующий за словом except. Операторы между
словами except и end образуют секцию обработки исключительной
ситуации. Эта секция пропускается при нормальном (безошибочном)
выполнении программы (рис. 11.1).
При написании программы вы можете использовать вложенные
защищенные блоки, чтобы организовать локальную и глобальную
обработку исключительных ситуаций. Концептуально это выглядит
следующим образом:
try
...........
try
{ операторы с локальной защитой от ошибок }
except
{ локальная обработка исключительных ситуаций }
end;
...........
193
except
{ глобальная обработка исключительных ситуаций }
end;
Нормальный ход вычислений
Ход вычислений в случае
возникновения исключительной ситуации
Рис. 11.1
Исключительные
ситуации
внешнего
защищенного
блока,
возникающие за пределами вложенного блока, обрабатываются внешней
секцией except....end. ”сключительные ситуации вложенного защищенного
блока обрабатываются вложенной секцией except....end. Если вложенная
секция не может обработать исключительную ситуацию, то управление
передается внешней секции except....end. Если и она не справляется с
обработкой, то управление передается обработчику исключительных
ситуаций вызывающей подпрограммы.
11.4.3.2 Распознавание исключительной ситуации
Распознавание класса исключительной ситуации выполняется с
помощью конструкций
on <класс исключительной ситуации> <do <оператор>;
которые записываются в секции обработки исключительной ситуации,
например:
try
{ вычисления с вещественными числами }
except
on EZeroDivide do { обработка ошибки деления на нуль };
on EMathError do { обработка других ошибок вещественной
математики };
end;
Поиск соответствующего обработчика выполняется последовательно
до тех пор, пока класс исключительной ситуации не станет совместим с
классом, указанным в операторе on. Как только обработчик найден,
выполняется оператор, стоящий за словом do и управление передается за
194
секцию except....end. Если исключительная ситуация не относится ни к
одному из указанных классов, то управление передается во внешний блок
try ... except... end и обработчик ищется в нем.
Обратите внимание, что порядок операторов on имеет значение,
поскольку распознавание исключительных ситуаций должно происходить
от частных классов к общим, иначе говоря от производных классов к
родительским. С чем это связано? Сейчас поймете. Представьте, к чему
приведет изменение порядка операторов on в примере выше, если принять
во внимание, что класс EMathError является базовым для EZeroDivide.
Ответ простой: обработчик EMathError будет поглощать все ошибки
вещественной математики, в том числе EZeroDivide, в результате
обработчик EZeroDivide никогда не выполнится.
На самом высоком уровне программы бывает необходимо отлавливать
все исключительные ситуации, чтобы в случае какой-нибудь неучтенной
ошибки корректно завершить приложение. Для этого применяется так
называемый обработчик по умолчанию. Он записывается в секции except
после всех операторов on и начинается словом else:
try
{ вычисления с вещественными числами }
except
on EZeroDivide do { обработка ошибки деления на нуль };
on EMathError do { обработка других ошибок вещественной
математики };
else { обработка всех остальных ошибок (обработчик по
умолчанию) };
end;
Учтите, что отсутствие части else соответствует записи else raise,
поэтому выражение else raise лишено смысла. Мы со своей стороны
вообще не советуем вам пользоваться обработкой исключительных
ситуаций по умолчанию, поскольку все ваши Delphi -приложения будут
строиться на основе библиотеки VCL, в которой обработка по умолчанию
уже предусмотрена.
11.4.3.2.1
Пример
обработки
исключительной
ситуации
В качестве примера обработки исключительной ситуации рассмотрим
две функции: StrToPercent и IncPercentStr. Первая функция выполняет
преобразование строки, содержащей значение процента, в целое число.
Если число не попадает в диапазон от 0 до 100, функция генерирует
исключительную ситуацию класса EConvertError.
function StrToPercent (const S : string): Integer;
begin
195
Result:=StrToInt(S);
if (Result<0) or (Result>100) then
raise EConvertError.Create(S+'is not a valid percent value');e
end;
Вторая функция IncPercentStr увеличивает строковое значение процента
и возвращает результат в виде строки.
function IncPercentStr(const S:string):string;
begin
try
Result:=IntToStr(StrToPercent(S)+1);
except
on EConvertError do Result:='0';
end;
end;
Для преобразования исходной строки в процент используется
определенная выше функция StrToPercent, а для преобразования
увеличенного на единицу процента в строку - стандартная функция
IntToStr. Если при операциях конвертирования происходит ошибка, то она
“поглощается” функцией IncPercentStr, которая в этом случае возвращает
строку '0'. Если происходит какая-нибудь другая ошибка (не
EConvertError), то управление передается внешнему блоку обработки
исключительных ситуаций, из которого была вызвана функция
IncPercentStr.
Пример очень прост, но хорошо демонстрирует преимущества
исключительных ситуаций перед традиционной обработкой ошибок.
Представьте более сложные вычисления, состояшие из множества
операторов, в каждом из которых может произойти ошибка. Насколько
сложной окажется обработка ошибок многочисленными операторами if и
насколько простой — оператором try.
11.4.4 Возобновление исключительной ситуации
В тех случаях, когда защищенный блок не может обработать
исключительную ситуацию полностью, он выполняет только свою часть
работы и возобновляет исключительную ситуацию с тем, чтобы ее
обработку продолжил внешний защищенный блок:
try
{ вычисления с вещественными числами }
except
on EZeroDivide do
begin
{ частичная обработка ошибки }
raise; { возобновление исключительной ситуации }
196
end;
end;
Если ни один из внешних защищенных блоков не обработал
исключительную ситуацию, то управление передается стандартному
обработчику исключительной ситуации, завершающему приложение.
11.4.5 Доступ к объекту, описывающему исключительную
ситуацию
При обработке исключительной ситуации бывает нужен доступ к
объекту, описывающему эту ситуацию и содержащему код ошибки,
текстовое описание ошибки и т.д. В этом случае используется расширенная
запись оператора on:
on <идентификатор объекта> : <класс исключительной ситуации>
do <оператор>;
Объект исключительной ситуации нужен, например, для того, чтобы
выдать пользователю сообщение об ошибке:
try
{ защищенные от ошибок операторы }
except
on E:EOutOfMemory do ShowMessage (E.Message);
end;
Переменная Е — это объект исключительной ситуации, ShowMessage
— процедура модуля Dialogs, отображающая на экране небольшое окно с
текстом и кнопкой ОК. Свойство Message типа string определено в классе
Exception, оно содержит текстовое описание ошибки. ”сходное значение
для текста сообщения указывается при конструировании объекта
исключительной ситуации.
Обратите внимание, что после обработки исключительной ситуации
освобождение соответствующего объекта выполняется автоматически, вам
этого делать не надо.
11.4.6 Защита выделенных ресурсов от пропадания
Программы, построенные на механизме исключительных ситуаций,
обязаны придерживаться строгих правил распределения и освобождения
таких ресурсов, как память, объекты, файлы, ресурсы (объекты) Windows.
Представьте ситуацию: подпрограмма распределяет некоторый ресурс,
но исключительная ситуация прерывает ее выполнение, и ресурс остается
неосвобожденным. Такая ошибка может вызвать: пропадание памяти,
файловых дескрипторов, истощение ресурсов Windows и т.д.
Следовательно, ресурсы нуждаются в защите от исключительных
ситуаций. Для этого в Delphi предусмотрен еще один вариант защищенного
блока:
{распределение ресурса }
197
try
{ защищенные операторы, использующие ресурс }
finally
{ освобождение ресурса }
end;
Особенность этого блока состоит в том, что секция finally... end
выполняется всегда, независимо от того, происходит исключительная
ситуация или нет. Если какой-либо оператор секции try... finally генерирует
исключительную ситуацию, то сначала выполняется секция finally... end,
называемая секцией очистки, а затем управление передается внешнему
защищенному блоку. Если все защищенные операторы выполняются без
ошибок, то секция очистки работает в своем нормальном режиме и
управление передается следующему за ней оператору. Обратите внимание,
что секция finally... end не обрабатывает исключительную ситуацию, в ней
нет ни средств ее обнаружения, ни средств доступа к объекту
исключительной ситуации (рис. 11.2).
Блок try ... finally... end обладает еще одной важной особенностью. Если
он помещен в цикл, то вызов из защищенного блока процедуры Вгеаk с
целью преждевременного выхода из цикла или процедуры Continue с
целью перехода на следующую итерацию цикла сначала обеспечивает
выполнение секции finally... end, а затем уже выполняется
соответствующий переход. Это утверждение справедливо также и для
процедуры Exit (выход из подпрограммы).
Как показывает практика, подпрограммы часто распределяют сразу
несколько ресурсов и используют их вместе. В таких случаях применяются
вложенные блоки try ... finally... end.
Нормальный ход вычислений Ход вычислений в случае возникновения
исключительной ситуации
Рис. 11.2
{ распределение первого ресурса }
198
try
............
{ распределение второго ресурса }
try
{ использование обоих ресурсов }
finlly
{ освобождение второго ресурса }
end;
...........
finlly
{ освобождение первого ресурса }
end;
Кроме того, вы успешно можете комбинировать блоки try ... finally...
end и try ... except... end для защиты ресурсов и обработки исключительных
ситуаций.
11.4.7 Параметр визуальной среды “Вгеаk оn ехсерtion”
В визуальной среде Delphi имеется опция, которая влияет на обработку
исключительных ситуаций во время отладки приложения. Найти ее
несложно:
 в главном меню активизируйте команду Тоо1s|Орtions...;
 выберите страницу Ргеfегеnсеs;
 и в секции Debugging увидите опцию Вгеаk оn ехсерtion.
Если опция включена (а по умолчанию — включена), то при
возникновении исключительной ситуации программа, запущенная из
визуальной среды, останавливается на операторе, который ее вызвал, и
строка с оператором выделяется в редакторе кода цветом. Фактически это
вариант известной с древних времен контрольной точки, сделанной
специально для отладки. Вы можете посмотреть значения всех переменных
и все что вас интересует на момент останова. Если ЕХЕ-файл запускается
не из Delphi, а непосредственно из Windows, то опция Вгеаk оn ехсерtion на
процесс выполнения приложения не оказывает вообще никакого влияния.
Иногда при отладке бывает не нужна остановка приложения из-за
исключительной ситуации. Тогда опцию Вгеаk оn ехсерtion отключают и на
экране виден только результат действия операторов обработки
исключительной ситуации.
Напоминаем, что здесь были рассмотрены только ошибки выполнения,
поэтому не забудьте прочитать о борьбе с логическими ошибками.
11.5 ПОРЯДОК ВЫПОЛНЕНИЯ РАБОТЫ.
 Изучить структуру программы в среде языка Object Pascal.
 Изучить основы создания консольных приложений в среде Delphi.
199
 Изучить основные операторы программ языка Object Pascal.
 Ответить на контрольные вопросы.
 Пользуясь своим вариантом задания, создайте консольное приложение.
 Пользуясь средствами Delphi, создайте проект, откомпилируйте его и
проверьте в работе.
 Составить отчет по лабораторной работе.
 В отчет должны входить следующие пункты:
 Цель работы.
 Описание основных разделов структуры программы.
 Описание основных операторов программ языка Object Pascal.
 Описание основ создания консольных приложений в среде Delphi.
 Описание процесса разработки программы по заданному варианту.
 Результаты проверки программы.
 Вывод о проделанной работе.
11.6 КОНТРОЛЬНЫЕ ВОПРОСЫ
 Из каких компонент состоит структура программы в Object Pascal?
 Как записывается заголовок программы?
 Как осуществляется подключение модулей?
 Из каких компонент состоит структура модуля в Object Pascal?
 Назовите основные стандартные модули Object Pascal и их назначение.
 Определите область действия подключаемых модулей и основной
программы.
 Как формируется раздел описания констант?
 Как
формируется
раздел
описания
типов,
определенных
программистом?
 Как формируется раздел описания переменных?
 Как формируется раздел описания процедур?
 Как формируется раздел описания функций?
 Как формируется тело программы?
 Что представляют собой простые операторы?
 Что представляют собой структурные операторы?
 Как записывается оператор присваивания?
 Как записывается оператор вызова процедуры?
 Что представляет собой составной оператор?
 Как записывается и работает оператор if?
 Как записывается и работает оператор case?
 Как записывается и работает оператор for?
 Как записывается и работает оператор repeat?
 Как записывается и работает оператор while?
200
 Как реализуется консольный ввод-вывод данных?
11.7 ВАРИАНТЫ ЗАДАНИЙ.
1. Используя среду визуального программирования, создайте сценарий
и спроектируйте консольное приложение.:
2. Вычисление корней квадратного уравнения вида ax2+bx+c=0.
3. Вычисление синуса по ряду Тейлора вида sin(Pi*x/2)(Pi*x/2)1/3!*(Pi*x/2)3+1/5!(Pi*x/2)5-1/7!* (Pi*x/2)7+1/9!* (Pi*x/2)9 .
4. Вычисление синуса sin(x)=x-x2//3!+x5/5!-x7/7!
5. Вычисление e—x=1-x+x2/2!-x2/3!+x4/4!
6. Вычисление tg(x)x+1/3(x2)+2/15(x5)+17/315(x7).
7. -Более сложные варианты по инициативе обучающихся.
201
ЗАКЛЮЧЕНИЕ
Практикум содержит методические указания, необходимые для
изучения основ визуального и объектно – ориентированного
программирования, предусмотренных при изучении дисциплины
«Алгоритмизация и программирование». Этих основ вполне достаточно
для дальнейшего углубленного изучения более сложных тем,
рассматриваемых
в
других
дисциплинах
–
«Технология
программирования», «Управление данными» и т. п.
Следует также заметить, что использование в практикуме версии 3
Delphi ни в коем случае не препятствует освоению более поздних версий
Delphi, а только помогает этому, т. к. при этом используется принцип «от
простого – к более сложному». Кроме того, следует иметь в виду, что
большинство современных языков программирования имеют в своем
составе средства визуального и объектно – ориентированного
программирования, а язык Pascal первоначально создавался для целей
обучения программированию, и в него была заложена идеология, которая
легко позволила включить в его дальнейшие версии все самые
современные средства, в том числе средства визуального и объектно –
ориентированного программирования. В других языках, например Basic
или С, для этого пришлось проводить концептуальные изменения.
Следует также заметить, что среда программирования Delphi в
настоящее время широко используется в практике создания серьезных
программных проектов.
На основании изложенного авторы планируют продолжить работу в
данном направлении.
202
БИБЛИОГРАФИЧЕСКИЙ СПИСОК.
1. В. В. Фаронов. Delphi 4. Учебный курс. М., Нолидж, 1999.
2. К. Сурков, Д. Сурков, А. Вальвачев. Программирование в среде
Delphi 2.0. Минск, Попурри, 1997.
3.
С.
Янг.
Алгоритмические
языки
реального времени.
Конструирование и разработка. М., Мир, 1985.
4. Б. Лисков, Дж. Гатэг. Использование абстракций и спецификаций
при разработке программ. М., Мир, 1989.
5. Ю. В. Блинков. Прикладное программирование. Современные
технологии. - Учебное пособие. Пенза, ПТИ, 2000
203
ОГЛАВЛЕНИЕ
ПРЕДИСЛОВИЕ
ВВЕДЕНИЕ
1 ИЗУЧЕНИЕ ОСНОВ ВИЗУАЛЬНОГО ПРОГРАММИРОВАНИЯ В
СРЕДЕ DELPHI
6
1.1 Методика выполнения работы
6
1.1.1 Основы визуального программирования
6
1.1.2 Среда визуальной разработки
8
1.1.3 Проектирование простого приложения
14
1.1.4 Компиляция и проверка работоспособности программы 18
1.2 Порядок выполнения работы
19
1.3 Контрольные вопросы
19
1.4 Варианты заданий.
19
1.5 Пояснение к теме. Некоторые стандартные функции для
работы со строками.
20
2 ИЗУЧЕНИЕ СРЕДСТВ УПРАВЛЕНИЯ ПРОЕКТОМ В СРЕДЕ
DELPHI
22
2.1 Методика выполнения работы
22
2.1.1 Структура проекта в Delphi
22
2.1.2 Создание, сохранение и открытие проекта
29
2.1.3 Компиляция и сборка проекта
35
2.1.4 Запуск готового приложения
35
2.2 Порядок выполнения работы
35
2.3 Контрольные вопросы
36
2.4 Варианты заданий
36
3 ИЗУЧЕНИЕ СВОЙСТВ И СОБЫТИЙ ФОРМ ПРИЛОЖЕНИЯ В
СРЕДЕ DELPHI
38
3.1 Методика выполнения работы
38
3.1.1 Понятие формы
38
3.1.2 Основные свойства формы
39
3.1.3 События формы
44
3.1.4 Создание в проекте новой формы
45
3.2 Порядок выполнения работы
51
3.3 Контрольные вопросы
52
3.4 Варианты заданий.
52
4 ИЗУЧЕНИЕ СВОЙСТВ И МЕТОДОВ ИСПОЛЬЗОВАНИЯ
КОМПОНЕНТОВ В СРЕДЕ DELPHI
54
4.1 Методика выполнения работы
54
4.1.1 Понятие компонента
54
4.1.2 Визуальные и невизуальные компоненты
55
4.1.3 Управляющие элементы пользовательского интерфейса 56
4.2 Палитра компонентов.
60
204
4.2.1 Страница Standard
61
4.2.2 Страница Additonal
62
4.2.3 Страница Win32
63
4.2.4 Страница SYSTEM
65
4.2.5 Страница DIALOGS
65
4.2.6 Страница SAMPLES
66
4.3 Управление компонентами при проектировании
67
4.3.1 Размещение компонентов на форме
67
4.3.2 Выбор рабочего компонента формы
67
4.3.3 Перемещение и изменение размеров компонента
69
4.3.4 Выравнивание компонентов на форме
71
4.3.5 Использование Буфера Обмена при работе с компонентами
72
4.4 Порядок выполнения работы.
72
4.5 Контрольные вопросы
73
4.6 Варианты заданий.
73
5 ИЗУЧЕНИЕ СРЕДСТВ СОЗДАНИЯ И ИСПОЛЬЗОВАНИЯ МЕНЮ
В DELPHI - ПРОЕКТАХ
75
5.1 Методика выполнения работы
75
5.1.1 Главное меню
77
5.1.2 Дизайнер меню
78
5.1.3 Пункты меню
81
5.1.4 Разделительные линии
82
5.1.5 Клавиатурные сокращения
83
5.1.6 Обработка команд меню
83
5.1.7 Законченный Редактор текста.
91
5.1.8 Всплывающее меню
93
5.2 Порядок выполнения работы.
95
5.3 Контрольные вопросы
95
5.4 Варианты заданий.
95
6 ИЗУЧЕНИЕ ОСНОВ ПЕЧАТИ ИЗ DELPHI - ПРОГРАММ
97
6.1 Методика выполнения работы
97
6.1.1 Выбор и настройка принтера
98
6.1.2 Установка параметров печати
101
6.1.3 Печать форматированного текста
102
6.1.4 Печать простого текста
105
6.1.5 Печать графики
106
6.2 Порядок выполнения работы.
108
6.3 Контрольные вопросы
109
6.4 Варианты заданий.
109
7 СОЗДАНИЕ СОБСТВЕННЫХ КОМПОНЕНТОВ В СРЕДЕ DELPHI
110
205
7.1 Методика выполнения работы
110
7.1.1 Основные этапы создания компонента
110
7.2 Порядок выполнения работы.
119
7.3 Контрольные вопросы
119
8 ИЗУЧЕНИЕ СРЕДСТВ ОТЛАДКИ ПРОГРАММ В СРЕДЕ DELPHI
120
8.1 Методика выполнения работы
120
8.1.1 Типы ошибок
120
8.1.2 Методика отладки
126
8.1.3 Встроенный отладчик Delphi
127
8.1.4 Отладка без отладчика
136
8.2 Порядок выполнения работы.
136
8.3 Контрольные вопросы
137
9 ТЕМА № 9. ИЗУЧЕНИЕ СТРУКТУРЫ И ПРИНЦИПОВ
ПОСТРОЕНИЯ
ПРИЛОЖЕНИЙ
С
МНОГОДОКУМЕНТАЛЬНЫМ
ИНТЕРФЕЙСОМ MDI
138
9.1 Методика выполнения работы
138
9.1.1 Однодокументные и многодокументные приложения 138
9.1.2 Обрамляющая форма многодокументного приложения 139
9.1.3 Дочерняя форма многодокументного приложения
139
9.1.4 Меню многодокументного приложения
141
9.1.5 Создание дочерних форм
144
9.1.6 Управление дочерними формами
146
9.1.7 Шаблон для многодокументных приложений
148
9.2 Порядок выполнения работы.
149
9.3 Контрольные вопросы
150
9.4 Варианты заданий.
150
10 ИЗУЧЕНИЕ ОСНОВ СОЗДАНИЯ СПРАВОЧНОЙ СИСТЕМЫ
ПРИЛОЖЕНИЯ В DELPHI
151
10.1
Методика выполнения работы
151
10.1.1 Основные принципы создания файлов справки.
152
10.1.2 Программа для создание файлов справочной системы 156
10.1.3 .Использование справочной системы
167
10.2
Порядок выполнения работы.
169
10.3
Контрольные вопросы
170
11 ПРИЛОЖЕНИЕ. СТРУКТУРА ПРОГРАММЫ И КОНСТРУКЦИИ
ЯЗЫКА OBJECT PASCAL
171
11.1
Структура программы
171
11.1.1 Заголовок программы
171
11.1.2 Подключение модулей
172
11.1.3 Программный блок
175
11.1.4 Операторы
179
206
11.1.5 Консольный ввод-вывод
186
11.2
Встроенный ассемблер
188
11.3
Подключение внешних подпрограмм
189
11.4
Исключительные ситуации и надежное программирование
189
11.4.1 Ошибки и исключительные ситуации
189
11.4.2 Классы исключительных ситуаций
190
11.4.3 Обработка исключительных ситуаций
193
11.4.4 Возобновление исключительной ситуации
196
11.4.5 Доступ к объекту, описывающему исключительную
ситуацию
197
11.4.6 Защита выделенных ресурсов от пропадания
197
11.4.7 Параметр визуальной среды “Вгеаk оn ехсерtion”
199
11.5
Порядок выполнения работы.
199
11.6
Контрольные вопросы
200
11.7
Варианты заданий.
201
ЗАКЛЮЧЕНИЕ
202
БИБЛИОГРАФИЧЕСКИЙ СПИСОК.
203
207
Учебное издание
Блинков Юрий Вадимович
Былкин Владимир Дмитриевич
ИЗУЧЕНИЕ СРЕДСТВ СОЗДАНИЯ ПРОГРАММ В СРЕДЕ «DELPHI»
Практикум
Редактор
Верстка
В.С.Кулакова
Н.А.Сазонова
________________________________________________________________
Подписано в печать 15.09.07. Формат 60x84/16.
Бумага офсетная. Печать на ризографе.
Усл.печ.л. 12,09. Уч.-изд. л. 13. Тираж 80 экз.
Заказ №147
________________________________________________________________
Издательство ПГУАС.
Отпечатано в полиграфическом центре ПГУАС.
440028, г.Пенэа, ул. Г.Титова, 28.
208