о том, что лучше один
Borland Delphi
или о том, что лучше один раз увидеть, чем сто раз услышать.
Допускаю, что вы пока еще не слышали этого названия. Хотя, быть может, и слышали. Delphi - это греческий город, где жил дельфийский оракул. И этим именем был назван новый программный продукт с феноменальными характеристиками. Шесть месяцев назад компания Borland представила на суд программистской общественности новый программный продукт, о котором к моменту его выхода ходило множество слухов. Первая версия продукта явилась результатом разработки, которая велась компанией в обстановке строжайшей секретности в течение двух с половиной лет.
Hадо отметить, что к моменту выхода продукта обстановка вокруг компании Borland складывалась не лучшим для нее образом. Поговаривали о возможной перепродаже компании, курс акций компании неудержимо катился вниз. Сейчас, по прошествии полугода, уже можно без всяких сомнений утверждать, что период трудностей позади (даже несмотря на то, что российская пресса нет-нет, да и вынет на свет божий залежалый перевод статьи полугодовой давности). Hеверно, конечно, было бы говорить, что только Delphi явился причиной восстановления компании; кроме Delphi, у Borland появились и другие замечательные продукты, так же, как и Delphi, основывающиеся на новых, появившихся недавно у компании Borland, технологиях. Я имею в виду новые BDE 2.0, BC++ 4.5, Paradox for Windows 5.0, dBase for Windows 5.0, BC++ 2.0 for OS/2.
Тем не менее, именно Delphi стал тем продуктом, на примере которого стало ясно, что у Borland есть еще порох в пороховницах, и что один единственный продукт может настолько удачно сочетать несколько передовых технологий.
Delphi. Основные характеристики продукта.
Delphi - это комбинация нескольких важнейших технологий: Высокопроизводительный компилятор в машинный код Объектно-ориентированная модель компонент Визуальное (а, следовательно, и скоростное) построение приложений из программных прототипов
Масштабируемые средства для построения баз данных
Компилятор в машинный код Компилятор, встроенный в Delphi, обеспечивает высокую производительность, необходимую для построения приложений в архитектуре “клиент-сервер”. Этот компилятор в настоящее время является самым быстрым в мире, его скорость компиляции составляет свыше 120 тысяч строк в минуту на компьютере 486DX33. Он предлагает легкость разработки и быстрое время проверки готового программного блока, характерного для языков четвертого поколения (4GL) и в то же время обеспечивает качество кода, характерного для компилятора 3GL. Кроме того, Delphi обеспечивает быструю разработку без необходимости писать вставки на Си или ручного написания кода (хотя это возможно).
В процессе построения приложения разработчик выбирает из палитры компонент готовые компоненты как художник, делающий крупные мазки кистью. Еще до компиляции он видит результаты своей работы - после подключения к источнику данных их можно видеть отображенными на форме, можно перемещаться по данным, представлять их в том или ином виде. В этом смысле проектирование в Delphi мало чем отличается от проектирования в интерпретирующей среде, однако после выполнения компиляции мы получаем код, который исполняется в 10-20 раз быстрее, чем то же самое, сделанное при помощи интерпретатора. Кроме того, компилятор компилятору рознь, в Delphi компиляция производится непосредственно в родной машинный код, в то время как существуют компиляторы, превращающие программу в так называемый p-код, который затем интерпретируется виртуальной p-машиной. Это не может не сказаться на фактическом быстродействии готового приложения.
Объектно-ориентированная модель программных компонент
Основной упор этой модели в Delphi делается на максимальном реиспользовании кода. Это позволяет разработчикам строить приложения весьма быстро из заранее подготовленных объектов, а также дает им возможность создавать свои собственные объекты для среды Delphi. Никаких ограничений по типам объектов, которые могут создавать разработчики, не существует. Действительно, все в Delphi
написано на нем же, поэтому разработчики имеют доступ к тем же объектам и инструментам, которые использовались для создания среды разработки. В результате нет никакой разницы между объектами, поставляемыми Borland или третьими фирмами, и объектами, которые вы можете создать. В стандартную поставку Delphi входят основные объекты, которые образуют удачно подобранную иерархию из 270 базовых классов. Для начала - неплохо. Но если возникнет необходимость в решении какой-то специфической проблемы на Delphi, советуем, прежде чем попытаться начинать решать проблему “с нуля”, просмотреть список свободно распространяемых или коммерческих компонент, разработанных третьими фирмами, количество этих фирм в настоящее время превышает число 250, хотя, возможно, я не обо всех знаю. Скептики, возможно, не поверят мне, когда я скажу, что на Delphi можно одинаково хорошо писать как приложения к корпоративным базам данных, так и, к примеру, игровые программы. Тем не менее, это так. Во многом это объясняется тем, что традиционно в среде Windows было достаточно сложно реализовывать пользовательский интерфейс. Событийная модель в Windows всегда была сложна для понимания и отладки. Но именно разработка интерфейса в Delphi является самой простой задачей для программиста.
Быстрая разработка работающего приложения из прототипов
Игровая программа Rendzu была собрана моим коллегой из готовых кусков за рабочий день, причем большая часть времени была посвящена прихорашиванию и приукрашиванию. Screen Saver в виде прыгающих часиков был также изготовлен на Delphi за весьма незначительное время. Теперь эти часики украшают почти каждую IBM-совместимую машину в нашем Демо-центре клиент-серверных технологий. Конечно, на разработку серьезной информационно-поисковой системы в архитектуре клиент-сервер может уйти гораздо большее время, чем на разработку программы-игрушки. Тем не менее многие наши коллеги, до Delphi программировавшие на других языках, утверждают, что на Delphi скорость изготовления сложного проекта выше раз в 10.
Соответствующий стандарт компонент назывался VBX. И этот стандарт так же поддерживается в Delphi. Однако, визуальные компоненты в Delphi обладают большей гибкостью. Вспомним, в чем была проблема в VB. Прикладной программист программировал, вообще говоря, в среде языка бэйсик. А компоненты в стандарте VBX готовили ему его коллеги-профессионалы на С++.
VBX’ы приходили, “как есть”, и ни исправить, ни добавить ничего было нельзя.
А для изготовления VBX надо было осваивать “кухню” языка C++. В Delphi визуальные компоненты пишутся на объектном паскале, на том же паскале, на котором пишется алгоритмическая часть приложения. И визуальные компоненты Delphi получаются открытыми для надстройки и переписывания. Чувствуете разницу?
Масштабируемые средства для построения баз данных
Объекты БД в Delphi основаны на SQL и включают в себя полную мощь Borland Database Engine. В состав Delphi также включен Borland SQL Link, поэтому доступ к СУБД Oracle, Sybase, Informix и InterBase происходит с высокой эффективностью. Кроме того, Delphi включает в себя локальный сервер Interbase для того, чтобы можно было разработать расширяемые на любые внешние SQL-сервера приложения в офлайновом режиме. Разработчик в среде Delphi, проектирующий информационную систему для локальной машины (к примеру, небольшую систему учета медицинских карточек для одного компьютера), может использовать для хранения информации файлы формата .dbf (как в dBase или Clipper) или .db
(Paradox). Если же он будет использовать локальный InterBase for Windows 4.0 (это локальный SQL-сервер, входящий в поставку), то его приложение безо всяких изменений будет работать и в составе большой системы с архитектурой клиент-сервер. Вот она - масштабируемость на практике - одно и то же приложение можно использовать как для локального, так и для более серьезного клиент-серверного вариантов.
Delphi - два варианта поставки
Я уже упомянул о технологиях, которые объединяет Delphi. Теперь можно перейти к описанию собственно продукта. Что лежит внутри в коробке, и чем может воспользоваться программист при разработке прикладной системы? Выпущены две версии Delphi - одна (Delphi Client-Server) адресована для разработчиков приложений в архитектуре “клиент-сервер”, а другая (Delphi for Windows) предназначена для остальных программистов. Приложения, разработанные при помощи Delphi, можно использовать без выплаты royalty-процентов и без оплаты runtime- лицензий.
Клиент-серверная версия Delphi
Она адресована корпоративным разработчикам, желающим разрабатывать высокопроизводительные приложения для рабочих групп и корпоративного применения.
Клиент-серверная версия включает в себя следующие особенности: SQL Links: специально написанные драйвера для доступа к Oracle, Sybase, Informix, InterBase Локальный сервер InterBase: SQL-сервер для Windows 3.1. СУБД для разработки в корпоративных приложений на компьютере, не подключенном к локальной сети. ReportSmith Client/server Edition: генератор отчетов для SQL-серверов Team Development Support: предоставляет версионный контроль при помощи PVCS компании Intersolve (приобретается отдельно) или при помощи других программных продуктов версионного контроля Visual Query Builder - это средство визуального построения SQL-запросов лицензия на право распространения приложений в архитектуре клиент-сервер, изготовленных при помощи Delphi исходные тексты всех визуальных компонент Delphi for Windows
Delphi for Windows представляет из себя подмножество Delphi
Client-Server и предназначен для разработчиков высокопроизводительных персональных приложений, работающих с локальными СУБД типа dBase и Paradox.Delphi Desktop Edition предлагает такую же среду для быстрой разработки и первоклассный компилятор как и клиент-серверная версия (Client/Server Edition). Эта среда позволяет разработчику быстро изготавливать персональные приложения, работающие с персональными СУБД типа dBase и Paradox. Delphi позволяет также создавать разработчику DLL, которая может быть вызвана из Paradox, dBase, C++ или каких-нибудь других готовых программ. В Delphi for Windows, как и в Delphi Client-Server, входят компилятор Object Pascal (этот язык является расширением языка Borland Pascal 7.0) генератор отчетов ReportSmith 2.5 (у которого, правда, отсутствует возможность работы с SQL-серверами) среда визуального построителя приложений библиотека визуальных компонент Локальный сервер InterBase RAD Pack for Delphi
В этом обзоре стоит упомянуть еще один продукт, выпущенный компанией Borland для Delphi. В RAD Pack for Delphi входит набор полезных дополнений, которые помогут разработчику при освоении и использовании Delphi. Это учебник по объектному паскалю, интерактивный отладчик самой последней версии, Borland Visual Solutions Pack (набор VBX для реализации редакторов, электронных таблиц, коммуникационные VBX, VBX с деловой графикой и т.п.), Resource WorkShop для работы с ресурсами Borland Pascal 7.0, а также дельфийский эксперт для преобразования ресурсов BP 7.0 в формы Delphi.
Для кого предназначен Delphi
В первую очередь Delphi предназначен для профессионалов-разработчиков корпоративных информационных систем. Может быть, здесь следует пояснить, что конкретно имеется в виду. Не секрет, что некоторые удачные продукты, предназначенные для скоростной разработки приложений (RAD - rapid application development) прекрасно работают при изготовлении достаточно простых приложений, однако, разработчик сталкивается с непредвиденными сложностями, когда пытается сделать что-то действительно сложное. Бывает, что в продукте вскрываются присущие ему ограничения только по прошествии некоторого времени.
Delphi такие ограничения не присущи. Хорошее доказательство тому - это тот факт, что сам Delphi разработан на Delphi. Можете делать выводы. Однако Delphi предназначен не только для программистов-профессионалов. Я читал в электронной конференции совершенно неожиданные для меня письма, где учителя, врачи, преподаватели ВУЗов, бизнесмены, все те, кто используют компьютер с чисто прикладной целью, рассказывали о том, что приобрели Delphi for Windows для того, чтобы быстро решить какие-то свои задачи, не привлекая для этого программистов со стороны. В большинстве случаев им это удается. Поразительный факт - журнал Visual Basic Magazine присудил свою премию Delphi for Windows.
Руководители предприятий, планирующие выделение средств на приобретение программных продуктов, должны быть уверены в том, что планируемые инвестиции окупятся. Поэтому одним из оцениваемых факторов должен быть вопрос - а легко ли найти специалиста по Delphi и сколько будет стоить его обучение, сколько времени специалист затратит на овладение продуктом. Ответ здесь получить весьма просто - любой программист на паскале способен практически сразу профессионально освоить Delphi. Специалисту, ранее использовавшему другие программные продукты, придется труднее, однако самое первое работающее приложение он сможет написать в течение первого же часа работы на Delphi. И, конечно же, открытая технология Delphi является мощным гарантом того, что инвестици, сделанные в Delphi, будут сохранены в течение многих лет.
Некоторые особенности Delphi
Локальный сервер InterBase - следует заметить, что этот инструмент предназначен только для автономной отладки приложений. В действительности он представляет из себя сокращенный вариант обработчика SQL-запросов InterBase, в который не включены некоторые возможности настоящего сервера InterBase. Отсутствие этих возможностей с лихвой компенсируется преимуществом автономной отладки программ.
Team Development Support - средство поддержки разработки проекта в группе. Позволяет существенно облегчить управление крупными проектами. Это сделано в виде возможности подключения такого продукта как Intersolve PVCS 5.1 непосредственно к среде Delphi.
Высокопроизводительный компилятор в машинный код - в отличие от большинства Паскаль-компиляторов, транслирующих в p-код, в Delphi программный текст компилируется непосредственно в машинный код, в результате чего Delphi- приложения исполняются в 10-20 раз быстрее (особенно приложения, использующие математические функции). Готовое приложение может быть изготовлено либо в виде исполняемого модуля, либо в виде динамической библиотеки, которую можно использовать в приложениях, написанных на других языках программирования.
Открытая компонентная архитектура
Благодаря такой архитектуре приложения, изготовленные при помощи Delphi, работают надежно и устойчиво. Delphi поддерживает использование уже существующих объектов, включая DLL, написанные на С и С++, OLE сервера, VBX, объекты, созданные при помощи Delphi. Из готовых компонент работающие приложения собираются очень быстро. Кроме того, поскольку Delphi имеет полностью объектную ориентацию, разработчики могут создавать свои повторно используемые объекты для того, чтобы уменьшить затараты на разработку.
Delphi предлагает разработчикам - как в составе команды, так и индивидуальным - открытую архитектуру, позволяющую добавлять компоненты, где бы они ни были изготовлены, и оперировать этими вновь введенными компонентами в визуальном построителе. Разработчики могут добавлять CASE-инструменты, кодовые генераторы, а также авторские help’ы, доступные через меню Delphi.
Two-way tools - однозначное соответствие между визуальным проектированием и классическим написанием текста программы Это означает, что разработчик всегда может видеть код, соответствующий тому, что он построил при помощи визуальных инструментов и наоборот.
Визуальный построитель интерфейсов (Visual User-interface builder) дает возможность быстро создавать клиент-серверные приложения визуально, просто выбирая компоненты из соответствующей палитры.
Библиотека визуальных компонент
Эта библиотека объектов включает в себя стандартные объекты построения пользовательского интерфейса, объекты управления данными, графические объекты, объекты мультимедиа, диалоги и объекты управления файлами, управление DDE и OLE.
Структурное объектно-ориентированное программирование
Delphi использует структурный объектно-ориентированный язык (Object Pascal), который сочетает с одной стороны выразительную мощь и простоту программирования, характерную для языков 4GL, а с другой стороны эффективность языка 3GL. Программисты немедленно могут начать производить работающие приложения, и им не придется для этого изучать особенности программирования событий в Windows. Delphi полностью поддерживает передовые программные концепции включая инкапсуляцию, наследование, полиморфизм и управление событиями.
Поддержка OLE 2.0, DDE и VBX
Это очень важная особенность для разработчиков в среде Windows, поскольку в уже существующие Windows-приложения программист может интегрировать то, что разработает при помощи Delphi.
Delphi: настраиваемая cреда разработчика
После запуска Delphi в верхнем окне горизонтально располагаются иконки палитры компонент. Если курсор задерживается на одной из иконок, под ней в желтом прямоугольнике появляется подсказка
Из этой палитры компонент вы можете выбирать компоненты, из которых можно строить приложения. Компоненты включают в себя как визуальные, так и логические компоненты. Такие вещи, как кнопки, поля редактирования - это визуальные компоненты; а таблицы, отчеты - это логические.
Понятно, что поскольку в Delphi вы визуальным образом строите свою программу, все эти компоненты имеют свое графическое представление в поле форм для того, чтобы можно было бы ими соответствующим образом оперировать. Но для работающей программы видимыми остаются только визуальные компоненты. Компоненты сгруппированы на страницах палитры по своим функциям. К примеру, компоненты, представляющие Windows “common dialogs” все размещены на странице палитры с названием “Dialogs”.
Delphi позволяет разработчикам настроить среду для максимального удобства. Вы можете легко изменить палитру компонент, инструментальную линейку, а также настраивать выделение синтаксиса цветом.
Заметим, что в Delphi вы можете определить свою группу компонент и разместить ее на странице палитры, а если возникнет необходимость, перегруппировать компоненты или удалить неиспользуемые.
Интеллектуальный редактор
Редактирование программ можно осуществлять, используя запись и исполнение макросов, работу с текстовыми блоками, настраиваемые комбинации клавиш и цветовое выделение строк .
Графический отладчик
Delphi обладает мощнейшим, встроенным в редактор графическим отладчиком, позволяющим находить и устранять ошибки в коде. Вы можете установить точки останова, проверить и изменить переменные, при помощи пошагового выполнения в точности понять поведение программы. Если же требуются возможности более тонкой отладки, Вы можете использовать отдельно доступный Turbo Debugger, проверив ассемблерные инструкции и регистры процессора.
Инспектор объектов
Этот инструмент представляет из себя отдельное окно, где вы можете в период проектирования программы устанавливать значения свойств и событий объектов (Properties & Events).
Менеджер проектов.
Дает возможность разработчику просмотреть все модули в соответствующем проекте и снабжает удобным механизмом для управления проектами.
Менеджер проектов показывает имена файлов, время/дату выбранных форм и пр.
Можно немедленно попась в текст или форму, просто щелкнув мышкой на соответствующее имя.
Навигатор объектов
Показывает библиотеку доступных объектов и осуществляет навигацию по вашему приложению. Можно посмотреть иерархию объектов, прекомпилированные модули в библиотеке, список глобальных имен вашего кода.
Дизайнер меню
Можно создавать меню, сохранить созданные в виде шаблонов и затем использовать в их в любом приложении.
Эксперты
Это набор инструментальных программ, облегчающих проектирование и настройку Ваших приложений.
Есть возможность подключать самостоятельно разработанные эксперты. Потенциально это та возможность, при помощи которой третьи фирмы могут расширять Delphi CASE-инструментами, разработанными специально для Delphi.
Включает в себя: Эксперт форм, работающих с базами данных Эксперт стилей и шаблонов приложений Эксперт шаблонов форм В состав RAD Pack входит эксперт для преобразования ресурсов, изготовленных в Borland Pascal 7.0, в формы Delphi. Уже появились эксперты, облегчающие построение DLL и даже написание собственных экспертов
Интерактивная обучающая система
Позволяет более полно освоить Delphi. Она являются не просто системой подсказок, а показывает возможности Delphi на самой среде разработчика.
Компоненты доступа к базам данных и визуализации данных
Библиотека объектов содержит набор визуальных компонент, значительно упрощающих разработку приложений для СУБД с архитектурой клиент-сервер. Объекты инкапсулируют в себя нижний уровень - Borland Database Engine.
Предусмотрены специальные наборы компонент, отвечающих за доступ к данным, и компонент, отображающих данные. Компоненты доступа к данным позволяют осуществлять соединения с БД, производить выборку, копирование данных, и т.п.
Компоненты визуализации данных позволяют отображать данные виде таблиц, полей, списков. Отображаемые данные могут быть текстового, графического или произвольного формата.
Разработка приложений БД
Delphi позволяет использовать библиотеку визуальных компонент для быстрого создания надежных приложений, которые легко расширяются до приложений с архитектурой клиент-сервер. Другими словами, Вы можете создать приложение, работающее с локальным сервером InterBase, а затем использовать созданное приложение, соединяясь с удаленным SQL-сервером через SQL-Links.
Библиотека объектных Визуальных Компонент
Компоненты, используемые при разработке в Delphi (и также собственно самим Delphi), встроены в среду разработки приложений и представляют из себя набор типов объектов, используемых в качестве фундамента при строительстве приложения.
Этот костяк называется Visual Component Library (VCL). В VCL есть такие стандартные элементы управления, как строки редактирования, статические элементы управления, строки редактирования со списками, списки объектов.
Еще имеются такие компоненты, которые ранее были доступны только в библиотеках третьих фирм: табличные элементы управления, закладки, многостраничные записные книжки.
VCL содержит специальный объект, предоставлющий интерфейс графических устройств Windows, и позволяющий разработчикам рисовать, не заботясь об обычных для программирования в среде Windows деталях.
Ключевой особенностью Delphi является возможность не только использовать визуальные компоненты для строительства приложений, но и создание новых компонент. Такая возможность позволяет разработчикам не переходить в другую среду разработки, а наоборот, встраивать новые инструменты в существующую среду. Кроме того, можно улучшить или полностью заменить существующие по умолчанию в Delphi компоненты.
Здесь следует отметить, что обычных ограничений, присущих средам визуальной разработки, в Delphi нет. Сам Delphi написан при помощи Delphi, что говорит об отсутствии таких ограничений.
Классы объектов построены в виде иерархии, состоящей из абстрактных, промежуточных, и готовых компонент. Разработчик может пользоваться готовыми компонентами, создавать собственные на основе абстрактных или промежуточных, а также создавать собственные объекты.
Язык программирования Delphi базируется на Borland Object Pascal.
Кроме того, Delphi поддерживает такие низкоуровневые особенности, как подклассы элементов управления Windows, перекрытие цикла обработки сообщений Windows, использование встроенного ассемблера.
Формы, модули и метод разработки “Two-Way Tools”
Формы - это объекты, в которые вы помещаете другие объекты для создания пользовательского интерфейса вашего приложения. Модули состоят из кода, который реализует функционирование вашего приложения, обработчики событий для форм и их компонент.
Информация о формах хранится в двух типах файлов - .dfm и .pas, причем первый тип файла - двоичный - хранит образ формы и ее свойства, второй тип описывает функционирование обработчиков событий и поведение компонент. Оба файла автоматически синхронизируются Delphi, так что если добавить новую форму в ваш проект, связанный с ним файл .pas
автоматически будет создан, и его имя будет добавлено в проект. Такая синхронизация и делает Delphi two-way-инструментом, обеспечивая полное соответствие между кодом и визуальным представлением. Как только вы добавите новый объект или код, Delphi устанавливает т.н. “кодовую синхронизацию” между визуальными элементами и соответствующими им кодовыми представлениями.
Например, предположим, вы добавили описание поведения формы (соотв. обработчик событий), чтобы показывать окно сообщения по нажатию кнопки. Такое описание появляется, если дважды щелкнуть мышкой непосредственно на оъект Button в форме или дважды щелкнуть мышью на строчку OnClick на странице Events в Инспекторе объектов. В любом случае Delphi создаст процедуру или заголовок метода, куда вы можете добавить код.
procedure TForm1.Button1Click(Sender: TObject);
begin
end;
Cоздавая этот код, Delphi автоматически формирует декларацию объекта TForm1, которая содержит процедуру ButtonClick, представляющую из себя собственно обработчик события.
TForm1 = class (TForm)
Button1: Tbutton;
procedure Button1Click(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;
Конечно вы запросто можете решить после получения этого кода, что автоматически созданные имена Вас не устраивают, и заменить их. Например, Button1 на Warning. Это можно сделать изменив свойство Name для Button1 при помощи Инспектора объектов. Как только вы нажмете Enter, Delphi автоматически произведет соответствующую синхронизацию в коде. Так как объект TForm1 существует в коде, вы свободно можете добавлять любые другие поля, процедуры, функции или object definition. К примеру, вы можете дописать в коде свою собственную процедуру, обрабатывающую событие, а не делать это визуальным методом.
Следующий пример показывает, как это можно сделать. Обработчик принимает аргумент типа TObject, который позволяет нам определить, если необходимо, кто инициировал событие. Это полезно в случае, когда несколько кнопок вызывают общую процедуру для обработки.
TForm1 = class(TForm)
Warning: TButton;
Button1: TButton;
procedure WarningClick(Sender: TObject);
procedure NewHandler(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;
Здесь мы имеем дело уже с второй стороной синхронизации. Визуальная среда в данном случае распознает, что новая процедура добавлена к объекту и соответствующие имена появляются в Инспекторе объектов.
Добавление новых объектов
Delphi - это прежде всего среда разработки, базирующаяся на использовании компонент. Поэтому вы можете добавлять совершенно новые компоненты в палитру компонент. Вы можете создавать компоненты внутри Delphi, или вводить компоненты, созданные как управляющие элементы VBX или OLE 2.0, или же вы можете использовать компоненты, написанные на С или С++ в виде dll.
Последовательность введения новой компоненты состоит из трех шагов: наследование из уже существующего типа компоненты определение новых полей, свойств и методов регистрация компоненты Это все делается через меню Install Components
Добавление управляющих элементов VBX
Delphi генерирует объектное расширение VBX, которое инсталлируется в качестве компонент.
Например, если вы инсталлируете SaxComm VBX из Visual Solutions Pack компании Borland в Delphi, автоматически генерится тип объекта TComm, который наследуется из стандартного TVBXControl. Когда вы инсталлируете компоненты, Delphi будет компилировать и подлинковывать их к библиотеке компонент.
Делегирование: события программируются проще
Под делегированием понимается то, что некий объект может предоставить другому объекту отвечать на некоторые события.
Такая модель в некоторых случаях значительно упрощает программирование. Например, вместо того чтобы создавать подкласс для Windows controls при добавлении нового поведения, вы можете просто привязать процедуру обработки события, которая будет вызываться автоматически на каждый щелчок мышью пользователем или нажатие им клавиши. Аналогично вы можете написать процедуру определения допустимости таблицы, которая будет выполняться обработчиком события, когда транзакция начинается или завершается, записи вставляются, удаляются или изменяются.
К примеру, когда вы добавляете кнопку в форму и прикрепляете код, обрабатывающий нажатие, вы фактически используете делегирование кода для ассоциирования кода с событием OnClick. Такая ассоциация происходит для вас автоматически. Если проверить страницу Events в Инспекторе объектов для вашего приложения, можно увидеть ассоциированные с событиями процедуры.
Ссылки на классы
Ссылки на классы придают дополнительный уровень гибкости, так, когда вы хотите динамически создавать объекты, чьи типы могут быть известны только во время выполнения кода. К примеру, ссылки на классы используются при формировании пользователем документа из разного типа объектов, где пользователь набирает нужные объекты из меню или палитры. Собственно, эта технология использовалась и при построении Delphi.
Обработка исключительных ситуаций
Серьезные приложения должны надежным образом обрабатывать исключительные ситуации, сохранять, если возможно, выполнение программы или, если это невозможно, аккуратно ее завершать. Написание кода, обрабатывающего исключительные ситуации, всегда было непростой задачей, и являлось источником дополнительных ошибок.
В Delphi это устроено в стиле С++. Исключения представлены в виде объектов, содержащих специфическую информацию о соответствующей ошибке (тип и место- нахождение ошибки). Разработчик может оставить обработку ошибки, существо-вавшую по умолчанию, или написать свой собственный обработчик.
Обработка исключений реализована в виде exception-handling blocks (также еще называется protected blocks), которые устанавливаются ключевыми словами try и end. Существуют два типа таких блоков: try...except и try...finally.
Общая конструкция выглядит примерно так:
try
{ выполняемые операторы }
except
on exception1 do statement1; { реакция на ситуации }
on exception2 do statement2;
else
{ операторы по умолчанию }
end;
Конструкция try....finally предназначена для того, чтобы разработчик мог быть полностью уверен в том, что, что бы ни случилось, перед обработкой исключительной ситуации всегда будет выполнен некоторый код (например, освобождение ресурсов).
try
{ выполняемые операторы }
finally
{ операторы, выполняемые безусловно }
end;
Немного о составе продукта
Документация. Руководство пользователя Руководство по написанию компонент Построение приложений, работающих с базами данных Руководство по генератору отчетов ReportSmith Руководство по SQL Links В составе Delphi входит 5 интерактивных обучающих систем, документация в электронном виде и около 10 Мб справочной информации.
Требования к аппаратным и программным средствам Windows 3.1 и выше 27 Mb дискового пространства для минимальной конфигурации 50 Mb дискового пространства для нормальной конфигурации процессор 80386, а лучше 80486 6-8 Mb RAM Заключение
В данной статье описаны возможности нового программного продукта компании Borland, а также некоторые особенности проектирования приложений с его помощью. В мире уже многие разработчики твердо ориентируются на использование Delphi как на инструмент, позволяющий создавать высокоэффективные клиент-серверные приложения. Более того, список готовых профессионально выполненных приложений настолько велик, что не позволяет полностью привести его в статье. Диапазон разработанных при помощи Delphi программных продуктов также поражает - от игровых программ до мощнейших банковских систем. Прошло всего полгода - и столько результатов. Delphi как продукт имеет версию 1.0, мы уже имеем сведения о том, что предполагается реализовать в следующей версии Delphi, и поскольку Delphi разрабатывается на Delphi, можем быть уверены, что разработка новой версии ведется действительно скоростными методами.
В данной статье дается обзор
Содержание урока 2:
Обзор
Требования к аппаратным и программным средствам
Общая структура Среды Delphi
Основные элементы
Дополнительные элементы
Инструментальные средства
Стандартные компоненты
Инспектор объектов
Сохранение проекта
TButton, исходный текст, заголовки и Z-упорядочивание
Тьюторы ОБЗОР В данной статье дается обзор среды программирования Delphi. Обсуждаются главные части рабочей среды и охватываются такие важные вопросы как требования к системным ресурсам и основные части программы, созданной в Delphi. В конце статьи можно найти короткое обсуждение тьюторов. Данная статья предполагает наличие знаний о: Использовании Windows Простейших программных конструкциях таких, как переменные, циклы и функции Требования к системным и программным ресурсам
Delphi это высокопроизводительный инструмент создания приложений. Текущая версия является 16-разрядным компилятором для создания программ, работающих в среде Windows 3.1. Delphi 2.0, которая появится в начале 1996 года, будет включать полный 32-разрядный компилятор для использования в Windows 95 или в Windows NT.
Для запуска Delphi требуется 386 компьютер с 4MB памяти. Более подходящей машиной будет 486DX 66MHz с 8MB ОЗУ.
Небольшие программы, созданные на Delphi будут работать на любом компьютере. Другими словами, они не требуют того ОЗУ или скорости процессора, что необходимо для среды Delphi. Структура среды программирования
Внешний вид среды программирования Delphi отличается от многих других из тех, что можно увидеть в Windows. К примеру, Borland Pascal for Windows 7.0, Borland C++ 4.0, Word for Windows, Program Manager - это все MDI приложения и выглядят по-другому, чем Delphi. MDI (Multiple Document Interface) - определяет особый способ управления нескольких дочерних окон внутри одного большого окна.
Среда Delphi же следует другой спецификации, называемой Single Document Interface (SDI), и состоит из нескольких отдельно расположенных окон. Это было сделано из-за того, что SDI близок к той модели приложений, что используется в Windows 95.
Если Вы используете SDI приложение типа Delphi, то уже знаете, что перед началом работы лучше минимизировать другие приложения, чтобы их окна не загромождали рабочее пространство. Если нужно переключиться на другое приложение, то просто щелкните мышкой на системную кнопку минимизации Delphi. Вместе с главным окном свернутся все остальные окна среды программирования, освободив место для работы других программ. Главные составные части среды программирования Ниже перечислены основные составные части Delphi: Дизайнер Форм (Form Designer) Окно Редактора Исходного Текста (Editor Window) Палитра Компонент (Component Palette) Инспектор Объектов (Object Inspector) Справочник (On-line help) Есть, конечно, и другие важные составляющие Delphi, вроде линейки инструментов, системного меню и многие другие, нужные Вам для точной настройки программы и среды программирования.
Программисты на Delphi проводят большинство времени переключаясь между Дизайнером Форм и Окном Редактора Исходного Текста (которое для краткости называют Редактор). Прежде чем Вы начнете, убедитесь, что можете распознать эти два важных элемента. Дизайнер Форм показан на рис.1, окно Редактора - на рис.2.
Дизайнер Форм в Delphi столь интуитивно понятен и прост в использовании, что создание визуального интерфейса превращается в детскую игру. Дизайнер Форм первоначально состоит из одного пустого окна, которое Вы заполняете всевозможными объектами, выбранными на Палитре Компонент.
Несмотря на всю важность Дизайнера Форм, местом, где программисты проводят основное время является Редактор. Логика является движущей силой программы и Редактор - то место, где Вы ее “кодируете”.
Палитра Компонент (см. рис.3) позволяет Вам выбрать нужные объекты для размещения их на Дизайнере Форм. Для использования Палитры Компонент просто первый раз щелкните мышкой на один из объектов и потом второй раз - на Дизайнере Форм. Выбранный Вами объект появится на проектируемом окне и им можно манипулировать с помощью мыши.
Палитра Компонент использует постраничную группировку объектов. Внизу Палитры находится набор закладок - Standard, Additional, Dialogs и т.д. Если Вы щелкнете мышью на одну из закладок, то Вы можете перейти на следующую страницу Палитры Компонент. Принцип разбиения на страницы широко используется в среде программирования Delphi и его легко можно использовать в своей программе. (На странице Additional есть компоненты для организации страниц с закладками сверху и снизу).
Рис.3: Палитра Компонент - место, где Вы выбираете объекты, которые будут помещены на вашу форму.
Предположим, Вы помещаете компонент TEdit на форму; Вы можете двигать его с места на место. Вы также можете использовать границу, прорисованную вокруг объекта для изменения его размеров. Большинством других компонент можно манипулировать тем же образом. Однако, невидимые во время выполнения программы компоненты (типа TMenu или TDataBase) не меняют своей формы.
Слева от Дизайнера Форм Вы можете видеть Инспектор Объектов (рис.4). Заметьте, что информация в Инспекторе Объектов меняется в зависимости от объекта, выбранного на форме. Важно понять, что каждый компонент является настоящим объектом и Вы можете менять его вид и поведение с помощью Инспектора Объектов.
Инспектор Объектов состоит из двух страниц, каждую из которых можно использовать для определения поведения данного компонента. Первая страница - это список свойств, вторая - список событий. Если нужно изменить что-нибудь, связанное с определенным компонентом, то Вы обычно делаете это в Инспекторе Объектов. К примеру, Вы можете изменить имя и размер компонента TLabel изменяя свойства Caption, Left, Top, Height, и Width.
Вы можете использовать закладки внизу Инспектора Объектов для переключения между страницами свойств и событий. Страница
событий связана с Редактором; если Вы дважды щелкнете мышкой на правую сторону какого-нибудь пункта, то соответствующий данному событию код автоматически запишется в Редактор, сам Редактор немедленно получит фокус, и Вы сразу же имеете возможность добавить код обработчика данного события. Данный аспект среды программирования Delphi будет еще обсуждаться позднее.
Последняя важная часть среды Delphi - Справочник (on-line help). Для доступа к этому инструменту нужно просто выбрать в системном меню пункт Help и затем Contents. На экране появится Справочник, показанный на рис.5
Рис.5: Справочник - быстрый поиск любой информации.
Справочник является контекстно-зависимым; при нажатии клавиши F1, Вы получите подсказку, соответствующую текущей ситуации. Например, находясь в Инспекторе Объектов, выберите какое-нибудь свойство и нажмите F1 - Вы получите справку о назначении данного свойства. Если в любой момент работы в среде Delphi возникает неясность или затруднение - жмите F1 и необходимая информация появится на экране. Дополнительные элементы В данном разделе внимание фокусируется на трех инструментах, которые можно воспринимать как вспомогательные для среды программирования: Меню (Menu System) Панель с кнопками для быстрого доступа (SpeedBar) Редактор картинок (Image Editor) Меню предоставляет быстрый и гибкий интерфейс к среде Delphi, потому что может управляться по набору “горячих клавиш”. Это удобно еще и потому, что здесь используются слова или короткие фразы, более точные и понятные, нежели иконки или пиктограммы. Вы можете использовать меню для выполнения широкого круга задач; скорее всего, для наиболее общих задач вроде открытия и закрытия файлов, управления отладчиком или настройкой среды программирования.
SpeedBar находится непосредственно под меню, слева от Палитры Компонент (рис.6). SpeedBar выполняет много из того, что можно сделать через меню. Если задержать мышь над любой из иконок на SpeedBar, то Вы увидите что появится подсказка, объясняющая назначение данной иконки.
Рис.6: SpeedBar находится слева от Палитры Компонент.
Редактор Картинок, показанный на рис.7, работает аналогично программе Paintbrush из Windows. Вы можете получить доступ к этому модулю выбрав пункт меню Tools | Image Editor.
Рис.7: Редактор Картинок можно использовать для создания картинок для кнопок, иконок и др. визуальных частей для программы.
А теперь нужно рассмотреть те элементы, которые программист на Delphi использует в повседневной жизни. Инструментальные средства
В дополнение к инструментам, обсуждавшимся выше, существуют пять средств, поставляемых вместе с Delphi. Эти инструментальные средства:
·Встроенный отладчик
·Внешний отладчик (поставляется отдельно)
·Компилятор командной строки
· WinSight
· WinSpector
Данные инструменты собраны в отдельную категорию не потому, что они менее важны, чем другие, но потому, что они играют достаточно абстрактную техническую роль в программировании.
Чтобы стать сильным программистом на Delphi, Вам понадобится понять, как использовать отладчик Delphi. Отладчик позволяет Вам пройти пошагово по исходному тексту программы, выполняя по одной строке за раз, и открыть просмотровое окно (Watch), в котором будут отражаться текущие значения переменных программы.
Встроенный отладчик, который наиболее важен из пяти вышеперечисленных инструментов, работает в том же окне, что и Редактор. Внешний отладчик делает все, что делает встроенный и кое-что еще. Он более быстр и мощен, чем встроенный. Однако он не так удобен в использовании, главным образом из-за необходимости покидать среду Delphi.
Теперь давайте поговорим о компиляторах. Внешний компилятор, называется DCC.EXE, полезен, в основном, если Вы хотите скомпилировать приложение перед отладкой его во внешнем отладчике. Большинство программистов, наверняка, посчитают, то гораздо проще компилировать в среде Delphi, нежели пытаться создать программу из командной строки. Однако, всегда найдется несколько оригиналов, которые будут чувствовать себя счастливее, используя компилятор командной строки. Но это факт - возможно создать и откомпилировать программу на Delphi используя только DCC.EXE и еще одну программу CONVERT.EXE, которая поможет создать формы. Однако, данный подход неудобен для большинства программистов.
WinSight и WinSpector интересны преимущественно для опытных программистов в Windows. Это не значит, что начинающий не должен их запускать и экспериментировать с ними по своему усмотрению. Но эти инструменты вторичны и используются для узких технических целей.
Из этих двух инструментов WinSight определенно более полезен. Основная его функция - позволить Вам наблюдать за системой сообщений Windows. Хотя Delphi делает много для того, чтобы спрятать сложные детали данной системы сообщений от неопытных пользователей, тем не менее Windows является операционной системой, управляемой событиями. Почти все главные и второстепенные события в среде Windows принимают форму сообщений, которые рассылаются с большой интенсивностью среди различными окнами на экране. Delphi дает Вам полный доступ к сообщениям Windows и позволяет отвечать на них, как только будет нужно. В результате, опытным пользователям WinSight становится просто необходим.
WinSpector сохраняет запись о текущем состоянии машины в текстовый файл; Вы можете просмотреть этот файл для того, чтобы узнать, что неправильно идет в программе. Данный инструмент полезен, когда программа находится в опытной эксплуатации - можно получить важную информацию при крушении системы. Стандартные компоненты Для дальнейшего знакомства со средой программирования Delphi потребуется рассказать о составе первой страницы Палитры Компонент.
На первой странице Палитры Компонент размещены 14 объектов
(рис.8) определенно важных для использования. Мало кто обойдется длительное время без кнопок, списков, окон ввода и т.д. Все эти объекты такая же часть Windows, как мышь или окно.
Набор и порядок компонент на каждой странице являются конфигурируемыми. Так, Вы можете добавить к имеющимся компонентам новые, изменить их количество и порядок.
Рис.8: Компоненты, расположенные на первой странице Палитры.
Стандартные компоненты Delphi перечислены ниже с некоторыми комментариями по их применению. При изучении данных компонент было бы полезно иметь под рукой компьютер с тем, чтобы посмотреть, как они работают и как ими манипулировать. · TMainMenu позволяет Вам поместить главное меню в программу. При помещении TMainMenu на форму это выглядит, как просто иконка. Иконки данного типа называют "невидимыми компонентом", поскольку они невидимы во время выполнения программы. Создание меню включает три шага: (1) помещение TMainMenu на форму, (2) вызов Дизайнера Меню через свойство Items в Инспекторе Объектов, (3) определение пунктов меню в Дизайнере Меню.
· TPopupMenu позволяет создавать всплывающие меню. Этот тип меню появляется по щелчку правой кнопки мыши.
· TLabel служит для отображения текста на экране. Вы можете изменить шрифт и цвет метки, если дважды щелкнете на свойство Font в Инспекторе Объектов. Вы увидите, что это легко сделать и во время выполнения программы, написав всего одну строчку кода.
· TEdit - стандартный управляющий элемент Windows для ввода. Он может быть использован для отображения короткого фрагмента текста и позволяет пользователю вводить текст во время выполнения программы.
· TMemo - иная форма TEdit. Подразумевает работу с большими текстами. TMemo может переносить слова, сохранять в Clipboard фрагменты текста и восстанавливать их, и другие основные функции редактора. TMemo имеет ограничения на объем текста в 32Кб, это составляет 10-20 страниц. (Есть VBX и “родные” компоненты Delphi, где этот предел снят).
· TButton позволяет выполнить какие-либо действия при нажатии кнопки во время выполнения программы. В Delphi все делается очень просто. Поместив TButton на форму, Вы по двойному щелчку можете создать заготовку обработчика события нажатия кнопки. Далее нужно заполнить заготовку кодом (подчеркнуто то, что нужно написать вручную):
procedure TForm1.Button1Click(Sender: TObject);
begin
MessageDlg('Are you there?',mtConfirmation,mbYesNoCancel,0);
end; ·TCheckBox отображает строку текста с маленьким окошком рядом. В окошке можно поставить отметку, которая означает, что что-то выбрано. Например, если посмотреть окно диалога настроек компилятора (пункт меню Options | Project, страница Compiler), то можно увидеть, что оно состоит преимущественно из CheckBox’ов.
·TRadioButton позволяет выбрать только одну опцию из нескольких. Если Вы опять откроете диалог Options | Project и выберете страницу Linker Options, то Вы можете видеть, что секции Map file и Link buffer file состоят из наборов RadioButton.
·TListBox нужен для показа прокручиваемого списка. Классический пример ListBox’а в среде Windows - выбор файла из списка в пункте меню File | Open многих приложений. Названия файлов или директорий и находятся в ListBox’е.
· TComboBox во многом напоминает ListBox, за исключением того, что позволяет водить информацию в маленьком поле ввода сверху ListBox. Есть несколько типов ComboBox, но наиболее популярен выпадающий вниз (drop-down combo box), который можно видеть внизу окна диалога выбора файла.
·TScrollbar - полоса прокрутки, появляется автоматически в объектах редактирования, ListBox’ах при необходимости прокрутки текста для просмотра.
· TGroupBox используется для визуальных целей и для указания Windows, каков порядок перемещения по компонентам на форме (при нажатии клавиши TAB).
· TPanel - управляющий элемент, похожий на TGroupBox, используется в декоративных целях. Чтобы использовать TPanel, просто поместите его на форму и затем положите другие компоненты на него. Теперь при перемещении TPanel будут передвигаться и эти компоненты. TPanel используется также для создания линейки инструментов и окна статуса.
TScrollBox представляет место на форме, которое можно скроллировать в вертикальном и горизонтальном направлениях. Пока Вы в явном виде не отключите эту возможность, форма сама по себе действует так же. Однако, могут быть случаи, когда понадобится прокручивать только часть формы. В таких случаях используется TScrollBox. Это полный список объектов на первой странице Палитры Компонент. Если Вам нужна дополнительная информация, то выберите на Палитре объект и нажмите клавишу F1 - появится Справочник с полным описанием данного объекта. Подробнее об Инспекторе Объектов
Ранее мы вкратце рассмотрели Инспектор Объектов (Object Inspector). Теперь нужно исследовать этот важный инструмент глубже. Основное для понимания Инспектора Объектов состоит в том, что он используется для изменения характеристик любого объекта, брошенного на форму. Кроме того, и для изменения свойств самой формы.
Лучший путь для изучения Инспектора объектов - поработать с ним. Для начала откройте новый проект, выбрав пункт меню File | New Project. Затем положите на форму объекты TMemo, TButton, и TListBox, как показано на рис.9.
Рис.9: Простой объект TForm с компонентами TMemo, TButton, и TListBox.
Сперва рассмотрим работу со свойствами на примере свойства Ctl3D (по умолчанию включено). Выберите форму, щелкнув на ней мышкой, перейдите в Инспектор Объектов и несколько раз с помощью двойных щелчков мышью переключите значение свойства Ctl3D. Заметьте, что это действие радикально меняет внешний вид формы. Изменение свойства Ctl3D формы автоматически изменяет свойство Ctl3D каждого дочернего окна, помещенного на форму.
Вернитесь на форму и поставьте значение Ctl3D в True. Теперь нажмите клавишу <Shift> и щелкните на TMemo и затем на TListBox. Теперь оба объекта имеют по краям маленькие квадратики, показывающие, что объекты выбраны.
Выбрав два или более объектов одновременно, Вы можете выполнить большое число операций над ними. Например, передвигать по форме. Затем попробуйте выбрать пункт меню Edit | Size и установить оба поля Ширину(Width) и Высоту(Height) в Grow to Largest, как показано на рис.10. Теперь оба объекта стали одинакового размера. Затем выберите пункт меню Edit | Align и поставьте в выравнивании по горизонтали значение Center (см. рис.11).
Поскольку Вы выбрали сразу два компонента, то содержимое Инспектора Объектов изменится - он будет показывать только те поля, которые являются общими для объектов. Это означает то, что изменения в свойствах, произведенные Вами повлияют не на один, а на все выбранные объекты.
Рассмотрим изменение свойств объектов на примере свойства Color. Есть три способа изменить его значение в Инспекторе Объектов. Первый - просто напечатать имя цвета (clRed) или номер цвета. Второй путь - нажать на маленькую стрелку справа и выбрать цвет из списка. Третий путь - дважды щелкнуть на поле ввода свойства Color. При этом появится диалог выбора цвета.
Свойство Font работает на манер свойства Color. Чтобы это посмотреть, сначала выберите свойство Font для объекта TMemo и дважды щелкните мышкой на поле ввода. Появится диалог настройки шрифта, как показано на рис.12. Выберите, например, шрифт New Times Roman и установите какой-нибудь очень большой размер, например 72. Затем измените цвет фонта с помощью ComboBox’а в нижнем правом углу окна диалога. Когда Вы нажмете кнопку OK, Вы увидите, что вид текста в объекте TMemo радикально изменился.
Рис.12: Диалог выбора шрифта позволяет Вам задать тип шрифта, размер, и цвет.
В завершение краткого экскурса по Инспектору Объектов дважды щелкните на свойство Items объекта ListBox. Появится диалог, в котором Вы можете ввести строки для отображения в ListBox. Напечатайте несколько слов, по одному на каждой строке, и нажмите кнопку OK. Текст отобразится в ListBox’е.
Сохранение программы
Вы приложили некоторые усилия по созданию программы и можете захотеть ее сохранить. Это позволит загрузить программу позже и снова с ней поработать.
Первый шаг - создать поддиректорию для программы. Лучше всего создать директорию, где будут храниться все Ваши программы и в ней - создать поддиректорию для данной конкретной программы. Например, Вы можете создать директорию MYCODE и внутри нее - вторую директорию TIPS1, которая содержала бы программу, над которой Вы только что работали.
После создания поддиректории для хранения Вашей программы нужно выбрать пункт меню File | Save Project. Сохранить нужно будет два файла. Первый - модуль (unit), над которым Вы работали, второй - главный файл проекта, который "владеет" Вашей программой. Сохраните модуль под именем MAIN.PAS и проект под именем TIPS1.DPR. (Любой файл с расширением PAS и словом “unit” в начале является модулем.) TButton, исходный текст, заголовки и Z-упорядочивание
Еще несколько возможностей Инспектора Объектов и Дизайнера Форм.
Создайте новый проект. Поместите на форму объект TMemo, а затем TEdit так, чтобы он наполовину перекрывал TMemo, как показано на рис.13. Теперь выберите пункт меню Edit | Send to Back, что приведет к перемещению TEdit вглубь формы, за объект TMemo. Это называется изменением Z-порядка компонент. Буква Z используется потому, что обычно математики обозначают третье измерение буквой Z. Так, X и Y используются для обозначения ширины и высоты, и Z используется для обозначения глубины.
Рис.13: Объект TEdit перекрывается наполовину объектом TMemo.
Если Вы “потеряли” на форме какой-то объект, то найти его можно в списке Combobox’а, который находится в верхней части Инспектора Объектов.
Поместите кнопку TButton в нижнюю часть формы. Теперь растяните Инспектор Объектов так, чтобы свойства Name и Caption были видны одновременно на экране. Теперь измените имя кнопки на Terminate. Заметьте, что заголовок (Caption) поменялся в тот же момент. Такое двойное изменение наблюдается только если ранее не изменялось свойство Caption.
Текст, который Вы видите на поверхности кнопки - это содержимое свойства Caption, свойство Name служит для внутренних ссылок, Вы будете использовать его при написании кода программы. Если Вы откроете сейчас окно Редактора, то увидите следующий фрагмент кода:
TForm1 = class(TForm)
Edit1: TEdit;
Memo1: TMemo;
Terminate: TButton;
private
{ Private declarations }
public
{ Public declarations }
end;
В этом фрагменте кнопка TButton называется Terminate из-за того, что Вы присвоили это название свойству Name. Заметьте, что TMemo имеет имя, которое присваивается по умолчанию.
Перейдите на форму и дважды щелкните мышкой на объект TButton. Вы сразу попадете в окно Редактора, в котором увидите фрагмент кода вроде этого:
procedure TForm1.TerminateClick(Sender: TObject);
begin
end;
Данный код был создан автоматически и будет выполняться всякий раз, когда во время работы программы пользователь нажмет кнопку Terminate. Вдобавок, Вы можете видеть, что определение класса в начале файла теперь включает ссылку на метод TerminateClick:
TForm1 = class(TForm)
Edit1: TEdit;
Memo1: TMemo;
Terminate: TButton;
procedure TerminateClick(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;
Потратьте немного времени на усвоение последовательности действий, описанных выше. Изначально Вы смотрите на кнопку на форме. Вы делаете двойной щелчок на эту кнопку, и соответствующий фрагмент кода автоматически заносится в Редактор.
Теперь самое время написать строчку кода. Это очень простой код, состоящий из одного слова Close:
procedure TForm1.TerminateClick(Sender: TObject);
begin
Close;
end;
Когда этот код исполняется, то главная форма (значит и все приложение) закрывается. Для проверки кода запустите программу и нажмите кнопку Terminate. Если все сделано правильно, программа закроется и Вы вернетесь в режим дизайна.
Прежде, чем перейти к следующему разделу, перейдите в Инспектор Объектов и измените значение свойства Name для кнопки на любое другое, например OK. Нажмите Enter для внесения изменений. Посмотрите в Редактор, Вы увидите, что код, написанный Вами изменился:
procedure TForm1.OkClick(Sender: TObject);
begin
Close;
end;
Заметьте, что аналогичные изменения произошли и в определении класса:
TForm1 = class(TForm)
Edit1: TEdit;
Memo1: TMemo;
Ok: TButton;
procedure OkClick(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;
Тьюторы (интерактивные обучающие программы) Delphi предоставляет тьютор, содержащий несколько тем и который можно запустить из пункта меню Help | Interactive Tutors. Тьютор запускается только если среда Delphi имеет все установки по умолчанию. Если конфигурация была изменена, то проще всего сохранить файл DELPHI.INI под другим именем и скопировать файл DELPHI.CBT в DELPHI.INI.
В первых двух темах дается краткий обзор Delphi и происходит обучение построению простейшего приложения.
Остальные темы посвящены построению пользовательского интерфейса: размещению объектов на форме, настройке их свойств и написанию обработчиков событий. А также созданию приложений, работающих с базами данных.
В данной статье рассказывается как
Урок 3: Управление проектом
Содержание урока 3:
Обзор
Проект Delphi
Пункт меню “File”
Управление проектом
Обзор других пунктов меню
Edit
Search
View
Compile
Пункт меню Options | Project
Forms
Applications
Compiler
Linker
Directories/Conditionals
Конфигурация среды программирования
Обзор
В данной статье рассказывается как : Добавлять и удалять формы и модули в проект Управлять окнами на рабочем пространстве Создавать выполняемый файл для Windows Тонко настроить среду программирования Проект Delphi
Любой проект имеет, по-крайней мере, шесть файлов, связанных с ним. Три из них относятся к управлению проектом из среды и напрямую программистом не меняются. Вот эти файлы : Главный файл проекта, изначально называется PROJECT1.DPR. Первый модуль программы /unit/, который автоматически появляется в начале работы. Файл называется UNIT1.PAS по умолчанию, но его можно назвать любым другим именем, вроде MAIN.PAS. Файл главной формы, который по умолчанию называется UNIT1.DFM, используется для сохранения информации о внешнем виде главной формы. Файл PROJECT1.RES содержит иконку для проекта, создается автоматически. Файл, который называется PROJECT1.OPT по умолчанию, является текстовым файлом для сохранения установок, связанных с данным проектом. Например, установленные Вами директивы компилятора сохраняются здесь. Файл PROJECT1.DSK содержит информацию о состоянии рабочего пространства. Разумеется, если сохранить проект под другим именем, то изменят название и файлы с расширением RES, OPT и DSK.
После компиляции программы получаются файлы с расширениями:
DCU - скомпилированные модули
EXE - исполняемый файл
DSM - служебный файл для запуска программы в среде, очень большой, рекомендуется стирать его при окончании работы.
~PA, ~DP - backup файлы Редактора.
Пункт меню “File”
Если нужно сохранить проект, то Вы выбираете пункт главного меню “File” (с помощью мышки или по клавише Alt+F). Пункт меню “File” выглядит следующим образом:
New Project
Open Project
Save Project
Save Project As
Close Project
---------------------
New Form
New Unit
New Component
Open File
Save File
Save File As
Close File
---------------------
Add File
Remove File
---------------------
---------------------
Exit
---------------------
1 PREV1.DPR
2 PREV2.DPR
Как Вы можете видеть, здесь есть шесть секций; вот их назначение: Первая секция дает возможность управления проектом вцелом. Вторая секция дает контроль над формами, модулями и компонентами проекта. Третья позволяет добавлять и удалять файлы из проекта. Четвертая управляет печатью. Пятая секция - выход из Delphi Шестая секция предоставляет список ранее редактировавшихся проектов; Вы можете быстро открыть нужный. Как Вы увидите позже, большинство операций из пункта меню “File” можно выполнить с помощью Менеджера Проекта (Project Manager), который можно вызвать из пункта меню View. Некоторые операции доступны и через SpeedBar. Данная стратегия типична для Delphi: она предоставляет несколько путей для решения одной и той же задачи, Вы сами можете решать, какой из них более эффективен в данной ситуации.
Каждая строка пункта меню “File” объяснена в Справочнике. Выберите меню “File” и нажмите F1, появится экран справочника, как на рис.1.
Рис.1: Delphi включает подсказку, как использовать пункт меню “File”.
Большинство из пунктов первой секции очевидны. “New Project” начинает новый проект, “Open Project” открывает существующий проект и т.д.
Первые два пункта второй секции позволяют Вам создать новую форму или новый модуль. Выбирая “New Form”, Вы создаете новую форму и модуль, связанный с ней; выбирая “New Unit”, Вы создаете один модуль.
“New Component” вызывает диалог для построения заготовки нового визуального компонента. В результате создается модуль, который можно скомпилировать и включить в Палитру Компонент.
“Open File” открывает при необходимости любой модуль или просто текстовый файл. Если модуль описывает форму, то эта форма тоже появится на экране.
При создании нового модуля Delphi дает ему имя по-умолчанию. Вы можете изменить это имя на что-нибудь более осмысленное (например, MAIN.PAS) с помощью пункта “Save File As“.
“ Save File” сохраняет только редактируемый файл, но не весь проект.
“Close File” удаляет файл из окна Редактора.
Нужно обратить внимание: Вы должны регулярно сохранять проект через File | Save Project либо через нажатие Ctrl+S.
Управление проектом
Теперь, когда Вы знаете о создании проекта с помощью пункта меню “File”, перейдем к Менеджеру Проектов, который помогает управлять проектом. Менеджер Проектов, рис.3, разделен на две части. Верхняя - панель с управляющими кнопками. Нижняя - список модулей, входящих в проект.
Рис.3: Кнопки сверху используются для удаления и добавления модулей в проект.
Вы можете использовать кнопки с плюсом и минусом для добавления и удаления файлов в проекте. Эти изменения влияют на файлы с исходным текстом, то есть, если добавить в проект модуль, то ссылка на него появится в файле с расширением DPR.
Краткое описание других кнопок : Третья слева кнопка - просмотр текста модуля, на котором стоит курсор. Четвертая - просмотр формы, если есть таковая для данного модуля Пятая - вызов диалога настройки проекта, сам диалог будет рассмотрен позже. Последняя - сохранение изменений на диске. Обзор других пунктов меню
Пункт меню “File” обсуждался ранее. Далее рассматриваются другие важные пункты - “Edit”, “Search”, “View” и “Compile”, но менее подробно. Далее, снова подробно, рассказывается о “Options”. Пункт меню “Edit”
“Edit” содержит команды “Undo” и “Redo”, которые могут быть очень полезны при работе в редакторе для устранения последствий при неправильных действиях, например, если случайно удален нужный фрагмент текста.
Отметьте для себя, что Справочник (on-line help) объясняет как нужно использовать пункт меню Options | Environment для настройки команды “Undo”. Возможность ограничить возможное количество команд “Undo” может пригодиться, если Вы работаете на машине с ограниченными ресурсами.
Команды “Cut”, “Copy”, “Paste” и “Delete” - как во всех остальных приложениях Windows, но их можно применять не только к тексту, но и к визуальным компонентам.
“Bring To Front”, “Send To Back”, “Align” и “Size” обсуждались в Уроке № 2. Оставшиеся четыре пункта помогают быстро “приукрасить” внешний вид формы. Пункт меню “Menu”
В “Search” есть команда “Find Error” (поиск ошибки), которая поможет отследить ошибку периода выполнения программы. Когда в сообщении об ошибке указан ее адрес, Вы можете выбрать пункт меню Search | Find Error и ввести этот адрес. Если это представится возможным, то среда переместит Вас в то место программы, где произошла ошибка. Пункт меню “View” Составляющие пункта меню “View”: Project Manager (Менеджер Проекта). Project Source - загружает главный файл проекта (DPR) в Редактор Установка, показывать или нет Object Inspector на экране. Установка, показывать или нет Alignment Palette. То же самое доступно из пункт меню Edit | Align. Browser - вызов средства для просмотра иерархии объектов программы, поиска идентификатора в исходных текстах и т.п. Watch, Breakpoint и Call Stack - связаны с процедурой отладки программы и будут обсуждаться позднее. Component List - список компонент, альтернатива Палитре Компонент. Используется для поиска компонента по имени или при отсутствии мыши. Window List - список окон, открытых в среде Delphi. Toggle Form/Unit, Units, Forms - переключение между формой и соответствующим модулем, выбор модуля или формы из списка. New Edit Window - открывает дополнительное окно Редактора. Полезно, если нужно, например, просмотреть две разных версии одного файла. SpeedBar и Component Palette - установки, нужно ли их отображать. Пункт меню “Compile”
В пункте меню “Compile” проект можно скомпилировать (compile) или перестроить (build). Если выбрать Compile или Run, то Delphi перекомпилирует только те модули, которые изменились со времени последней компиляции. Build all, с другой стороны, перекомпилирует все модули, исходные тексты которых доступны. Команда Syntax Check только проверяет правильность кода программы, но не обновляет DCU файлы.
В самом низу - пункт Information, который выдает информацию о программе:
размеры сегментов кода, данных и стека, размер локальной динамической памяти и количество скомпилированных строк. Пункт меню “Run” Можно использовать “Run” для компиляции и запуска программы и для указания параметров командной строки для передачи в программу. Здесь же имеются опции для режима отладки. Пункт меню Options | Project
“Options” наиболее сложная часть системного меню. Это центр управления, из которого вы можете изменять установки для проекта и для всей рабочей среды Delphi. В “Options” есть семь пунктов:
Project
Environment
Tools
Gallery
--
Open Library
Install Components
Rebuild Library
Первые четыре пункта вызывают диалоговые окна. Ниже приведено общее описание пункта меню “Options”: Project - выбор установок, которые напрямую влияют на текущий проект, это могут быть, к примеру, директивы компилятора проверки стека (stack checking) или диапазона (range checking). Environment - конфигурация самой среды программирования (IDE). Например, здесь можно изменить цвета, используемые в Редакторе. Tools - позволяет добавить или удалить вызов внешних программ в пункт главного меню “Tools”. Например, если Вы часто пользуетесь каким-нибудь редактором или отладчиком, то здесь его вызов можно добавить в меню. Gallery - позволяет определить специфические установки для Эксперта Форм и Эксперта Проектов и их “заготовок”. Эксперты и “заготовки” предоставляют путь для ускорения конструирования интерфейса программы. Последние три пункта позволяют сконфигурировать Палитру Компонент. Диалог из пункта Options | Project включает пять страниц: На странице Forms перечислены все формы, включенные в проект; Вы можете указать, нужно ли автоматически создавать форму при старте программы или Вы ее создадите сами. На странице Application Вы определяете элементы программы такие, как заголовок, файл помощи и иконка. Страница Compiler включает установки для генерации кода, управления обработкой ошибок времени выполнения, синтаксиса, отладки и др. На странице Linker можно определить условия для процесса линковки приложения
Страница Directories/Conditionals - здесь указываются директории, специфичные для данного проекта. После предыдущего абзаца с общим описанием, каждая страница описана детально в отдельной главе. Все установки для проекта сохраняются в текстовом файле с расширением OPT и Вы можете вручную их исправить. Страница Forms
На странице Forms можно выбрать главную форму проекта. Изменения, которые Вы сделаете, отобразятся в соответствующем файле DPR. Например, в нижеследующем проекте, Form1 является главной, поскольку появляется первой в главном блоке программы:
program Project1;
uses
Forms,
Unit1 in 'UNIT1.PAS' {Form1},
Unit2 in 'UNIT2.PAS' {Form2};
{$R *.RES}
begin
Application.CreateForm(TForm1, Form1);
Application.CreateForm(TForm2, Form2);
Application.Run;
end.
Если изменить код так, чтобы он читался
begin
Application.CreateForm(TForm2, Form2);
Application.CreateForm(TForm1, Form1);
Application.Run;
end.
то теперь Form2 станет главной формой проекта.
Вы также можете использовать эту страницу для определения, будет ли данная форма создаваться автоматически при старте программы. Если форма создается не автоматически, а по ходу выполнения программы, то для этого нужно использовать процедуру Create.
Кстати, в секции Uses имя формы в фигурных скобках является существенным для Менеджера Проектов и удалять его не стоит. Не нужно вообще ничего изменять вручную в файле проекта, если только Вы не захотели создать DLL, но об этом позднее. Страница Applications
На странице Applications, см. рис.5, вы можете задать заголовок (Title), файл помощи (Help file) и пиктограмму (Icon) для проекта.
Рис.5: Страница общих установок для приложения. Страница Compiler
Ранее уже говорилось, что установки из пункта меню “Options | Project” сохраняются в соответствующем файле с расширением OPT. Давайте рассмотрим директивы компилятора на странице Compiler (рис.6).
Рис.6: Страница для определения директив компилятора.
Следующая таблица показывает, как различные директивы отображаются в OPT файле, на странице Compiler и внутри кода программы:
| OPT File | Options Page | Editor Symbol |
| F | Force Far Calls | {$F+} |
| A | Word Align Date | {$A+} |
| U | Pentium-Safe FDIV | {$U+} |
| K | Smart Callbacks | {$K+} |
| W | Windows (3.0) Stack Frame | {$W+} |
| R | Range Checking | {$R+} |
| S | Stack Checking | {$S+} |
| I | IO Checking | {$I+} |
| Q | Overflow Checking | {$Q+} |
| V | Strict Var Strings | {$V+} |
| B | Complete Boolean Evaluation | {$B+} |
| X | Extended Syntax | {$X+} |
| T | Typed @ Operator | {$T+} |
| P | Open Parameters | {$P+} |
| D | Debug Information | {$D+} |
| L | Local Symbols | {$L+} |
| Y | Symbol Information | {$Y+} |
| N | Numeric Processing | {$N+} |
Страница Linker
Теперь давайте перейдем к странице Linker, показанной на рис.7.
Рис.7: Страница линковщика.
Установки отладчика рассматриваются ниже. Если буфер линковщика расположен в памяти, то линковка происходит быстрее.
Размер стека (Stack Size) и локальной динамической памяти (Heap Size) весьма важны. Delphi устанавливает по умолчанию и Stack Size, и Heap Size в 8192 байт каждый. Вам может понадобиться изменить размер стека в программе, но обычно это не более 32Кб. В сумме эти два размера не должны превышать 64Кб, иначе будет выдаваться ошибка при компиляции программы. Страница Directories/Conditionals Страница Directories/Conditionals, рис.8, дает возможность расширить число директорий, в которых компилятор и линковщик ищут DCU файлы.
Рис.8: Страница Directories/Conditionals.
В файле DELPHI.INI содержится еще один список директорий. Запомните, что в OPT файле - список директорий для конкретного проекта, а в файле DELPHI.INI - список относится к любому проекту.
Output directory - выходная директория, куда складываются EXE и DCU файлы, получающиеся при компиляции.
Search path - список директорий для поиска DCU файлов при линковке. Директории перечисляются через точку с запятой ;
Conditional defines - для опытного программиста и на первом этапе создания проекта не требуется. Для информации можно вызвать Справочник (on-line help).
Конфигурация среды программирования (IDE)
Пункт меню “Options | Environment” предоставляет Вам большой набор страниц и управляющих элементов, которые определяют внешний вид и работу IDE. Delphi позволяет сделать следующие важные настройки: Определить, что из проекта будет сохраняться автоматически. Можно менять цвета IDE. Можно менять подсветку синтаксиса в Редакторе. Можно изменить состав Палитры Компонент. Указать “горячие клавиши” IDE. Первая страница пункта меню “Options | Environment” показана на рис.9
Рис.9: Страница Preferences.
В группе “Desktop Contents” определяется, что будет сохраняться при выходе из Delphi. Если выбрать Desktop Only - это сохранит информацию о директориях и открытых окнах, если выбрать Desktop And Symbols - это сохранит то же самое плюс информацию для броузера (browser).
В группе “Autosave” указывается, что нужно сохранять при запуске программы. Если позиция Editor Files выбрана, то сохраняются все модифицированные файлы из Редактора при выполнении команд Run|Run, Run|Trace Into, Run|Step Over, Run|Run To Cursor или при выходе из Delphi. Если позиция Desktop выбрана - сохраняется рабочая среда при закрытии проекта или при выходе из Delphi. Если Вы позже откроете проект, то он будет иметь тот же вид, что и при его закрытии.
В группе “Form Designer” можно установить, показывать ли сетку (grid) на экране и выравнивать ли объекты по ней, и размер ячеек сетки.
В группе “Debugging”: опция Integrated Debugging - использовать ли встроенный отладчик; Step Program Block - отладчик остановится на первой строке модуля, в котором есть отладочная информация; Break On Exception - останавливать ли программу при возникновении исключительной ситуации; Minimize On Run - свертывать ли Delphi при запуске программы. После закрытия программы среда Delphi восстанавливается. Hide Designers On Run - прячет окна Дизайнера (Инспектор Объектов, формы) при запуске приложения.
Show Compiler Progress - показывать ли окно, в котором отражается процесс компиляции программы.
“Gallery” - указывает, в каких случаях нужно предоставлять “галерею” (коллекцию заготовок и экспертов).
Страницы Editor Options, Editor Display и Editor Colors позволяют Вам изменить цвета и “горячие” клавиши, используемые IDE. Страница Editor Display показана на рис.10, а Editor Colors - на рис.11.
Рис.10: Страница Editor Display.
Рис.11: Страница Editor Colors.
Существует несколько способов изменить назначение “горячих” клавиш, используемых Редактором. Например, многие пользователи привыкли, что по клавише F5 максимизируется окно Редактора. Для этого им надо использовать расположение клавиш, называемое “Classic” (Keystroke mapping : Classic). Всего есть четыре вида конфигурации клавиш: “Default” - характерно для Microsoft. Если Вы новичок в Windows или уже привыкли к этому расположению клавиш, то это подойдет. “Classic” - более известно ветеранам Borland C++ и Borland Pascal. Поддерживает многие комбинации клавиш WordStar и отладчик управляется старым добрым способом. Остальные два вида - имитируют редакторы Epsilon и BRIEF. Подойдут, если вы с ними знакомы. Точное описание назначения клавиш можно найти в Справочнике (в Help | Topic Search набрать “key mapping”).
Цвета IDE можно изменить на странице Editor Colors.
И, наконец, Editor Options (рис.12).
Рис.12: На странице Editor Options можно настроить тонкие детали работы Редактора.
Многие из установок на данной странице не очень важны для большинства пользователей, поэтому остановимся лишь на некоторых.
“Use syntax highlight” - выделять ли цветом синтаксические конструкции в Редакторе Исходного текста.
“Find text at cursor” - если включено, то при поиске (Ctrl+F) в качестве подстроки для поиска будет браться то слово, на котором стоит курсор.
Обо всех опциях можно подробнее узнать в Справочнике (F1).
Установки сохраняются в файле DELPHI.INI, который находится в директории Windows.
В данной статье дается обзор
Содержание урока 4:
Обзор
Страница Standard
Страница Additional
Страница Dialogs
Страница System
Страница VBX
ОБЗОР
В данной статье дается обзор стандартных и дополнительных компонент из Палитры Компонент Delphi (стр. Standard и Additional), страницы диалогов (Dialogs), системных компонент (стр. System), страницы объектов в формате Visual Basic (VBX). Компоненты, осуществляющие доступ к данным и отображение их на экране будут рассматриваться позднее.
Стандартные компоненты
С компонентами, расположенными на первой странице Палитры Компонент Вы могли ознакомиться в Уроке № 2.
На первой странице Палитры Компонент размещены 14 объектов (рис.8) определенно важных для использования. Мало кто обойдется длительное время без кнопок, списков, окон ввода и т.д. Все эти объекты такая же часть Windows, как мышь или окно.
Набор и порядок компонент на каждой странице являются конфигурируемыми. Так, Вы можете добавить к имеющимся компонентам новые, изменить их количество и порядок. Это можно сделать, вызвав всплывающее меню (нажать правую кнопку мыши, когда указатель над Палитрой).
Рис.8: Компоненты, расположенные на первой странице Палитры.
Стандартные компоненты Delphi перечислены ниже с некоторыми комментариями по их применению. При изучении данных компонент было бы полезно иметь под рукой компьютер с тем, чтобы посмотреть, как они работают и как ими манипулировать.
Курсор - не компонент, просто пиктограмма для быстрой отмены выбора какого-либо объекта.
TMainMenu позволяет Вам поместить главное меню в программу. При помещении TMainMenu на форму это выглядит, как просто иконка. Иконки данного типа называют "невидимыми компонентом", поскольку они невидимы во время выполнения программы. Создание меню включает три шага: (1) помещение TMainMenu на форму, (2) вызов Дизайнера Меню через свойство Items в Инспекторе Объектов, (3) определение пунктов меню в Дизайнере Меню.
TPopupMenu позволяет создавать всплывающие меню. Этот тип меню появляется по щелчку правой кнопки мыши на объекте, к которому привязано данное меню. У всех видимых объектов имеется свойство PopupMenu, где и указывается нужное меню. Создается PopupMenu аналогично главному меню.
TEdit - стандартный управляющий элемент Windows для ввода. Он может быть использован для отображения короткого фрагмента текста и позволяет пользователю вводить текст во время выполнения программы.
TMemo - иная форма TEdit. Подразумевает работу с большими текстами. TMemo может переносить слова, сохранять в ClipBoard фрагменты текста и восстанавливать их, и другие основные функции редактора. TMemo имеет ограничения на объем текста в 32Кб, это составляет 10-20 страниц. (Есть VBX и “родные” компоненты Delphi, где этот предел снят).
TButton позволяет выполнить какие-либо действия при нажатии кнопки во время выполнения программы. В Delphi все делается очень просто. Поместив TButton на форму, Вы по двойному щелчку можете создать заготовку обработчика события нажатия кнопки. Далее нужно заполнить заготовку кодом:
procedure TForm1.Button1Click(Sender: TObject);
begin
MessageDlg('Are you there?',mtConfirmation,mbYesNoCancel,0);
end;
TCheckBox отображает строку текста с маленьким окошком рядом. В окошке можно поставить отметку, которая означает, что что-то выбрано. Например, если посмотреть окно диалога настроек компилятора (пункт меню Options | Project, страница Compiler), то можно увидеть, что оно состоит преимущественно из CheckBox’ов.
TRadioButton позволяет выбрать только одну опцию из нескольких. Если Вы опять откроете диалог Options | Project и выберете страницу Linker Options, то Вы можете видеть, что секции Map file и Link buffer file состоят из наборов RadioButton.
TListBox нужен для показа прокручиваемого списка. Классический пример ListBox’а в среде Windows - выбор файла из списка в пункте меню File | Open многих приложений. Названия файлов или директорий и находятся в ListBox’е.
TComboBox во многом напоминает ListBox, за исключением того, что позволяет водить информацию в маленьком поле ввода сверху ListBox. Есть несколько типов ComboBox, но наиболее популярен спадающий вниз (drop-down combo box), который можно видеть внизу окна диалога выбора файла.
TGroupBox используется для визуальных целей и для указания Windows, каков порядок перемещения по компонентам на форме (при нажатии клавиши TAB).
TRadioGroup используется аналогично TGroupBox, для группировки объектов TRadioButton.
TPanel - управляющий элемент, похожий на TGroupBox, используется в декоративных целях. Чтобы использовать TPanel, просто поместите его на форму и затем положите другие компоненты на него. Теперь при перемещении TPanel будут передвигаться и эти компоненты. TPanel используется также для создания линейки инструментов и окна статуса.
Это полный список объектов на первой странице Палитры Компонент. Если Вам нужна дополнительная информация, то выберите на Палитре объект и нажмите клавишу F1 - появится Справочник с полным описанием данного объекта. Страница Additional
На странице Standard представлены управляющие элементы, появившиеся в Windows 3.0. На странице Additional размещены объекты, позволяющие создать более красивый пользовательский интерфейс программы.
Список компонент:
TBitBtn - кнопка вроде TButton, однако на ней можно разместить картинку (glyph). TBitBtn имеет несколько предопределенных типов (bkClose, bkOK и др), при выборе которых кнопка принимает соответствующий вид. Кроме того, нажатие кнопки на модальном окне (Form2.ShowModal) приводит к закрытию окна с соответствующим модальным результатом (Form2.ModalResult).
TSpeedButton - кнопка для создания панели быстрого доступа к командам (SpeedBar). Пример - SpeedBar слева от Палитры Компонент в среде Delphi. Обычно на данную кнопку помещается только картинка (glyph).
TTabSet - горизонтальные закладки. Обычно используется вместе с TNoteBook для создания многостраничных окон. Название страниц можно задать в свойстве Tabs. Но проще это сделать в программе при создании формы (OnCreate) :
TabSet1.Tabs := Notebook1.Pages;
А для того, чтобы при выборе закладки страницы перелистывались нужно в обработчике события OnClick для TTabSet написать:
Notebook1.PageIndex := TabSet1.TabIndex;
TNoteBook - используется для создания многостраничного диалога, на каждой странице располагается свой набор объектов. Используется совместно с TTabSet.
TTabbedNotebook - многостраничный диалог со встроенными закладками, в данном случае - закладки сверху.
TMaskEdit - аналог TEdit, но с возможностью форматированного ввода. Формат определяется в свойстве EditMask. В редакторе свойств для EditMask есть заготовки некоторых форматов: даты, валюты и т.п. Спец. символы для маски можно посмотреть в Справочнике.
TOutline - используется для представления иерархических отношений связанных данных. Например - дерево директорий.
TStringGrid - служит для представления текстовых данных в виде таблицы. Доступ к каждому элементу таблицы происходит через свойство Cell.
TDrawGrid - служит для представления данных любого типа в виде таблицы. Доступ к каждому элементу таблицы происходит через свойство CellRect.
TImage - отображает графическое изображение на форме. Воспринимает форматы BMP, ICO, WMF. Если картинку подключить во время дизайна программы, то она прикомпилируется к EXE файлу.
TShape - служит для отображения простейших графических объектов на форме: окружность, квадрат и т.п.
TBevel - элемент для рельефного оформления интерфейса.
THeader - элемент оформления для создания заголовков с изменяемыми размерами для таблиц.
TScrollBox - позволяет создать на форме прокручиваемую область с размерами большими, нежели экран. На этой области можно разместить свои объекты.
Страница Dialogs
На странице Dialogs представлены компоненты для вызова стандартных диалогов Windows. Внешний вид диалогов зависит от используемой версии Windows. Объекты, представленные на данной странице невидимы во время выполнения и вызов диалогов происходит программно, например:
if OpenDialog1.Execute then Image1.Picture.LoadFromFile(OpenDialog1.FileName);
Диалоги Windows в порядке появления на странице Dialogs: - OpenDialog; выбрать файл - SaveDialog; сохранить файл - FontDialog; настроить шрифт - ColorDialog; выбор цвета - PrintDialog; печать - PrinterSetupDialog; настройка принтера - FindDialog; поиск строки - ReplaceDialog; поиск с заменой Страница System
Страница представляет набор компонент для доступа к некоторым системным сервисам типа таймер, DDE, OLE и т.п.
TTimer - таймер, событие OnTimer периодически вызывается через промежуток времени, указанный в свойстве Interval. Период времени может составлять от 1 до 65535 мс.
TPaintBox - место для рисования. В обработчики событий, связанных с мышкой передаются относительные координаты мышки в TPaintBox, а не абсолютные в форме.
TFileListBox - специализированный ListBox, в котором отображаются файлы из указанной директории (св-во Directory). На названия файлов можно наложить маску, для этого служит св-во Mask. Кроме того, в св-ве FileEdit можно указать объект TEdit для редактирования маски.
TDirectoryListBox - специализированный ListBox, в котором отображается структура директорий текущего диска. В св-ве FileList можно указать TFileListBox, который будет автоматически отслеживать переход в другую директорию.
TDriveComboBox - специализированный ComboBox для выбора текущего диска. Имеет свойство DirList, в котором можно указать TDirectoryListBox, который будет отслеживать переход на другой диск.
TFilterComboBox - специализированный ComboBox для выбора маски имени файлов. Список масок определяется в свойстве Filter. В свойстве FileList указывается TFileListBox, на который устанавливается маска.
!!!! С помощью последних четырех компонент (TFileListBox, TDirectoryListBox, TDriveComboBox, TFilterComboBox) можно построить свой собственный диалог выбора файла, причем для этого не потребуется написать ни одной строчки кода.
TMediaPlayer - служит для управления мултимедйными устройствами (типа CD-ROM, MIDI и т.п.). Выполнен в виде панели управления с кнопками Play, Stop, Record и др. Для воспроизведения может понадобиться как соответствующее оборудование, так и программное обеспечение. Подключение устройств и установка ПО производится в среде Windows. Например, для воспроизведения видео, записанного в формате AVI, в потребуется установить ПО MicroSoft Video (в Windows 3.0, 3.1, WFW 3.11).
TDDEClientConv,TDDEClientItem, TDDEServerConv, TDDEServerItem - 4 объекта для организации DDE. С помощью этих объектов можно построить приложение как DDE-сервер, так и DDE-клиент. Подробнее - в следующих уроках.
Страница VBX
Поскольку формат объектов из MicroSoft Visual Basic (VBX) является своего рода стандартом и существует большое количество библиотек таких объектов, то в Delphi была предусмотрена совместимость с этим форматом. VBX версии 1.0 можно включить в Палитру Компонент Delphi и использовать их как “родные” компоненты (в том числе, выбирать их в качестве предков и наследовать свойства и методы).
Из данной статьи Вы узнаете
Содержание урока 5:
Обзор
Графические компоненты
Свойство объектов Canvas
Объект TPaintBox
Примеры ex05.zip
Обзор
Из данной статьи Вы узнаете о том, какие возможности есть в Delphi для создания приложений, использующих графику; как использовать компоненты для отображения картинок; какие средства есть в Delphi для оформления программы. Кроме того, познакомитесь с важным свойством Canvas, которое предоставляет доступ к графическому образу объекта на экране. Графические компоненты
В стандартную библиотеку визуальных компонент Delphi входит несколько объектов, с помощью которых можно придать своей программе совершенно оригинальный вид. Это - TImage (TDBImage), TShape, TBevel.
TImage позволяет поместить графическое изображение в любое место на форме. Этот объект очень прост в использовании - выберите его на странице Additional и поместите в нужное место формы. Собственно картинку можно загрузить во время дизайна в редакторе свойства Picture (Инспектор Объектов). Картинка должна храниться в файле в формате BMP (bitmap), WMF (Windows Meta File) или ICO (icon). (TDBImage отображает картинку, хранящуюся в таблице в поле типа BLOB. При этом доступен только формат BMP.)
Как известно, форматов хранения изображений гораздо больше трех вышеназванных (например, наиболее известны PCX, GIF, TIFF, JPEG). Для включения в программу изображений в этих форматах нужно либо перевести их в формат BMP, либо найти библиотеки третьих фирм, в которых есть аналог TImage, “понимающий” данные форматы (есть как VBX объекты, так и “родные” объекты для Delphi).
При проектировании следует помнить, что изображение, помещенное на форму во время дизайна, включается в файл .DPR и затем прикомпилируется к EXE файлу. Поэтому такой EXE файл может получиться достаточно большой. Как альтернативу можно рассмотреть загрузку картинки во время выполнения программы, для этого у свойства Picture (которое является объектом со своим набором свойств и методов) есть специальный метод LoadFromFile. Это делается, например, так:
if OpenDialog1.Execute then
Image1.Picture.LoadFromFile(OpenDialog1.FileName);
Важными являются свойства объекта Center и Stretch - оба имеют булевский тип. Если Center установлено в True, то центр изображения будет совмещаться с центром объекта TImage. Если Stretch установлено в True, то изображение будет сжиматься или растягиваться таким образом, чтобы заполнить весь объект TImage.
TShape - простейшие графические объекты на форме типа круг, квадрат и т.п. Вид объекта указывается в свойстве Shape. Свойство Pen определяет цвет и вид границы объекта. Brush задает цвет и вид заполнения объекта. Эти свойства можно менять как во время дизайна, так и во время выполнения программы.
TBevel - объект для украшения программы, может принимать вид рамки или линии. Объект предоставляет меньше возможностей по сравнению с TPanel, но не занимает ресурсов. Внешний вид указывается с помощью свойств Shape и Style. Свойство объектов Canvas
У ряда объектов из библиотеки визуальных компонент есть свойство Canvas (канва), которое предоставляет простой путь для рисования на них. Эти объекты - TBitmap, TComboBox, TDBComboBox, TDBGrid, TDBListBox, TDirectoryListBox, TDrawGrid, TFileListBox, TForm, TImage, TListBox, TOutline, TPaintBox, TPrinter, TStringGrid. Canvas является в свою очередь объектом, объединяющим в себе поле для рисования, карандаш (Pen), кисть (Brush) и шрифт (Font). Canvas обладает также рядом графических методов : Draw, TextOut, Arc, Rectangle и др. Используя Canvas, Вы можете воспроизводить на форме любые графические объекты - картинки, многоугольники, текст и т.п. без использования компонент TImage,TShape и TLabel (т.е. без использования дополнительных ресурсов), однако при этом Вы должны обрабатывать событие OnPaint того объекта, на канве которого Вы рисуете. Рассмотрим подробнее свойства и методы объекта Canvas.
Свойства Canvas :
Brush -кисть, является объектом со своим набором свойств:
Bitmap - картинка размером строго 8x8, используется для заполнения (заливки) области на экране.
Color - цвет заливки.
Style - предопределенный стиль заливки; это свойство конкурирует со свойством Bitmap - какое свойство Вы определили последним, то и будет определять вид заливки.
Handle - данное свойство дает возможность использовать кисть в прямых вызовах процедур Windows API .
ClipRect - (только чтение) прямоугольник, на котором происходит графический вывод.
CopyMode - свойство определяет, каким образом будет происходить копирование (метод CopyRect) на данную канву изображения из другого места: один к одному, с инверсией изображения и др.
Font - шрифт, которым выводится текст (метод TextOut).
Handle - данное свойство используется для прямых вызовов Windows API.
Pen - карандаш, определяет вид линий; как и кисть (Brush) является объектом с набором свойств:
Color - цвет линии
Handle - для прямых вызовов Windows API
Mode - режим вывода: простая линия, с инвертированием, с
выполнением исключающего или и др.
Style - стиль вывода: линия, пунктир и др.
Width - ширина линии в точках
PenPos - текущая позиция карандаша, карандаш рекомендуется перемещать с помощью метода MoveTo, а не прямой установкой данного свойства.
Pixels - двухмерный массив элементов изображения (pixel), с его помощью Вы получаете доступ к каждой отдельной точке изображения (см. пример к данному уроку).
Методы Canvas:
Методы для рисования простейшей графики - Arc, Chord, LineTo, Pie, Polygon, PolyLine, Rectangle, RoundRect. При прорисовке линий в этих методах используются карандаш (Pen) канвы, а для заполнения внутренних областей - кисть (Brush).
Методы для вывода картинок на канву - Draw и StretchDraw, В качестве параметров указываются прямоугольник и графический объект для вывода (это может быть TBitmap, TIcon или TMetafile). StretchDraw отличается тем, что растягивает или сжимает картинку так, чтобы она заполнила весь указанный прямоугольник (см. пример к данному уроку).
Методы для вывода текста - TextOut и TextRect. При выводе текста используется шрифт (Font) канвы. При использовании TextRect
текст выводится только внутри указанного прямоугольника. Длину и высоту текста можно узнать с помощью функций TextWidth и TextHeight.
Объект TPaintBox
На странице System Палитры Компонент есть объект TPaintBox, который можно использовать для построения приложений типа графического редактора или, например, в качестве места построения графиков (если, конечно, у Вас нет для этого специальных компонент третьих фирм). Никаких ключевых свойств, кроме Canvas, TPaintBox не имеет, собственно, этот объект является просто канвой для рисования. Важно, что координаты указателя мыши, передаваемые в обработчики соответствующих событий (OnMouseMove и др.), являются относительными, т.е. это смещение мыши относительно левого верхнего угла объекта TPaintBox, а не относительно левого верхнего угла формы.
Примеры ex05.zip В первом примере (проект SHAPE.DPR, рис.1) показано, как во время выполнения программы можно изменять свойства объекта TShape. Изменение цвета объекта (событие OnChange для ColorGrid1): procedure TForm1.ColorGrid1Change(Sender: TObject);
begin
Shape1.Brush.Color:=ColorGrid1.ForeGroundColor;
end;
Во втором примере (проект PIXELS.DPR, рис.2) показано, как осуществить доступ к отдельной точке на изображении (на канве). По нажатию кнопки “Fill” всем точкам изображения присваивается свой цвет:
procedure TForm1.Button1Click(Sender: TObject);
var
i, j : Longint;
begin
Button1.Enabled:=False;
with Canvas do
for i:=1 to Width do begin
Application.ProcessMessages;
for j:=1 to Height do
Pixels[i,j]:=i*j;
end;
Button1.Enabled:=True;
end;
В третьей программе (проект DRAW.DPR, рис.3) приведен пример использования методов, выводящих изображение - Draw и StretchDraw:
Прорисовка изображений происходит в обработчике события OnPaint для формы:
procedure TForm1.FormPaint(Sender: TObject);
begin
with Canvas do begin
Draw(0,0, Image1.Picture.BitMap);
StretchDraw(Rect(250,0,350,50),Image1.Picture.BitMap)
end;
end;
о возможных способах вывода информации
Содержание урока 6:
Обзор
Печать в текстовом режиме
Вывод содержимого формы на печать
Графическая печать (объект TPrinter)
Пример ex06.zip
Обзор
В данной статье рассказывается о возможных способах вывода информации на печать из программы, созданной в Delphi. Рассматривается вывод документа в текстовом режиме принтера, вывод графики с помощью объекта TPrinter и печать содержимого формы. О выводе на печать отчетов с помощью генератора отчетов ReportSmith рассказывается ниже.
Печать в текстовом режиме
Если Вам нужно напечатать на принтере документ в текстовом режиме, то это делается следующим образом. С принтером Вы работаете, как с обычным текстовым файлом, за исключением того, что вместо процедуры AssignFile нужно вызывать процедуру AssignPrn. В примере на принтер выводится одна строка текста: procedure TForm1.Button1Click(Sender: TObject);
var
To_Prn : TextFile;
begin
AssignPrn(To_Prn);
Rewrite(To_Prn);
Writeln(To_Prn, 'Printer in Text Mode');
CloseFile(To_Prn);
end;
Здесь необходимо, видимо, пояснить, что по сравнению с BP 7.0 в Delphi изменены названия некоторых функций и переменных в модуле System : AssignFile вместо Assign CloseFile вместо Close TextFile вместо Text Вывод содержимого формы на печать
Иногда в программе требуется просто получить твердую копию экранной формы. В Delphi это делается более, чем просто - у объекта TForm есть метод Print, который и нужно вызвать в нужный момент.
Графическая печать (объект TPrinter) И все же, более интересно, как из программы созданной в Delphi можно вывести на печать графическую информацию. Для этого есть специальный объект Printer (класса TPrinter). Он становится доступен, если к программе подключить модуль Printers (т.е. добавить имя модуля в разделе uses ). С помощью этого объекта печать на принтере графической информации становится не сложнее вывода этой информации на экран. Основным является то, что Printer
предоставляет разработчику свойство Canvas ( работа с канвой описана в предыдущем уроке) и методы, выводящие содержание канвы на принтер. Рассмотрим подробнее свойства и методы объекта Printer. Свойства Printer: Aborted - тип булевский; показывает, прервал ли пользователь работу принтера методом Abort.
Canvas - канва, место для вывода графики; работа с Canvas описана в Уроке 5.
Fonts - список доступных шрифтов.
Handle - используется при прямых вызовах Windows API.
Orientation - ориентация страницы, вертикально или горизонтально.
PageWidth, PageHeight, PageNumber - соответственно ширина, высота и номер страницы.
Printers перечисляет все установленные в системе принтеры, а
PrinterIndex указывает, какой из них является текущим. Чтобы печатать на принтере по умолчанию здесь должно быть значение -1.
Printing - тип булевский; показывает, начата ли печать (методом BeginDoc).
Title - заголовок для Print Manager и для заголовка перед выводом на сетевом принтере.
Методы Printer:
Abort - прерывает печать, начатую методом BeginDoc BeginDoc - вызывается перед тем, как начать рисовать на канве.
EndDoc - вызывается когда все необходимое уже нарисовано на канве, принтер начинает печатать именно после этого метода.
NewPage - переход на новую страницу. Остальными методами объекта в обычных случаях пользоваться не нужно.
Итак, порядок вывода на печать графической информации выглядит следующим образом: выполняется метод BeginDoc на канве (Canvas) рисуем все, что нужно при необходимости разместить информацию на нескольких листах вызываем метод NewPage посылаем нарисованное на принтер, выполняя метод EndDoc Пример ex06.zip В примере (проект PRINTS.DPR, рис.1 ) реализованы все три вышеописанных ситуации.
Каждый компонент, который Вы помещаете
Урок 7: Свойства в Delphi
Содержание урока 7:
Обзор
Управление свойствами визуальных компонент в режиме выполнения
Программа SHAPEDEM2 ex07.zip
Заключение Обзор Каждый компонент, который Вы помещаете на форму, имеет свое отражение в окне Инспектора Объектов (Object Inspector). Как Вы помните, Object Inspector имеет две “странички” - “Properties” (Свойства) и “Events” (События). Создание программы в Delphi сводится к “нанесению” компонент на форму (которая, кстати, также является компонентом) и настройке взаимодействия между ними путем: изменения значения свойств этих компонент написания адекватных реакций на события. Более подробно события мы рассмотрим на следующем уроке, а сейчас сосредоточимся на свойствах и, в меру необходимости, затронем создание откликов на события.
Как Вы уже успели, наверное, заметить, свойство является важным атрибутом компонента. Для пользователя (программиста) свойство выглядит как простое поле какой-либо структуры, содержащее некоторое значение. Однако, в отличие от “просто” поля, любое изменение значения некоторого свойства любого компонента сразу же приводит к изменению визуального представления этого компонента, поскольку свойство инкапсулирует в себе методы (действия), связанные с чтением и записью этого поля (которые, в свою очередь, включают в себя необходимую перерисовку). Свойства служат двум главным целям. Во-первых, они определяют внешний вид формы или компонента. А во-вторых, свойства определяют поведение формы или компонента.
Существует несколько типов свойств, в зависимости от их “природы”, т.е. внутреннего устройства. Простые свойства - это те, значения которых являются числами или строками. Например, свойства Left и Top принимают целые значения, определяющие положение левого верхнего угла компонента или формы. Свойства Caption и Name представляют собой строки и определяют заголовок и имя компонента или формы. Перечислимые свойства - это те, которые могут принимать значения из предопределенного набора (списка). Простейший пример - это свойство типа Boolean, которое может принимать значения True
или False. Вложенные свойства - это те, которые поддерживают вложенные значения (или объекты). Object Inspector изображает знак “+” слева от названия таких свойств. Имеется два вида таких свойств: множества и комбинированные значения. Object Inspector изображает множества в квадратных скобках. Если множество пусто, оно отображается как []. Установки для вложенных свойств вида “множество” обычно имеют значения типа Boolean. Наиболее распространенным примером такого свойства является свойство Style с вложенным множеством булевых значений. Комбинированные значения отображаются в Инспекторе Объектов как коллекция некоторых величин, каждый со своим типом данных (рис 1). Некоторые свойства, например, Font, для изменения своих значений имеют возможность вызвать диалоговое окно. Для этого достаточно щелкнуть маленькую кнопку с тремя точками в правой части строки Инспектора Объектов, показывающей данное свойство.
Delphi позволяет легко манипулировать свойствами компонент как в режиме проектирования (design time), так и в режиме выполнения программы (run time).
В режиме проектирования манипулирование свойствами осуществляется с помощью Дизайнера Форм (Forms Designer) или, как Вы уже видели, на страничке “Properties” Инспектора Объектов. Например, для того чтобы изменить свойства Height (высоту) и Width (ширину) кнопки, достаточно “зацепить” мышкой за любой ее угол и раздвинуть до нужного представления. Того же результата можно добиться, просто подставив новые значения свойств Height и Width в окне Object Inspector.
С другой стороны, в режиме выполнения пользователь (программист) имеет возможность не только манипулировать всеми свойствами, отображаемыми в Инспекторе Объектов, но и управлять более обширным их списком. В следующем разделе мы рассмотрим, как это делается.
Управление свойствами визуальных компонент в режиме выполнения
Все изменения значений свойств компонент в режиме выполнения должны осуществляться путем прямой записи строк кода на языке Паскаль. В режиме выполнения невозможно использовать Object Inspector. Однако, доступ к свойствам компонентов довольно легко получить программным путем. Все, что Вы должны сделать для изменения какого-либо свойства - это написать простую строчку кода аналогично следующей:
MyComponent.Width := 35;
Вышеприведенная строка устанавливает ширину (Width) компонента в значение 35. Если свойство Width компонента еще не было равно 35 к моменту выполнения данной строки программы, Вы увидите, как компонента визуально изменит свою ширину.
Таким образом, нет ничего магического в Инспекторе Объектов. Object Inspector просто является удобным способом выполнения в режиме проектирования того, что может быть осуществлено программным путем в режиме выполнения. Более того, как уже было сказано выше, у компонента могут быть свойства, не отображаемые в окне Инспектора Объектов.
Объектно-ориентированный язык Паскаль, лежащий в основе Delphi, в качестве базового имеет принцип соответствия визуальных компонент тем вещам, которые они представляют. Разработчики Delphi поставили перед собой цель, чтобы, например, представление компонента Button (кнопка), инкапсулирующее некий код, соответствовало визуальному изображению кнопки на экране и являлось как можно более близким эквивалентом реальной кнопки, которую Вы можете найти на клавиатуре. И именно из этого принципа родилось понятие свойства.
Если Вы измените свойства Width и Height компонента Button, кнопка соответствующим образом изменит свои ширину и высоту. Вам нет необходимости после изменения свойства Width указывать объекту, чтобы он перерисовал себя, хотя при обычном программировании именно так Вы и должны поступать. Свойства - это более чем просто данные. Напротив, они делают эти данные “живыми”, и все это происходит перед Вашими глазами! Свойства дают Вам иллюзию, как будто Вы имеете дело с реальными объектами, а не с их программным представлением.
Программа SHAPEDEM.DPR, изображенная на рис. 4, демонстрирует различные способы, с помощью которых можно изменять пользовательский интерфейс при выполнении программы. Эта программа не производит никаких полезных действий кроме демонстрации того, как легко можно создать “дельфийское” приложение с настраиваемым интерфейсом.
Программа SHAPEDEM содержит всего лишь объект TShape, размещенный на форме, вместе с двумя полосами прокрутки и несколькими кнопками. Эта программа интересна тем, что позволяет в режиме выполнения изменять размер, цвет и внешний вид объекта TShape, равно как размер и цвет самой формы.
Рис. 4: Программа SHAPEDEM имеет 2 полосы прокрутки и несколько кнопок
Листинг А показывает код программы SHAPEDEM. Код головного модуля этой программы мы приведем по частям - по мере его написания.
Листинг А: Исходный код программы SHAPEDEM.DPR.
program Shapedem;
uses
Forms,
Mina in 'MAIN.PAS' {Form1};
begin
Application.CreateForm(TForm1, Form1);
Application.Run;
end.
В нашем примере полосы прокрутки (ScrollBars) используются для изменения размера фигуры, изображенной в средней части экрана, как показано на рис.5. Для выбора нового вида фигуры используйте выпадающий список (ComboBox), а для изменения цвета фигуры или окна (формы) используйте стандартное диалоговое окно выбора цвета, вызываемое кнопками “Цвет фигуры” и “Цвет формы”.
Что нужно сделать пользователю (программисту) для того чтобы получить возможность “в режиме выполнения” изменять цвет какого-либо элемента или всего окна (формы)? Для этого достаточно выполнить всего лишь несколько действий. Убедитесь сами. Для изменения цвета окна просто выберите компонент ColorDialog из палитры компонентов (она находится на страничке “Dialogs”) и поместите его на форму. Кроме того, поместите на форму обычную кнопку (компонент Button, находится на страничке “Standard”). Для удобства чтения с помощью Object Inspector измените имя компонента (свойство Name) с “Button1” (которое дается по умолчанию) на “FormColor”, а его заголовок (свойство Caption) - на “Цвет формы”. Дважды щелкните по кнопке “Цвет формы” - Delphi сгенерирует заготовку метода, который выглядит следующим образом:
procedure TForm1.FormColorClick(Sender: TObject);
begin
end;
Теперь введите две простые строчки кода:
procedure TForm1.FormColorClick(Sender: TObject);
begin
if ColorDialog1.Execute then
Form1.Color := ColorDialog1.Color;
end;
Данный код во время выполнения при нажатии кнопки “Цвет формы” вызывает стандартное диалоговое окно выбора цвета, как показано на рис.6.Если в этом диалоговом окне Вы щелкните кнопку OK, выполнится следующая строка:
Form1.Color:=ColorDialog1.Color;
Этот код установит свойство Color формы Form1 в цвет, который был выбран с помощью диалогового окна ColorDialog1. Это очень просто!!!
Та же самая техника может использоваться для изменения цвета фигуры (компонент Shape, объект TShape). Все, что Вам нужно сделать - это поместить на форму другую кнопку, изменить (при желании) ее имя на “ShapeColor”, а заголовок - на “Цвет Фигуры”, дважды щелкнуть по ней мышкой и создать метод аналогичный следующему:
procedure TForm1.ShapeColorClick(Sender: TObject);
begin
if ColorDialog1.Execute then
Shape1.Brush.Color := ColorDialog1.Color;
end;
Что может быть проще?!!
Отметим, что код, написанный здесь, является самодокументированным. Т.е. любой, мало-мальски знакомый с программированием человек сможет без особого труда разобраться, что же делают эти строки; а если он перед этим прочтет документацию, то для него вообще все будет прозрачно.
Все эти действия можно проделать и автоматически - например, можно изменить цвет определенного элемента формы, чтобы привлечь внимание пользователя к какому-либо действию.
Весь механизм Windows-сообщений, используемый при взаимодействии компонент во время выполнения, оказывается скрытым от программиста, делая процесс создания программ наиболее легким. Сложное программирование в среде Windows становится доступным “широким” массам программистов. Например, программирование изменения размера фигуры с помощью полос прокрутки, требовавшее в “чистом” Windows сложной обработки сообщений в конструкции типа “case”, в Delphi сводится к написанию одной-единственной строчки кода.
Для начала, поместите два компонента ScrollBar на форму (находится на страничке “Standard”) и установите свойство Kind первого компонента в sbHorizontal, а второго - в sbVertical. Переключитесь на страничку “Events” в Инспекторе Объектов и создайте заготовки метода для отклика на событие OnChange для каждой полосы прокрутки. Напишите в каждом из методов по одной строчке следующим образом:
procedure TForm1.ScrollBar1Change(Sender: TObject);
begin
Shape1.Width := ScrollBar1.Position * 3;
end;
procedure TForm1.ScrollBar2Change(Sender: TObject);
begin
Shape1.Height := ScrollBar2.Position * 2;
end;
Код, показанный здесь, устанавливает свойства Width и Height фигуры TShape в соответствие с положением “бегунка” на полосах прокрутки (сомножители 3 и 2 введены только для лучшего представления).
Последняя часть программы SHAPEDEM демонстрирует большие возможности языка Object Pascal, на основе которого построен Delphi. Вы можете ввести элементы в список компонента ComboBox как в режиме проектирования, так и при выполнении программы. При этом в режиме проектирования Вы можете просто ввести нужные элементы в список Items, щелкнув маленькую кнопку с тремя точками в правой части строки Инспектора Объектов, показывающей данное свойство (Items).
Перед Вами появится диалоговое окно текстового редактора (String List Editor), в котором Вы и введете элементы (рис.7). Вы могли заметить, что список этих элементов совпадает со списком опций свойства Shape компонента Shape1 (Shape). Другими словами, если Вы выделите компонент Shape1 на форме (просто щелкнув по нему) и посмотрите свойство Shape в Инспекторе Объектов, Вы увидите список возможных видов фигур, которые может принимать данный компонент. Это как раз те самые виды фигур, которые мы перечисляли в списке у компонента ComboBox1. Этот список Вы можете найти в on-line справочнике по Delphi по контексту “TShapeType”. Или же, если Вы заглянете в исходный код класса TShape, там увидите те же элементы, формирующие перечислимый тип TShapeType:
TShapeType = (stRectangle, stSquare, stRoundRect,
stRoundSquare, stEllipse, stCircle);
Итак, смысл всего сказанного в том, что за всеми объектами, которые Вы видите в “дельфийской” программе, стоит некий код на Паскале, к которому Вы имеете доступ при “прямом” программировании. Ничто не скрыто от Вас. Это значит, что Вы можете изменить поведение любой части Вашей программы во время выполнения путем написания соответствующего кода.
В нашем конкретном случае, Вам нужно написать только одну строчку кода, которая будет выполнена в качестве отклика на щелчок пользователем по выпадающему списку ComboBox1. Чтобы написать код этого отклика, в режиме проектирования выделите компонент ComboBox1 на форме (как всегда, просто щелкнув по нему левой кнопкой мыши), затем перейдите на страничку “Events” в Инспекторе Объектов. Дважды щелкните по пустому полю напротив события OnClick. В редакторе автоматически сгенерируется следующая заготовка метода:
procedure TForm1.ComboBox1Click(Sender: TObject);
begin
end;
Теперь вставьте одну строчку кода, чтобы метод выглядел следующим образом:
procedure TForm1.ComboBox1Click(Sender: TObject);
begin
Shape1.Shape := TShapeType(ComboBox1.ItemIndex);
end;
Эта строчка кода устанавливает свойство Shape компонента Shape1 в вид, который пользователь выберет в выпадающем списке. Этот код работает благодаря соответствию между порядковыми членами перечислимого типа и числовыми значениями различных элементов в ComboBox. Другими словами, первый элемент перечислимого типа имеет значение 0, что соответствует первому элементу, показанному в ComboBox (см. рис.7). Давайте рассмотрим этот подход несколько подробней.
Если Вы рассмотрите декларацию перечислимого типа TShapeType, Вы увидите, что первый его элемент называется “stRectangle”. По определению, компилятор назначает этому элементу порядковый номер 0. Следующему по порядку элементу назначается номер 1 и т.д. Таким образом, слова “stRectangle”, “stSquare” и т.п., в действительности, просто символизируют порядковые номера в данном перечислимом типе. На элементы в списке ComboBox также можно сослаться по их порядковому номеру, начиная с 0. Именно поэтому так важно (в данном случае) вводить указанные строки в строгом соответствии с декларацией типа TShapeType. Таким образом, используя преобразование типа “TShapeType(ComboBox1.ItemIndex)”, Вы можете указать компилятору, что общего имеют элементы в ComboBox
и перечислимый тип в TShapeType: а именно, порядковые номера. Итак, Вы видите, что Delphi является очень гибким и мощным программным средством, которое позволяет Вам быстро реализовать логику Вашей программы и предоставляет полное управление приложением. Программа SHAPEDEM2 Программа SHAPEDEM проста в написании и в освоении. Однако при изменении пользователем размера окна она будет выглядеть “некрасиво”. Давайте изменим ее таким образом, чтобы программа сама обрабатывала изменение размера окна, а заодно изучим компонент меню. Для достижения этих целей сделаем следующее: Кнопки и выпадающий список уберем с экрана и вместо них поместим на форму компонент меню (MainMenu) “Заставим” полосы прокрутки изменять свое положение в зависимости от размера окна “Заставим” свойство Position полос прокрутки изменяться, чтобы правильно отражать размер формы. Взглянув на рис.8, Вы сможете увидеть, как будет выглядеть программа после этих изменений.
Рис. 8: Программа SHAPDEM2 имеет возможность реагировать на изменение пользователем размера окна
Листинг B: Программа SHAPDEM2 включает метод FormOnResize. Представлен главный модуль.
unit Main;
interface
uses
WinTypes, WinProcs, Classes, Graphics, Forms, Controls, ColorDlg, StdCtrls, Menus, Dialogs, ExtCtrls;
type
TForm1 = class(TForm)
Shape1: TShape;
ColorDialog1: TColorDialog;
ScrollBar1: TScrollBar;
ScrollBar2: TScrollBar;
MainMenu1: TMainMenu;
Shapes1: TMenuItem;
ShapeColor1: TMenuItem;
FormColor1: TMenuItem;
Shapes2: TMenuItem;
Rectangle1: TMenuItem;
Square1: TMenuItem;
RoundRect1: TMenuItem;
RoundSquare1: TMenuItem;
Ellipes1: TMenuItem;
Circle1: TMenuItem;
Exit1: TMenuItem;
procedure NewShapeClick(Sender: TObject);
procedure ShapeColorClick(Sender: TObject);
procedure FormColorClick(Sender: TObject);
procedure ScrollBar2Change(Sender: TObject);
procedure ScrollBar1Change(Sender: TObject);
procedure FormResize(Sender: TObject);
procedure Exit1Click(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;
var
Form1: TForm1;
implementation
{$R *.DFM}
procedure TForm1.NewShapeClick(Sender: TObject);
begin
Shape1.Shape := TShapeType((Sender as TMenuItem).Tag);
end;
procedure TForm1.ShapeColorClick(Sender: TObject);
begin
if ColorDialog1.Execute then
Shape1.Brush.Color := ColorDialog1.Color;
end;
procedure TForm1.FormColorClick(Sender: TObject);
begin
if ColorDialog1.Execute then
Form1.Color := ColorDialog1.Color;
end;
procedure TForm1.ScrollBar2Change(Sender: TObject);
begin
Shape1.Height := ScrollBar2.Position;
end;
procedure TForm1.ScrollBar1Change(Sender: TObject);
begin
Shape1.Width := ScrollBar1.Position;
end;
procedure TForm1.FormResize(Sender: TObject);
var
Menu,
Caption,
Frame: Integer;
begin
Caption := GetSystemMetrics(sm_cyCaption);
Frame := GetSystemMetrics(sm_cxFrame) * 2;
Menu := GetSystemMetrics(sm_cyMenu);
Scrollbar1.Max := Width;
Scrollbar2.Max := Height;
Scrollbar2.Left := Width - Frame - Scrollbar2.Width;
Scrollbar1.Top := Height - ScrollBar2.Width - Frame - Caption - Menu;
Scrollbar1.Width := Width - Scrollbar2.Width - Frame;
Scrollbar2.Height := Height - Frame - Caption - Menu - Scrollbar1.Height;
end; procedure TForm1.Exit1Click(Sender: TObject);
begin
Close;
end;
end.
Главное меню для программы создается с помощью компонента MainMenu (находится на страничке “Standard” палитры компонентов). Поместив его на форму, дважды щелкните по нему мышкой - откроется редактор меню, в котором Вы сможете ввести нужные Вам названия пунктов меню и, при желании, изменить их имена (задаваемые Delphi по умолчанию) для удобочитаемости. Создадим меню программы SHAPEDEM2 с тремя главными пунктами: “Цвета”, “Фигуры”, “Выход”.
Для первого пункта создадим следующие подпункты: Цвет фигуры Цвет окна Для второго: Прямоугольник Квадрат Закругленный прямоугольник Закругленный квадрат Эллипс Окружность Третий пункт меню не будет содержать никаких подпунктов.
После создания всех пунктов и подпунктов меню для работы программы SHAPEDEM2 нужно назначить номера для каждого из подпунктов меню, связанных с типом фигуры. Для этого воспользуемся свойством Tag, имеющимся у каждого пункта меню. Свойство Tag
(типа Integer) специально введено в каждый компонент Delphi с тем, чтобы программисты могли использовать его по своему усмотрению. Назначим 0 свойству Tag пункта “Прямоугольник”, 1 - пункту “Квадрат”, 2 - пункту “Закругленный прямоугольник” и т.д. Цель такого назначения будет объяснена позднее. Два метода, созданные для подпунктов изменения цвета аналогичны тем, которые были в программе SHAPEDEM:
procedure TForm1.ShapeColorClick(Sender: TObject);
begin
if ColorDialog1.Execute then
Shape1.Brush.Color := ColorDialog1.Color;
end;
procedure TForm1.FormColorClick(Sender: TObject);
begin
if ColorDialog1.Execute then
Form1.Color := ColorDialog1.Color;
end;
Как Вы видите, ничего не изменилось по сравнению с первой версией программы, хотя данные методы уже вызываются из меню, а не из кнопок.
Аналогично, методы, реализующие реакцию на выбор подпунктов меню изменения вида фигуры также очень похожи на методы выбора фигуры через выпадающий список:
procedure TForm1.NewShapeClick(Sender: TObject);
begin
Shape1.Shape := TShapeType((Sender as TMenuItem).Tag);
end;
Этот код “работает” правильно благодаря тому, что перечислимый тип TShapeType в качестве начального имеет значение 0 и в свойство Tag подпунктов меню мы также записали порядковые номера, начинающиеся с нуля.
Отметим, что мы использовали оператор as, который позволяет надежно преобразовывать типы из одного в другой: в частности, преобразовать параметр Sender (имеющий общий тип TObject) в тип TMenuItem. Как правило, параметр Sender в Delphi - это управляющий элемент, посылающий сообщения функции, в которой он фигурирует. В данном случае, Sender является пунктом меню, и, следовательно, Вы можете работать с этим параметром как если бы он был декларирован с типом TMenuItem.
Главная причина использования оператора as состоит в том, что он обеспечивает очень ясный синтаксис, даже если Вы проводите сложное двухуровневое преобразование типов. Более того, оператор as обеспечивает проверку преобразования в режиме выполнения программы. Когда Вы используете оператор as, Вы можете быть уверены в том, что преобразование Sender
в TMenuItem реально будет произведено лишь в том случае, если Sender действительно имеет тип TMenuItem. Две полосы прокрутки в программе SHAPEDEM2 всегда будут располагаться возле границ окна, независимо от его размеров. Выполнение этих действий требует от Вас написания несколько более сложного программирования, чем было ранее. Как было указано ранее, Delphi, хотя и скрывает от программиста детали Windows-программирования, однако не запрещает обращаться к функциям Windows API (прикладного пользовательского интерфейса). Таким образом, Delphi поддерживает низкоуровневое программирование на уровне Windows API. Короче говоря, если Вам нужно углубиться в дебри низкоуровневого программирования - пожалуйста!
procedure TForm1.FormResize(Sender: TObject);
var
Menu,
Caption,
Frame: Integer;
begin
Caption := GetSystemMetrics(sm_cyCaption);
Frame := GetSystemMetrics(sm_cxFrame) * 2;
Menu := GetSystemMetrics(sm_cyMenu);
Scrollbar1.Max := Width;
Scrollbar2.Max := Height;
Scrollbar2.Left := Width - Frame - Scrollbar2.Width;
Scrollbar2.Height := Height - Frame - Caption - Menu;
Scrollbar1.Top :=
Height - Scrollbar2.Width - Frame - Caption - Menu;
Scrollbar1.Width := Width - Scrollbar2.Width - Frame;
end;
Код, показанный здесь, является реакцией на событие OnResize. Это событие перечислено среди других на страничке “Events” Инспектора Объектов в состоянии, когда выбрана форма (окно). Как Вы можете ожидать, событие (сообщение) OnResize посылается форме (окну) каждый раз, когда пользователь “захватывает” мышкой за какой-либо край окна и делает размер окна большим или меньшим. Однако, это же сообщение (событие) посылается окну и тогда, когда происходит максимизация окна (но не минимизация).
Первое, что делается в данном методе - запрашиваются системные параметры, определяющие размеры заголовка окна, огибающей его рамки и меню. Эта информация “добывается” путем вызова функции GetSystemMetrics, являющейся частью Windows API. Функции GetSystemMetrics передается один аргумент в виде константы, определяющей вид запрашиваемой информации. Например, если Вы передадите функции константу sm_cyCaption, получите в качестве результата высоту заголовка окна (в пикселах). Полный список этих констант имеется в on-line справочнике Delphi (Help|Windows API|Alphabetical functions|User functions|GetSystemMetrics), здесь же мы приведем небольшую выдержку из справочника:
SM_CXBORDER Ширина огибающей окно рамки, размер которой не может быть изменен. SM_CYBORDER Высота огибающей окно рамки, размер которой не может быть изменен.
SM_CYCAPTION Высота заголовка окна, включая высоту огибающей окно рамки, размер которой не может быть изменен (SM_CYBORDER).
SM_CXCURSOR Ширина курсора.
SM_CYCURSOR Высота курсора.
SM_CXFRAME Ширина огибающей окно рамки, размер которой может быть изменен.
SM_CYFRAME Высота огибающей окно рамки, размер которой может быть изменен.
SM_CXFULLSCREEN Ширина клиентской части для полноэкранного окна.
SM_CYFULLSCREEN Высота клиентской части для полноэкранного окна (эквивалентна высоте экрана за вычетом высоты заголовка окна).
SM_CXICON Ширина иконки.
SM_CYICON Высота иконки.
SM_CYMENU Высота полосы меню в одну строку. Это высота меню за вычетом высоты огибающей окно рамки, размер которой не может быть изменен (SM_CYBORDER).
SM_CXMIN Минимальная ширина окна.
SM_CYMIN Минимальная высота окна.
SM_CXSCREEN Ширина экрана.
SM_CYSCREEN Высота экрана.
SM_MOUSEPRESENT Не 0, если мышь установлена.
В методе FormResize программа вычисляет новые размеры полос прокрутки:
Scrollbar1.Max := Width;
Scrollbar2.Max := Height;
Scrollbar2.Left := Width - Frame - Scrollbar2.Width;
Scrollbar2.Height := Height - Frame - Caption - Menu;
Scrollbar1.Top :=
Height - Scrollbar2.Width - Frame - Caption - Menu;
Scrollbar1.Width := Width - Scrollbar2.Width - Frame;
Вычисления, приведенные здесь, включают простые математические действия. Например, левая сторона вертикальной полосы прокрутки должна быть равна ширине всего окна (формы) за вычетом ширины рамки и ширины самой полосы прокрутки. Это элементарная логика, и реализовав ее в программе, мы получим вертикальную полосу прокрутки, всегда располагающуюся возле правого края окна (формы).
В программе SHAPEDEM свойство Max каждой полосы прокрутки оставалось равным значению по умолчанию - 100; это означало, что после того как бегунок полосы прокрутки пройдет все доступное расстояние (как для вертикальной, так и для горизонтальной полосы прокрутки), свойство Position
будет установлено в 100. Если бегунок возвращался к началу, свойство Position устанавливалось равным свойству Min, которое, по умолчанию, 0. В программе SHAPEDEM2 Вы можете изменять значения свойств Min и Max так, чтобы диапазон значений Position полос прокрутки отражал текущий размер окна (формы), даже при изменении формой своего размера в режиме выполнения. Здесь приведены соответствующие строки из метода FormResize.
procedure TForm1.FormResize(Sender: TObject);
begin
...
Scrollbar1.Max := Width;
Scrollbar2.Max := Height;
...
end;
Две строчки кода, показанные выше, просто устанавливают максимальные значения полос прокрутки равными ширине и высоте формы соответственно. После этого Вы всегда сможете сделать помещенную на форму фигуру такой же “большой”, как и сама форма. После введения таких изменений Вам больше не потребуется умножать свойство Position на какой-либо множитель.
procedure TForm1.Scrollbar2Change (Sender: TObject);
begin
Shape1.Height := Scrollbar2.Position;
end;
Если Вы после этого запустите программу SHAPDEM2 на выполнение, Вы увидите, что она работает корректно при любом изменении размера формы. Более того, теперь Вы можете выбирать фигуры и цвета из меню, что придает программе более строгий вид.
В конце хотелось бы сделать одно маленькое замечание. Как Вы, возможно, уже заметили, каждая форма, по умолчанию, имеет две полосы прокрутки (HorzScrollbar и VertScrollbar), которые появляются автоматически всякий раз, когда размер формы становится меньше, чем область, занимаемая управляющими элементами, расположенными на этой форме. Иногда эти полосы прокрутки могут быть очень полезными, но в нашей ситуации они сделают совсем не то, что хотелось бы. Поэтому, для надежности, Вы можете установить их вложенные свойства Visible в False. Заключение В этом уроке мы рассмотрели, как изменять свойства компонент во время выполнения. В целом, такие действия не намного сложнее, чем изменение свойств в режиме проектирования с помощью Object Inspector. В конце раздела Вы могли увидеть, что язык Object Pascal, лежащий в основе Delphi, дает Вам полное управление над работой приложения, включая прямое обращение к функциям Windows API.
и почувствовать все преимущества Delphi,
32 урока по Delphi
Методы в Delphi Содержание урока 8:
Обзор
Создание методов с помощью визуальных средств
Передача параметров
Более сложные методы и управляющие элементы
Информация периода выполнения. Программа CONTROL3 ex08.zip
Заключение
Обзор
Чтобы полностью понять и почувствовать все преимущества Delphi, Вам нужно хорошо изучить язык Object Pascal. И хотя возможности визуальной части Delphi чрезвычайно богаты, хорошим программистом может стать только тот, кто хорошо разбирается в технике ручного написания кода.
По мере обсуждения темы данного раздела мы рассмотрим несколько простых примеров, которые, тем не менее, демонстрируют технику использования важных управляющих элементов Windows. Создание методов с помощью визуальных средств
В предыдущем уроке Вы видели, что синтаксический “скелет” метода может быть сгенерирован с помощью визуальных средств. Для этого, напомним, нужно в Инспекторе Объектов дважды щелкнуть мышкой на пустой строчке напротив названия интересующего Вас события в требуемом компоненте. Заметим, если эта строчка не пуста, то двойной щелчок на ней просто переместит Вас в окне Редактора Кода в то место, где находится данный метод.
Для более глубокого понимания дальнейшего изложения кратко остановимся на концепции объектно-ориентированного программирования. Для начала определим базовое понятие объектно-ориентированного программирования - класс. Класс - это категория объектов, обладающих одинаковыми свойствами и поведением. При этом объект представляет собой просто экземпляр какого-либо класса. Например, в Delphi тип “форма” (окно) является классом, а переменная этого типа - объектом. Метод - это процедура, которая определена как часть класса и инкапсулирована (содержится) в нем. Методы манипулируют полями и свойствами классов (хотя могут работать и с любыми переменными) и имеют автоматический доступ к любым полям и методам своего класса. Доступ к полям и методам других классов зависит от уровня “защищенности” этих полей и методов. Пока же для нас важно то, что методы можно создавать как визуальными средствами, так и путем написания кода вручную.
Давайте рассмотрим процесс создания программы CONTROL1, которая поможет нам изучить технику написания методов в Delphi.
Теперь перейдите в Object Inspector, выберите страничку “Events” и дважды щелкните в пустой строчке напротив события OnDblClick, как показано на 8. После этого в активизировавшемся окне Редактора Вы увидите сгенерированный “скелет” метода Edit1DblClick, являющегося реакцией на событие OnDblClick:
procedure TForm1.Edit1DblClick(Sender: TObject);
begin
end;
После генерации процедуры Вы можете оставить ее имя таким, каким “установил” Delphi, или изменить его на любое другое (для этого просто введите новое имя в указанной выше строке Инспектора Объектов справа от требуемого события и нажмите Enter).
Теперь в окне Редактора Кода введите смысловую часть метода:
procedure TForm1.Edit1DblClick(Sender: TObject);
begin
Edit1.Text:= 'Вы дважды щелкнули в строке редактирования';
end;
Сохраните программу. Во время выполнения дважды щелкните на строке редактирования. Текст в этой строке изменится в соответствии с тем, что мы написали в методе Edit1DblClick: см. 8.
Рис. -C: Содержимое управляющего элемента TEdit изменяется после двойного щелчка по нему
8 и 8 предоставляют полный код программы CONTROL1.
Листинг -A: Программа CONTROL1 демонстрирует, как создавать и использовать методы в Delphi.
program Control1;
uses
Forms,
Main in 'MAIN.PAS' {Form1};
begin
Application.CreateForm(TForm1, Form1);
Application.Run;
end.
Листинг -B: Головной модуль программы CONTROL1.
unit Main;
interface
uses
WinTypes, WinProcs,
Classes, Graphics, Controls,
Printers, Menus, Forms, StdCtrls;
type
TForm1 = class(TForm)
Edit1: TEdit;
procedure Edit1DblClick(Sender: TObject);
end;
var
Form1: TForm1;
implementation
{$R *.DFM}
procedure TForm1.Edit1DblClick(Sender: TObject);
begin
Edit1.Text := 'Вы дважды щелкнули в строке редактирования';
end;
end. После того, как Ваша программа загрузится в память, выполняются две строчки кода в CONTROL1.DPR, автоматически сгенерированные компилятором:
Application.CreateForm(TForm1, Form1);
Application.Run;
Первая строка запрашивает память у операционной системы и создает там объект Form1, являющийся экземпляром класса TForm1. Вторая строка указывает объекту Application, “по умолчанию” декларированному в Delphi, чтобы он запустил на выполнение главную форму приложения. В данном месте мы не будем подробно останавливаться на классе TApplication и на автоматически создаваемом его экземпляре - Application. Важно понять, что главное его предназначение - быть неким ядром, управляющим выполнением Вашей программы.
Как правило, у большинства примеров, которыми мы будем оперировать в наших уроках, файлы проектов .DPR практически одинаковы. Поэтому в дальнейшем там, где они не отличаются кардинально друг от друга, мы не будем приводить их текст. Более того, в файл .DPR, автоматически генерируемый Delphi, в большинстве случаев нет необходимости заглядывать, поскольку все действия, производимые им, являются стандартными.
Итак, мы видели, что большинство кода Delphi генерирует автоматически. В большинстве приложений все, что Вам остается сделать - это вставить одну или несколько строк кода, как в методе Edit1DblClick:
Edit1.Text := 'Вы дважды щелкнули в строке редактирования';
Хотя внешний интерфейс программы CONTROL1 достаточно прост, она (программа) имеет строгую внутреннюю структуру. Каждая программа в Delphi состоит из файла проекта, имеющего расширение .DPR и одного или нескольких модулей, имеющих расширение .PAS. Модуль, в котором содержится главная форма проекта, называется головным. Указанием компилятору о связях между модулями является предложение Uses, которое определяет зависимость модулей.
Нет никакого функционального различия между модулями, созданными Вам в Редакторе, и модулями, сгенерированными Delphi автоматически. В любом случае модуль подразделяется на три секции:
·Заголовок
·Секция Interface
·Секция Implementation
Таким образом, “скелет” модуля выглядит следующим образом:
unit Main; {Заголовок модуля}
interface {Секция Interface}
implementation {Секция Implementation}
end.
В интерфейсной секции (interface) описывается все то, что должно быть видимо для других модулей (типы, переменные, классы, константы, процедуры, функции). В секции implementation помещается код, реализующий классы, процедуры или функции. Передача параметров В Delphi процедурам и функциям (а, следовательно, и методам классов) могут передаваться параметры для того, чтобы обеспечить их необходимой для работы информацией. Программа PARAMS демонстрирует, как использовать передачу параметров в методы Delphi. Кроме того, мы узнаем, как: ·создавать свои собственные процедуры
·добавлять процедуру в класс, формируя метод класса
·вызывать одну процедуру из другой. Программа PARAMS позволяет Вам вводить фразы в строки редактирования. После нажатия кнопки “Вызов процедуры WriteAll” строка из управляющего элемента EditSource скопируется в шесть управляющих элементов - строк редактирования, как показано на 8.
Далее мы не будем подробно останавливаться на том, как размещать компоненты на форме - считаем, что это Вы уже умеете. После того как Вы разместили на форме семь компонентов Edit, переименуйте с помощью Инспектора Объектов седьмой компонент (Edit7) в EditSource. Положите на форму компонент Button, и в Object Inspector измените его заголовок (свойство Caption) на “Вызов процедуры WriteAll” (естественно, Вы можете заменить его шрифт, цвет и т.д.).
После завершения проектирования формы класс TForm1 будет выглядеть следующим образом:
TForm1 = class(TForm)
Edit1: TEdit;
Edit2: TEdit;
Edit3: TEdit;
Edit4: TEdit;
Edit5: TEdit;
Edit6: TEdit;
EditSource: TEdit;
Button1: TButton;
end;
Следующий шаг состоит в добавлении метода, вызываемого по нажатию пользователем кнопки Button1. Это, напомним, можно сделать двумя способами:
Перейти в Инспекторе Объектов на страничку “Events” (предварительно выбрав компонент Button1 на форме), выбрать слово OnClick и дважды щелкнуть мышкой на пустой строчке справа от него Просто дважды щелкнуть на компоненте Button1 на форме. Delphi сгенерирует следующую “заготовку”: procedure TForm1.Button1Click(Sender: TObject);
begin
end;
Цель программы PARAMS - научить Вас писать процедуры и передавать в них параметры. В частности, программа PARAMS реагирует на нажатие кнопки Button1 путем вызова процедуры WriteAll и передачи ей в качестве параметра содержимого строки редактирования EditSource (EditSource.Text).
procedure TForm1.Button1Click(Sender: TObject);
begin
WriteAll(EditSource.Text);
end;
Важно понять, что объект EditSource является экземпляром класса TEdit и, следовательно, имеет свойство Text, содержащее набранный в строке редактирования текст. Как Вы уже, наверное, успели заметить, по умолчанию свойство Text содержит значение, совпадающее со значением имени компонента (Name) - в данном случае “EditSource”. Свойство Text Вы, естественно, можете редактировать как в режиме проектирования, так и во время выполнения.
Текст, который должен быть отображен в шести строках редактирования, передается процедуре WriteAll как параметр. Чтобы передать параметр процедуре, просто напишите имя этой процедуры и заключите передаваемый параметр (параметры) в скобки - вот так:
WriteAll(EditSource.Text);
Заголовок этой процедуры выглядит следующим образом:
procedure TForm1.WriteAll(NewString: String);
где указано, что передаваемый процедуре параметр NewString должен иметь тип String.
Вспомним, что задача процедуры WriteAll состоит в копировании содержимого строки редактирования EditSource в шесть других строк редактирования Edit1-Edit6. Поэтому процедура должна выглядеть следующим образом:
procedure TForm1.WriteAll(NewString: String);
begin
Edit1.Text := NewString;
Edit2.Text := NewString;
Edit3.Text := NewString;
Edit4.Text := NewString;
Edit5.Text := NewString;
Edit6.Text := NewString;
end; Поскольку процедура WriteAll не является откликом на какое-либо событие в Delphi, то ее нужно полностью написать “вручную”. Простейший способ сделать это - скопировать заголовок какой-либо уже имеющейся процедуры, исправить его, а затем дописать необходимый код.
Возвратимся еще раз к заголовку процедуры. Заголовок состоит из пяти частей:
procedure TForm1.WriteAll(NewString: String); · Первая часть - зарезервированное слово “procedure”; пятая часть - концевая точка с запятой “;”. Обе эти части служат определенным синтаксическим целям, а именно: первая информирует компилятор о том, что определен синтаксический блок “процедура”, а вторая указывает на окончание заголовка (собственно говоря, все операторы в Delphi должны заканчиваться точкой с запятой).
· Вторая часть заголовка - слово “TForm1”, которое квалифицирует то обстоятельство, что данная процедура является методом класса TForm1.
· Третья часть заголовка - имя процедуры. Вы можете выбрать его любым, по вашему усмотрению. В данном случае мы назвали процедуру “WriteAll”.
· Четвертая часть заголовка - параметр. Параметр декларируется внутри скобок и, в свою очередь, состоит из двух частей. Первая часть - имя параметра, вторая - его тип. Эти части разделены двоеточием. Если Вы описываете в процедуре более чем один параметр, нужно разделить их точкой с запятой, например:
procedure Example(Param1: String; Param2: String);
После того как Вы создали “вручную” заголовок процедуры, являющейся методом класса, Вы должны включить его в декларацию класса, например, путем копирования (еще раз напомним, что для методов, являющихся откликами на дельфийские события, данное включение производится автоматически):
TForm1 = class(TForm)
Edit1: TEdit;
Edit2: TEdit;
Edit3: TEdit;
Edit4: TEdit;
Edit5: TEdit;
Edit6: TEdit;
EditSource: TEdit;
Button1: TButton;
procedure Button1Click(Sender: TObject);
procedure WriteAll(NewString: String);
end;
В данном месте нет необходимости оставлять в заголовке метода слово “TForm1”, так как оно уже присутствует в описании класса.
8 показывает полный текст головного модуля программы PARAMS. Мы не включили сюда файл проекта, поскольку, как уже упоминалось, он практически одинаков для всех программ.
Листинг -C: Исходный код головного модуля программы PARAMS показывает, как использовать строки редактирования и как передавать параметры.
Unit Main;
interface
uses
WinTypes, WinProcs, Classes,
Graphics, Controls,
Printers, Forms, StdCtrls;
type
TForm1 = class(TForm)
Edit1: TEdit;
Edit2: TEdit;
Edit3: TEdit;
Edit4: TEdit;
Edit5: TEdit;
Edit6: TEdit;
EditSource: TEdit;
Button1: TButton;
procedure Button1Click(Sender: TObject);
procedure WriteAll(NewString: String);
end;
var
Form1: TForm1;
implementation
{$R *.DFM}
procedure TForm1.WriteAll(NewString: String);
begin
Edit1.Text := NewString;
Edit2.Text := NewString;
Edit3.Text := NewString;
Edit4.Text := NewString;
Edit5.Text := NewString;
Edit6.Text := NewString;
end;
procedure TForm1.Button1Click(Sender: TObject);
begin
WriteAll(EditSource.Text);
end;
end.
При экспериментах с программой PARAMS Вы можете попробовать изменить имена процедур и параметров. Однако, следует помнить, что ряд слов в Delphi являются зарезервированными, и употреблять их в идентификаторах (именах процедур, функций, переменных, типов, констант) не разрешается - компилятор сразу же обнаружит ошибку. К ним относятся такие слова, как “procedure”, “string”, “begin”, “end” и т.п.; полный же список их приведен в on-line справочнике Delphi.
Не старайтесь запомнить сразу все зарезервированные слова - компилятор “напомнит” Вам о неправильном их использовании выдачей сообщения типа “Identifier expected.” (Ожидался идентификатор, а обнаружено зарезервированное слово). Более сложные методы и управляющие элементы Теперь, когда Вы освоили базовые понятия в системе программирования Delphi, можно продолжить изучение компонент и способов создания их методов.
В программе CONTROL1, рассмотренной в начале урока, был сгенерирован метод, являющийся откликом на событие OnClick строки редактирования Edit1. Аналогично, можно сгенерировать метод, являющийся реакцией на событие OnDblClick. В программе CONTROL2, имеющейся на диске, расширен список находящихся на форме компонентов и для многих из них определены события OnClick
и OnDblClick. Для исследования Вы можете просто скопировать файлы проекта CONTROL1 в новую директорию CONTROL2, изменить имя проекта на CONTROL2.DPR (в этом файле после ключевого слова “program” также должно стоять название “CONTROL2”) и добавить компоненты Label, GroupBox, CheckBox, RadioButton, Button на форму (эти компоненты находятся на страничке “Standard” Палитры Компонентов). Ваша форма будет иметь примерно следующий вид - 8.
Выберите объект Label1. Создайте для него метод, являющийся откликом на событие OnDblClick (см. стр. *). Введите в метод одну строчку, например:
procedure TForm1.Label1DblClick(Sender: TObject);
begin
Edit1.Text := 'Двойной щелчок на Label1';
end;
Запустите программу на выполнение и дважды щелкните мышкой на метке Label1. Вы увидите, что строка редактирования изменится, и в ней появится текст “Двойной щелчок на Label1”.
Теперь закройте приложение и возвратитесь в режим проектирования. Добавьте обработчики событий OnClick и OnDblClick для каждого объекта, имеющегося на форме. Текст вашего головного модуля будет выглядеть следующим образом:
Листинг -D: Головной модуль программы CONTROL2.
Unit Main;
interface
uses
WinTypes, WinProcs, Classes,
Graphics, Controls, StdCtrls,
Printers, Menus, Forms;
type
TForm1 = class(TForm)
Label1: TLabel;
Edit1: TEdit;
Button1: TButton;
GroupBox1: TGroupBox;
CheckBox1: TCheckBox;
CheckBox2: TCheckBox;
RadioButton1: TRadioButton;
RadioButton2: TRadioButton;
procedure Edit1DblClick(Sender: TObject);
procedure Label1DblClick(Sender: TObject);
procedure CheckBox1Click(Sender: TObject);
procedure CheckBox2Click(Sender: TObject);
procedure RadioButton1Click(Sender: TObject);
procedure RadioButton2Click(Sender: TObject);
procedure Button1Click(Sender: TObject);
end;
var
Form1: TForm1;
implementation
{$R *.DFM}
procedure TForm1.Edit1DblClick(Sender: TObject);
begin
Edit1.Text := 'Двойной щелчок на Edit1';
end;
procedure TForm1.Label1DblClick(Sender: TObject);
begin
Edit1.Text := 'Двойной щелчок на Label1';
end ;
procedure TForm1.CheckBox1Click(Sender: TObject);
begin
Edit1.Text := 'Щелчок на CheckBox1';
end;
procedure TForm1.CheckBox2Click(Sender: TObject);
begin
Edit1.Text := 'Щелчок на CheckBox2';
end;
procedure TForm1.RadioButton1Click(Sender: TObject);
begin
Edit1.Text := 'Щелчок на RadioButton1';
end;
procedure TForm1.RadioButton2Click(Sender: TObject);
begin
Edit1.Text := 'Щелчок на Radiobutton2';
end;
procedure TForm1.Button1Click(Sender: TObject);
begin
Edit1.Text := 'Щелчок на Button1';
end;
end.
Эта программа служит двум целям: Она показывает, как создавать процедуры (методы) и как “наполнять” их содержательной “начинкой” Она демонстрирует технику работы с управляющими элементами Windows. Информация периода выполнения. Программа CONTROL3 Как Вы, наверное, заметили, методы программы CONTROL2, являющиеся откликами на события OnClick
и OnDblClick, во многом похожи друг на друга. Открытость среды Delphi позволяет получать и оперировать информацией особого рода, называемой информацией периода выполнения (RTTI - run-time type information). Эта информация организована в виде нескольких уровней.
Верхний уровеньRTTI представлен как средство проверки и приведения типов с использованием ключевых слов is и as.
Ключевое слово is дает программисту возможность определить, имеет ли данный объект требуемый тип или является одним из наследников данного типа, например, таким образом:
if MyObject is TSomeObj then ...
Имеется возможность использовать RTTI и для процесса приведения объектного типа, используя ключевое слово as:
if MyObject is TSomeObj then
(MyObject as TSomeObj).MyField:=...
что эквивалентно:
TSomeObj(MyObject).MyField:=...
Средний уровень RTTI использует методы объектов и классов для подмены операций as и is на этапе компиляции. В основном, все эти методы заложены в базовом классе TObject, от которого наследуются все классы библиотеки компонент VCL. Для любого потомка TObject доступны, в числе прочих, следующие информационные методы: ClassName - возвращает имя класса, экземпляром которого является объект ClassInfo - возвращает указатель на таблицу с RTTI, содержащей информацию о типе объекта, типе его родителя, а также о всех его публикуемых свойствах, методах и событиях ClassParent - возвращает тип родителя объекта ClassType - возвращает тип самого объекта InheritsFrom - возвращает логическое значение, определяющее, является ли объект потомком указанного класса InstanceSize - возвращает размер объекта в байтах. Эти методы могут использоваться в Вашем коде напрямую.
Нижний уровень RTTI определяется в дельфийском модуле TypInfo и представляет особый интерес для разработчиков компонент. Через него можно получить доступ к внутренним структурам Delphi, в том числе, к ресурсам форм, инспектору объектов и т.п.
Итак, доступ к информации периода выполнения в Delphi позволяет динамически получать как имя объекта, находящегося на форме, так и название класса, которому он принадлежит (и еще много другой полезной информации; но об этом - в дальнейших уроках). Для этого используется свойство Name, имеющееся у любого класса-наследника TComponent
( а таковыми являются все компоненты, входящие в дельфийскую библиотеку VCL), и метод ClassName, доступный для любого потомка класса базового TObject. А, поскольку класс TComponent, в свою очередь, является наследником класса TObject, то он доступен для всех компонент из библиотеки VCL. Вернувшись к нашим примерам, мы можем заменить целую “кучу” методов двумя, реализующими события OnClick и OnDblClick для всех объектов сразу. Для этого можно скопировать все файлы из CONTROL2 в новый директорий CONTROL3 или использовать для работы уже имеющуюся на диске программу. Создадим стандартным образом методы ControlDblClick и ControlClick для какого-либо объекта (например, для Label1). Введем в них следующие строки:
procedure TForm1.ControlDblClick(Sender: TObject);
begin
Edit1.Text := 'Двойной щелчок на ' +
(Sender as TComponent).Name +
' (класс ' + Sender.ClassName + ')';
end;
procedure TForm1.ControlClick(Sender: TObject);
begin
Edit1.Text := 'Щелчок на ' +
(Sender as TComponent).Name +
' (класс ' + Sender.ClassName + ')';
end;
Теперь назначим данные методы всем событиям OnClick и OnDblClick, имеющимся у расположенных на форме объектов. Мы видим, что размер программы существенно сократился, а функциональность ее значительно выросла. В режиме выполнения после, например, щелчка на объекте CheckBox1 приложение будет иметь вид, изображенный на 8.
Итак, мы видим, что используя информацию периода выполнения, можно сделать программу очень гибкой и универсальной.
Заключение В этом уроке мы рассмотрели, как управлять методами компонент во время выполнения программы. Кроме того, мы изучили, как что такое информация периода выполнения и научились использовать ее в целях создания гибких и универсальных приложений.
в Delphi введены новые расширения
Урок 9 : Обработка исключительных ситуаций в Delphi
Содержание урока 9:
Обзор
Структурная обработка исключительных ситуаций
Модель исключительных ситуаций в Delphi
Синтаксис обработки исключительных ситуаций
Примеры обработки исключительных ситуаций
Вызов исключительной ситуации
Доступ к экземпляру объекта exception
Предопределенные обработчики исключительных ситуаций
Исключения, возникающие при работе с базами данных
Заключение
Обзор
С целью поддержки структурной обработки исключительных ситуаций (exception) в Delphi введены новые расширения языка Pascal. В данной статье будет дано описание того, что из себя представляет такая обработка, почему она полезна, будут приведены соответствующий синтаксис Object Pascal и примеры использования исключительных ситуаций в Delphi. Структурная обработка исключительных ситуаций
Структурная обработка исключительных ситуаций - это система, позволяющая программисту при возникновении ошибки (исключительной ситуации) связаться с кодом программы, подготовленным для обработки такой ошибки. Это выполняется с помощью языковых конструкций, которые как бы “охраняют” фрагмент кода программы и определяют обработчики ошибок, которые будут вызываться, если что-то пойдет не так в “охраняемом” участке кода. В данном случае понятие исключительной ситуации относится к языку и не нужно его путать с системными исключительными ситуациями (hardware exceptions), такими как General Protection Fault. Эти исключительные ситуации обычно используют прерывания и особые состояния “железа” для обработки критичной системной ошибки; исключительные ситуации в Delphi же независимы от “железа”, не используют прерываний и используются для обработки ошибочных состояний, с которыми подпрограмма не готова иметь дело. Системные исключительные ситуации, конечно, могут быть перехвачены и преобразованы в языковые исключительные ситуации, но это только одно из применений языковых исключительных ситуаций.
При традиционной обработке ошибок, ошибки, обнаруженные в процедуре обычно передаются наружу (в вызывавшую процедуру) в виде возвращаемого значения функции, параметров или глобальных переменных (флажков). Каждая вызывающая процедура должна проверять результат вызова на наличие ошибки и выполнять соответствующие действия. Часто, это просто выход еще выше, в более верхнюю вызывающую процедуру и т.д. : функция A вызывает B, B вызывает C, C обнаруживает ошибку и возвращает код ошибки в B, B проверяет возвращаемый код, видит, что возникла ошибка и возвращает код ошибки в A, A проверяет возвращаемый код и выдает сообщение об ошибке либо решает сделать что-нибудь еще, раз первая попытка не удалась.
Такая “пожарная бригада” для обработки ошибок трудоемка, требует написания большого количества кода в котором можно легко ошибиться и который трудно отлаживать.
Одна ошибка в коде программы или переприсвоение в цепочке возвращаемых значений может привести к тому, что нельзя будет связать ошибочное состояние с положением дел во внешнем мире. Результатом будет ненормальное поведение программы, потеря данных или ресурсов, или крах системы.
Структурная обработка исключительной ситуации замещает ручную обработку ошибок автоматической, сгенерированной компилятором системой уведомления. В приведенном выше примере, процедура A установила бы “охрану” со связанным обработчиком ошибки на фрагмент кода, в котором вызывается B. B просто вызывает C. Когда C обнаруживает ошибку, то создает (raise) исключительную ситуацию. Специальный код, сгенерированный компилятором и встроенный в Run-Time Library (RTL) начинает поиск обработчика данной исключительной ситуации. При поиске “защищенного” участка кода используется информация, сохраненная в стеке. В процедурах C и B нет такого участка, а в A - есть. Если один из обработчиков ошибок, которые используются в A, подходит по типу для возникшей в C исключительной ситуации, то программа переходит на его выполнение. При этом, область стека, используемая в B и C, очищается; выполнение этих процедур прекращается.
Если в A нет подходящего обработчика, то поиск продолжается в более верхнем уровне, и так может идти, пока поиск не достигнет подходящего обработчика ошибок среди используемых по умолчанию обработчиков в RTL. Обработчики ошибок из RTL только показывают сообщение об ошибке и форсированно прекращают выполнение программы. Любая исключительная ситуация, которая осталась необработанной, приведет к прекращению выполнения приложения.
Без проверки возвращаемого кода после каждого вызова подпрограммы, код программы должен быть более простым, а скомпилированный код - более быстрым. При наличии исключительных ситуаций подпрограмма B не должна содержать дополнительный код для проверки возвращаемого результата и передачи его в A. B ничего не должна делать для передачи исключительной ситуации, возникшей в C, в процедуру A - встроенная система обработки исключительных ситуаций делает всю работу.
Данная система называется структурной, поскольку обработка ошибок определяется областью “защищенного” кода; такие области могут быть вложенными. Выполнение программы не может перейти на произвольный участок кода; выполнение программы может перейти только на обработчик исключительной ситуации активной программы. Модель исключительных ситуаций в Delphi
Модель исключительных ситуаций в Object Pascal является невозобновляемой(non-resumable). При возникновении исключительной ситуации Вы уже не сможете вернуться в точку, где она возникла, для продолжения выполнения программы (это позволяет сделать возобновляемая(resumable) модель). Невозобновляемые исключительные ситуации разрушают стек, поскольку они сканируют его в поисках обработчика; в возобновляемой модели необходимо сохранять стек, состояние регистров процессора в точке возникновения ошибки и выполнять поиск обработчика и его выполнение в отдельном стеке. Возобновляемую систему обработки исключительных ситуаций гораздо труднее создать и применять, нежели невозобновляемую.
Синтаксис обработки исключительных ситуаций Теперь, когда мы рассмотрели, что такое исключительные ситуации, давайте дадим ясную картину, как они применяются. Новое ключевое слово, добавленное в язык Object Pascal - try. Оно используется для обозначения первой части защищенного участка кода. Существует два типа защищенных участков:
try..except try..finally Первый тип используется для обработки исключительных ситуаций. Его синтаксис:
try
Statement 1;
Statement 2;
...
except
on Exception1 do Statement;
on Exception2 do Statement;
...
else
Statements; {default exception-handler}
end;
Для уверенности в том, что ресурсы, занятые вашим приложением, освободятся в любом случае, Вы можете использовать конструкцию второго типа. Код, расположенный в части finally, выполняется в любом случае, даже если возникает исключительная ситуация. Соответствующий синтаксис:
try
Statement1;
Statement2;
...
finally
Statements; { These statements always execute }
end;
Примеры обработки исключительных ситуаций
Ниже приведены процедуры A,B и C, обсуждавшиеся ранее, воплощенные в новом синтаксисе Object Pascal:
type
ESampleError = class(Exception);
var
ErrorCondition: Boolean;
procedure C;
begin
writeln('Enter C');
if (ErrorCondition) then
begin
writeln('Raising exception in C');
raise ESampleError.Create('Error!');
end;
writeln('Exit C');
end;
procedure B;
begin
writeln('enter B');
C;
writeln('exit B');
end;
procedure A;
begin
writeln('Enter A');
try
writeln('Enter A''s try block');
B;
writeln('After B call');
except
on ESampleError do
writeln('Inside A''s ESampleError handler');
on ESomethingElse do
writeln('Inside A''s ESomethingElse handler');
end;
writeln('Exit A');
end;
begin
writeln('begin main');
ErrorCondition := True;
A;
writeln('end main');
end.
При ErrorCondition = True программа выдаст:
begin main
Enter A
Enter A's try block
enter B
Enter C
Raising exception in C
Inside A's ESampleError handler
Exit A
end main
Возможно вас удивила декларация типа 'ESampleError =class' вместо '=object'; это еще одно новое расширение языка. Delphi вводит новую модель объектов, доступную через декларацию типа '=class'. Описание новой объектной модели дается в других уроках. Здесь же достаточно сказать, что исключительные ситуации (exceptions) являются классами, частью новой объектной модели.
Процедура C проверяет наличие ошибки ( в нашем случае это значение глобальной переменной) и, если она есть (а это так), C вызывает(raise) исключительную ситуацию класса ESampleError.
Процедура A помещает часть кода в блок try..except. Первая часть этого блока содержит часть кода, аналогично конструкции begin..end. Эта часть кода завершается ключевым словом except, далее следует один или более обработчиков исключительных ситуаций on xxxx do yyyy, далее может быть включен необязательный блок else, вся конструкция заканчивается end;. В конструкции, назначающей определенную обработку для конкретной исключительной ситуации (on xxxx do yyyy), после резервного слова on указывается класс исключительной ситуации, а после do следует собственно код обработки данной ошибки. Если возникшая исключительная ситуация подходит по типу к указанному после on, то выполнение программы переходит сюда (на код после do). Исключительная ситуация подходит в том случае, если она того же класса, что указан в on, либо является его потомком. Например, в случае on EFileNotFound обрабатываться будет ситуация, когда файл не найден. А в случае on EFileIO - все ошибки при работе с файлами, в том числе и предыдущая ситуация. В блоке else обрабатываются все ошибки, не обработанные до этого.
Приведенные в примере процедуры содержат код (строка с writeln), который отображает путь выполнения программы. Когда C вызывает exception, программа сразу переходит на обработчик ошибок в процедуре A, игнорируя оставшуюся часть кода в процедурах B и C.
После того, как найден подходящий обработчик ошибки, поиск оканчивается. После выполнения кода обработчика, программа продолжает выполняться с оператора, стоящего после слова end блока try..except (в примере - writeln('Exit A')).
Конструкция try..except подходит, если известно, какой тип ошибок нужно обрабатывать в конкретной ситуации. Но что делать, если требуется выполнить некоторые действия в любом случае, произошла ошибка или нет? Это тот случай, когда понадобится конструкция try..finally.
Рассмотрим модифицированную процедуру B:
procedure NewB;
var
P: Pointer;
begin
writeln('enter B');
GetMem(P, 1000);
C;
FreeMem(P, 1000);
writeln('exit B');
end;
Если C вызывает исключительную ситуацию, то программа уже не возвращается в процедуру B. А что же с теми 1000 байтами памяти, захваченными в B? Строка FreeMem(P,1000) не выполнится и Вы потеряете кусок памяти. Как это исправить? Нужно ненавязчиво включить процедуру B в процесс, например:
procedure NewB;
var
P: Pointer;
begin
writeln('enter NewB');
GetMem(P, 1000);
try
writeln('enter NewB''s try block');
C;
writeln('end of NewB''s try block');
finally
writeln('inside NewB''s finally block');
FreeMem(P, 1000);
end;
writeln('exit NewB');
end;
Если в A поместить вызов NewB вместо B, то программа выведет сообщения следующим образом:
begin main
Enter A
Enter A's try block
enter NewB
enter NewB's try block
Enter C
Raising exception in C
inside NewB's finally block
Inside A's ESampleError handler
Exit A
end main
Код в блоке finally выполнится при любой ошибке, возникшей в соответствующем блоке try. Он же выполнится и в том случае, если ошибки не возникло. В любом случае память будет освобождена. Если возникла ошибка, то сначала выполняется блок finally, затем начинается поиск подходящего обработчика. В штатной ситуации, после блока finally программа переходит на следующее предложение после блока.
Почему вызов GetMem не помещен внутрь блока try? Этот вызов может окончиться неудачно и вызвать exception EOutOfMemory. Если это произошло, то FreeMem попытается освободить память, которая не была распределена. Когда мы размещаем GetMem вне защищаемого участка, то предполагаем, что B сможет получить нужное количество памяти, а если нет, то более верхняя процедура получит уведомление EOutOfMemory.
А что, если требуется в B распределить 4 области памяти по схеме все-или-ничего? Если первые две попытки удались, а третья провалилась, то как освободить захваченную область память? Можно так:
procedure NewB;
var
p,q,r,s: Pointer;
begin
writeln('enter B');
P := nil;
Q := nil;
R := nil;
S := nil;
try
writeln('enter B''s try block');
GetMem(P, 1000);
GetMem(Q, 1000);
GetMem(R, 1000);
GetMem(S, 1000);
C;
writeln('end of B''s try block');
finally
writeln('inside B''s finally block');
if P <> nil then FreeMem(P, 1000);
if Q <> nil then FreeMem(Q, 1000);
if R <> nil then FreeMem(R, 1000);
if S <> nil then FreeMem(S, 1000);
end;
writeln('exit B');
end;
Установив сперва указатели в NIL, далее можно определить, успешно ли прошел вызов GetMem.
Оба типа конструкции try можно использовать в любом месте, допускается вложенность любой глубины. Исключительную ситуацию можно вызывать внутри обработчика ошибки, конструкцию try можно использовать внутри обработчика исключительной ситуации. Вызов исключительной ситуации
В процедуре C из примера мы уже могли видеть, как должна поступать программа при обнаружении состояния ошибки - она вызывает исключительную ситуацию:
raise ESampleError.Create(‘Error!’);
После ключевого слова raise следует код, аналогичный тому, что используется для создания нового экземпляра класса. Действительно, в момент вызова исключительной ситуации создается экземпляр указанного класса; данный экземпляр существует до момента окончания обработки исключительной ситуации и затем автоматически уничтожается. Вся информация, которую нужно сообщить в обработчик ошибки передается в объект через его конструктор в момент создания.
Почти все существующие классы исключительных ситуаций являются наследниками базового класса Exception и не содержат новых свойств или методов. Класс Exception имеет несколько конструкторов, какой из них конкретно использовать - зависит от задачи. Описание класса Exception можно найти в on-line Help.
Доступ к экземпляру объекта exception
До сих пор мы рассматривали механизмы защиты кода и ресурсов, логику работы программы в исключительной ситуации. Теперь нужно немного разобраться с тем, как же обрабатывать возникшую ошибку. А точнее, как получить дополнительную информацию о коде ошибки, текст сообщения и т.п.
Как уже говорилось, при вызове исключительной ситуации (raise) автоматически создается экземпляр соответствующего класса, который и содержит информацию об ошибке. Весь вопрос в том, как в обработчике данной ситуации получить доступ к этому объекту.
Рассмотрим модифицированную процедуру A в нашем примере:
procedure NewA;
begin
writeln('Enter A');
try
writeln('Enter A''s try block');
B;
writeln('After B call');
except
on E: ESampleError do writeln(E.Message);
on ESomethingElse do
writeln('Inside A''s ESomethingElse handler');
end;
writeln('Exit A');
end;
Здесь все изменения внесены в строку
on ESE: ESampleError do writeln(ESE.Message);
Пример демонстрирует еще одно новшество в языке Object Pascal - создание локальной переменной. В нашем примере локальной переменной является ESE - это тот самый экземпляр класса ESampleError, который был создан в процедуре C в момент вызова исключительного состояния. Переменная ESE доступна только внутри блока do. Свойство Message объекта ESE содержит сообщение, которое было передано в конструктор Create в процедуре C.
Есть еще один способ доступа к экземпляру exception - использовать функцию ExceptionObject:
on ESampleError do
writeln(ESampleError(ExceptionObject).Message);
Предопределенные обработчики исключительных ситуаций Ниже Вы найдете справочную информацию по предопределенным исключениям, необходимую для профессионального программирования в Delphi.
Exception - базовый класс-предок всех обработчиков исключительных ситуаций. EAbort - “скрытое” исключение. Используйте его тогда, когда хотите прервать тот или иной процесс с условием, что пользователь программы не должен видеть сообщения об ошибке. Для повышения удобства использования в модуле SysUtils предусмотрена процедура Abort, определенная, как: procedure Abort;
begin
raise EAbort.CreateRes(SOperationAborted) at ReturnAddr;
end; EComponentError - вызывается в двух ситуациях: 1) при попытке регистрации компоненты за пределами процедуры Register;
2) когда имя компоненты не уникально или не допустимо. EConvertError - происходит в случае возникновения ошибки при выполнении функций StrToInt и StrToFloat, когда конвертация строки в соответствующий числовой тип невозможна. EInOutError - происходит при ошибках ввода/вывода при включенной директиве {$I+}. EIntError - предок исключений, случающихся при выполнении целочисленных операций. EDivByZero - вызывается в случае деления на ноль, как результат RunTime Error 200. EIntOverflow - вызывается при попытке выполнения операций, приводящих к переполнению целых переменных, как результат RunTime Error 215 при включенной директиве {$Q+}. ERangeError - вызывается при попытке обращения к элементам массива по индексу, выходящему за пределы массива, как результат RunTime Error 201 при включенной директиве {$R+}. EInvalidCast - происходит при попытке приведения переменных одного класса к другому классу, несовместимому с первым (например, приведение переменной типа TListBox к TMemo). EInvalidGraphic - вызывается при попытке передачи в LoadFromFile файла, несовместимого графического формата. EInvalidGraphicOperation - вызывается при попытке выполнения операций, неприменимых для данного графического формата (например, Resize для TIcon). EInvalidObject - реально нигде не используется, объявлен в Controls.pas. EInvalidOperation - вызывается при попытке отображения или обращения по Windows-обработчику (handle) контрольного элемента, не имеющего владельца (например, сразу после вызова MyControl:=TListBox.Create(...) происходит обращение к методу Refresh). EInvalidPointer - происходит при попытке освобождения уже освобожденного или еще неинициализированного указателя, при вызове Dispose(), FreeMem() или деструктора класса. EListError - вызывается при обращении к элементу наследника TList по индексу, выходящему за пределы допустимых значений (например, объект TStringList содержит только 10 строк, а происходит обращение к одиннадцатому).
EMathError - предок исключений, случающихся при выполнении операций с плавающей точкой. EInvalidOp - происходит, когда математическому сопроцессору передается ошибочная инструкция. Такое исключение не будет до конца обработано, пока Вы контролируете сопроцессор напрямую из ассемблерного кода. EOverflow - происходит как результат переполнения операций с плавающей точкой при слишком больших величинах. Соответствует RunTime Error 205. Underflow - происходит как результат переполнения операций с плавающей точкой при слишком малых величинах. Соответствует RunTime Error 206. EZeroDivide - вызывается в результате деления на ноль. EMenuError - вызывается в случае любых ошибок при работе с пунктами меню для компонент TMenu, TMenuItem, TPopupMenu и их наследников. EOutlineError - вызывается в случае любых ошибок при работе с TOutLine и любыми его наследниками. EOutOfMemory - происходит в случае вызовов New(), GetMem() или конструкторов классов при невозможности распределения памяти. Соответствует RunTime Error 203. EOutOfResources - происходит в том случае, когда невозможно выполнение запроса на выделение или заполнение тех или иных Windows ресурсов (например таких, как обработчики - handles). EParserError - вызывается когда Delphi не может произвести разбор и перевод текста описания формы в двоичный вид (часто происходит в случае исправления текста описания формы вручную в IDE Delphi). EPrinter - вызывается в случае любых ошибок при работе с принтером. EProcessorException - предок исключений, вызываемых в случае прерывания процессора- hardware breakpoint. Никогда не включается в DLL, может обрабатываться только в “цельном” приложении. EBreakpoint - вызывается в случае останова на точке прерывания при отладке в IDE Delphi. Среда Delphi обрабатывает это исключение самостоятельно. EFault - предок исключений, вызываемых в случае невозможности обработки процессором тех или иных операций. EGPFault - вызывается, когда происходит “общее нарушение защиты” - General Protection Fault. Соответствует RunTime Error 216.
EInvalidOpCode - вызывается, когда процессор пытается выполнить недопустимые инструкции. EPageFault - обычно происходит как результат ошибки менеджера памяти Windows, вследствие некоторых ошибок в коде Вашего приложения. После такого исключения рекомендуется перезапустить Windows. EStackFault - происходит при ошибках работы со стеком, часто вследствие некорректных попыток доступа к стеку из фрагментов кода на ассемблере. Компиляция Ваших программ со включенной проверкой работы со стеком {$S+} помогает отследить такого рода ошибки. ESingleStep - аналогично EBreakpoint, это исключение происходит при пошаговом выполнении приложения в IDE Delphi, которая сама его и обрабатывает. EPropertyError - вызывается в случае ошибок в редакторах свойств, встраиваемых в IDE Delphi. Имеет большое значение для написания надежных property editors. Определен в модуле DsgnIntf.pas. EResNotFound - происходит в случае тех или иных проблем, имеющих место при попытке загрузки ресурсов форм - файлов .DFM в режиме дизайнера. Часто причиной таких исключений бывает нарушение соответствия между определением класса формы и ее описанием на уровне ресурса (например,вследствие изменения порядка следования полей-ссылок на компоненты, вставленные в форму в режиме дизайнера). EStreamError - предок исключений, вызываемых при работе с потоками. EFCreateError - происходит в случае ошибок создания потока (например, при некорректном задании файла потока). EFilerError - вызывается при попытке вторичной регистрации уже зарегистрированного класса (компоненты). Является, также, предком специализированных обработчиков исключений, возникающих при работе с классами компонент. EClassNotFound - обычно происходит, когда в описании класса формы удалено поле-ссылка на компоненту, вставленную в форму в режиме дизайнера. Вызывается, в отличие от EResNotFound, в RunTime. EInvalidImage - вызывается при попытке чтения файла, не являющегося ресурсом, или разрушенного файла ресурса, специализированными функциями чтения ресурсов (например, функцией ReadComponent).
EMethodNotFound - аналогично EClassNotFound, только при несоответствии методов, связанных с теми или иными обработчиками событий. EReadError - происходит в том случае, когда невозможно прочитать значение свойства или другого набора байт из потока (в том числе ресурса). EFOpenError - вызывается когда тот или иной специфированный поток не может быть открыт (например, когда поток не существует). EStringListError - происходит при ошибках работы с объектом TStringList (кроме ошибок, обрабатываемых TListError).
Исключения, возникающие при работе с базами данных Delphi, обладая прекрасными средствами доступа к данным, основывающимися на интерфейсе IDAPI, реализованной в виде библиотеки Borland Database Engine (BDE), включает ряд обработчиков исключительных ситуаций для регистрации ошибок в компонентах VCL работающим с БД. Дадим краткую характеристику основным из них: EDatabaseError - наследник Exception ; происходит при ошибках доступа к данным в компонентах-наследниках TDataSet. Объявлено в модуле DB. Ниже приведен пример из Delphi On-line Help, посвященный этому исключению: repeat {пока не откроем таблицу или не нажмем кнопку Cancel} try
Table1.Active := True; {Пытаемся открыть таблицу}
Break; { Если нет ошибки - прерваем цикл}
except
on EDatabaseError do
{Если нажата OK - повторяем попытку открытия Table1}
if MessageDlg('Не могу открыть Table1', mtError,
[mbOK, mbCancel], 0) <> mrOK
then
raise;
end;
until False; EDBEngineError - наследник EDatabaseError ; вызывается, когда происходят ошибки BDE или на сервере БД. Объявлено в модуле DB: EDBEngineError = class(EDatabaseError)
private
FErrors: TList;
function GetError(Index: Integer): TDBError;
function GetErrorCount: Integer;
public
constructor Create(ErrorCode: DBIResult);
destructor Destroy;
property ErrorCount: Integer;
property Errors[Index: Integer]: TDBError;
end;
Особенно важны два свойства класса EDBEngineError :
Errors - список всех ошибок, находящихся в стеке ошибок BDE. Индекс первой ошибки 0;
ErrorCount - количество ошибок в стеке.
Объекты, содержащиеся в Errors, имеют тип TDBError. Доступные свойства класса TDBError:
ErrorCode - код ошибки, возвращаемый Borland Database Engine;
Category - категория ошибки, описанной в ErrorCode;
SubCode - ‘субкод’ ошибки из ErrorCode;
NativeError - ошибка, возвращаемая сервером БД. Если NativeError 0, то ошибка в ErrorCode не от сервера;
Message - сообщение, переданное сервером, если NativeError не равно 0; сообщение BDE - в противном случае. EDBEditError - наследник Exception ; вызывается, когда данные не совместимы с маской ввода, наложенной на поле. Объявлено в модуле Mask. Заключение Данный урок должен был дать вам достаточно информации для того, чтобы начать исследование того, как Вы можете использовать систему обработки исключительных ситуаций в вашей программе. Вы, конечно, можете обрабатывать ошибки и без привлечения этой системы; но с ней Вы получите лучшие результаты с меньшими усилиями.
Одна из ключевых целей среды
Содержание урока 10:
Обзор
События в Delphi
Понимание событий
Обработка сообщений Windows в Delphi
Обзор
Одна из ключевых целей среды визуального программирования - скрыть от пользователя сложность программирования в Windows. При этом, однако, хочется, чтобы такая среда не была упрощена слишком, не до такой степени, что программисты потеряют доступ к самой операционной системе.
Программирование, ориентированное на события - неотъемлемая черта Windows. Некоторые программные среды для быстрой разработки приложений (RAD) пытаются скрыть от пользователя эту черту совсем, как будто она настолько сложна, что большинство не могут ее понять. Истина заключается в том, что событийное программирование само по себе не так уж сложно. Однако, есть некоторые особенности воплощения данной концепции в Windows, которые в некоторых ситуациях могут вызвать затруднения.
Delphi предоставляет полный доступ к подструктуре событий, предоставляемой Windows. С другой стороны, Delphi упрощает программирование обработчиков таких событий.
В данном уроке приводится несколько примеров того, как обрабатывать события в Delphi, дается более детальное объяснение работы системы, ориентированной на события. События в Delphi
Объекты из библиотеки визуальных компонент (VCL) Delphi, равно как и объекты реального мира, имеют свой набор свойств и свое поведение - набор откликов на события, происходящие с ними. Список событий для данного объекта, на которые он реагирует, можно посмотреть, например, в Инспекторе Объектов на странице событий. (На самом деле, на этой странице представлен список свойств, которые имеют тип вроде TMouseMoveEvent и представляют из себя процедуры-обработчики событий. Существует соглашение по названиям данных свойств. Например, OnDblClick соответствует двойному щелчку мыши, а OnKeyUp - событию, когда нажатая клавиша была отпущена.) Среди набора событий для различных объектов из VCL есть как события, портируемые из Windows (MouseMove, KeyDown), так и события, порождаемые непосредственно в программе (DataChange для TDataSource).
Поведение объекта определяется тем, какие обработчики и для каких событий он имеет. Создание приложения в Delphi состоит из настройки свойств используемых объектов и создания обработчиков событий.
Простейшие события, на которые иногда нужно реагировать - это, например, события, связанные с мышкой (они есть практически у всех видимых объектов) или событие Click для кнопки TButton. Предположим, что вы хотите перехватить щелчок левой кнопки мыши на форме. Чтобы сделать это - создайте новый проект, в Инспекторе Объектов выберите страницу событий и сделайте двойной щелчок на правой части для свойства OnClick. Вы получите заготовку для обработчика данного события:
procedure TForm1.FormClick(Sender: TObject);
begin
end;
Напишите здесь следующее:
procedure TForm1.FormClick(Sender: TObject);
begin
MessageDlg('Hello', mtInformation, [mbOk], 0);
end;
Каждый раз , когда делается щелчок левой кнопки мыши над формой будет появляться окно диалога (см. рис.1).
Рис.1: Диалог, появляющийся при щелчке мыши на форме.
Код, приведенный выше, представляет из себя простейший случай ответа на событие в программе на Delphi. Он настолько прост, что многие программисты могут написать такой код и без понимания того, что они на самом деле отвечают на сообщение о событии, посланное им операционной системой. Хотя программист получает это событие через третьи руки, тем не менее он на него отвечает.
Опытные программисты в Windows знают, что при возникновении события, операционная система передает вам не только уведомление о нем, но и некоторую связанную с ним информацию. Например, при возникновении события “нажата левая кнопка мыши” программа информируется о том, в каком месте это произошло. Если вы хотите получить доступ к такой информации, то должны вернуться в Инспектор Объектов и создать обработчик события OnMouseDown:
procedure TForm1.FormMouseDown(Sender: TObject;
Button: TMouseButton;
Shift: TShiftState;
X, Y: Integer);
begin
Canvas.TextOut(X, Y, 'X='+IntToStr(X)+' Y='+IntToStr(Y));
end;
Запустите программу, пощелкайте мышкой на форме:
Рис.2
Как видите, в Delphi очень просто отвечать на события. И не только на события, связанные с мышкой. Например, можно создать обработчик для OnKeyDown (нажата клавиша):
procedure TForm1.FormKeyDown(Sender: TObject;
var Key: Word;
Shift: TShiftState);
begin
MessageDlg(Chr(Key), mtInformation, [mbOk], 0);
end;
Теперь, когда вы имеете начальные знания о программировании событий в Delphi, самое время вернуться назад и посмотреть на теорию, стоящую за тем кодом, что вы написали. После получения представления о том, как работает система, можно вернуться к среде Delphi и посмотреть, как использовать полностью имеющиеся возможности. Понимание событий Событийное программирование есть не только в Windows, и данную черту можно реализовать не только в операционной системе. Например, любая DOS программа может быть основана на простом цикле, работающем все время жизни программы в памяти. Ниже вы найдете гипотетический пример, как данный код может выглядеть:
begin
InitializeMemory;
repeat
CheckForMouseEvent(Events);
CheckForKeyPress(Events)
HandleEvents(Events);
until Done := True;
DisposeMemory;
end.
Это типичный пример программы, ориентированной на события. Она начинается и заканчивается инициализацией и освобождением памяти. В программе присутствует простой цикл repeat..until, который проверяет появление событий от мыши и клавиатуры и затем дает возможность программисту ответить на эти события.
Переменная Events может быть записью с простой структурой:
TEvent = record
X, Y: Integer;
MouseButton: TButton;
Key: Word;
end;
Тип TButton, указанный выше, можно декларировать так:
TButton = (lButton, rButton);
Эти структуры позволяют вам проследить, где находится мышь, каково состояние ее кнопок, и значение нажатой клавиши на клавиатуре. Конечно, это пример очень простой структуры, но заложенные здесь принципы отражают то, что происходит внутри Windows или внутри других систем, ориентированных на события, вроде Turbo Vision. Если бы программа, приведенная выше, была редактором текста, то обработчик HandleEvent для такой программы мог бы иметь вид:
procedure HandleEvent(Events: TEvent);
begin
case Events.Key of
’A’..’z’: Write(Events.Key);
EnterKey: Write(CarriageReturn);
EscapeKey: Done := True;
end;
end;
Согласно коду выше, программа будет печатать букву ‘a’ при нажатии этой клавиши и перейдет на новую строку, если нажата клавиша ‘Enter’. Нажатие ‘Esc’ приведет к завершению программы.
Код такого типа может быть очень удобным, в частности, если вы пишете программу, в которой требуется анимация. Например, если нужно перемещать несколько картинок по экрану, то может понадобиться сдвинуть их на несколько точек, затем проверить, нажимал ли пользователь кнопки. Если такое событие было, то его можно обработать, если нет, то двигать дальше.
Надеюсь, что приведенный пример дает некоторое понимание работы ориентированной на события системы. Единственное, что осталось пропущенным - почему система Windows так спроектирована.
Одной из основных причин, почему Microsoft сделал Windows по такой схеме, является тот факт, что множество задач работает в среде одновременно. В многозадачных системах операционная система должна знать, щелкнул ли пользователь мышкой на определенное окно. Если это окно было частично перекрыто другим, то это становится известно операционной системе и она перемещает окно на передний план. Понятно, что неудобно заставлять само окно выполнять эти действия. Операционной системе лучше обрабатывать все нажатия клавиш и кнопок на мыши и затем передавать их в остальные программы в виде событий.
Если кратко, программист в Windows почти никогда не должен напрямую проверять “железо”. Система выполняет эту задачу и передает информацию программе в виде сообщений.
Когда пользователь щелкает мышкой, операционная система обрабатывает это событие и передает его в окно, которое должно обработать данное событие. Созданное сообщение, в этом случае, пересылается в некую процедуру DefWindowProc окна (default window procedure). DefWindowProc - аналог процедуры HandleEvent из примера, приведенного выше.
Каждое окно в Windows имеет свою DefWindowProc. Чтобы полностью понять данное утверждение, представьте, что каждая кнопка, каждый ListBox, каждое поле ввода и т.д. на самом деле являются окнами и имеют свою процедуру DefWindowProc. Это очень гибкая и мощная система, но она может заставить программиста писать очень сложный код. Delphi дает возможность быть защищенным от такой структуры программы.
Почти все, что происходит в Windows принимает форму сообщений и, если вы хотите их использовать в Delphi (в большей мере это необходимо при написании своих собственных компонент), то нужно понять, как эти сообщения работают.
Если посмотреть на DefWindowProc в справочнике по Windows API, то можно увидеть следующее определение:
function DefWindowProc(Wnd: HWnd; Msg, wParam: Word;
lParam: LongInt);
Каждое сообщение, посылаемое в окно, состоит из четырех частей: первая часть - handle окна, получающего сообщение, Msg сообщает, что произошло а третья и четвертая части (wParam и lParam) содержат дополнительную информацию о событии. Вместе эти четыре части являются аналогом показанной выше структуры TEvent.
Вторая часть сообщения имеет длину 16 бит и сообщает, что за событие произошло. Например, если нажата левая кнопка на мыши, то переменная Msg содержит значение WM_LBUTTONDOWN. Существуют десятки различного типа cообщений и они называются вроде WM_GETTEXT, WM_HSCROLL, WM_GETTEXTLENGTH и т.п. Список всех сообщений можно видеть в справочнике по Windows API (on-line help).
Последние две переменные, длиной 16 и 32 бита, называются wParam и lParam. Они сообщают программисту важную дополнительную информацию о каждом событии. Например при нажатии кнопки мыши, lParam содержит координаты указателя мыши.
Одна из хитростей заключается в том, как выделить нужную информацию из этих переменных. В большинстве случаев Delphi освобождает вас от необходимости выполнять данную задачу. Например, в обработчике события OnMouseDown для формы вы просто используете координаты X и Y. Как программисту, вам не нужно прилагать усилия для получения сообщения и связанных с ним параметров. Все, что связано с событиями, представлено в простом и непосредственном виде:
procedure TForm1.FormMouseDown(Sender: TObject;
Button: TMouseButton;
Shift: TShiftState;
X, Y: Integer);
Итак, если подвести итог, то должно стать ясным следующее: Windows является системой ориентированной на события; События в Windows принимают форму сообщений;
В недрах VCL Delphi сообщения Windows обрабатываются и преобразуются в более простую для программиста форму; Обработка событий в Delphi сводится к написанию для каждого объекта своих обработчиков; События в программе на Delphi вызываются не только сообщениями Windows, но и внутренними процессами. Обработка сообщений Windows в Delphi Конечно, нельзя придумать такую библиотеку объектов, которые бы полностью соответствовали потребностям программистов. Всегда возникнет необходимость дополнения или изменения свойств и поведения объектов. В этом случае, так же, как и при создании своих собственных компонент в Delphi, часто требуется обрабатывать сообщения Windows. Поскольку Object Pascal является развитием и продолжением Borland Pascal 7.0, то это выполняется сходным с BP способом. Общий синтаксис для декларации обработчика сообщений Windows:
procedure Handler_Name(var Msg : MessageType);
message WM_XXXXX;
Handler_Name обозначает имя метода; Msg - имя передаваемого параметра; MessageType - какой либо тип записи, подходящий для данного сообщения; директива message указывает, что данный метод является обработчиком сообщения; WM_XXXXX - константа или выражение, которое определяет номер обрабатываемого сообщения Windows.
Рассмотрим обработку сообщений на примере. Например, при нажатии правой кнопки мыши на форме в программе появляется всплывающее меню (pop-up menu, если оно было привязано к этой форме). Программист может захотеть привязать к правой кнопке какое-нибудь другое событие. Это можно сделать так:
type
TForm1 = class(TForm)
PopupMenu1: TPopupMenu;
MenuItem1: TMenuItem;
MenuItem2: TMenuItem;
MenuItem3: TMenuItem;
private
{ Private declarations }
procedure WMRButtonDown(var Msg : TWMMouse); message
WM_RBUTTONDOWN;
public
{ Public declarations }
end;
Подчеркнут код, добавленный в декларацию объекта TForm1 вручную. Далее, в секции implementation нужно написать обработчик:
procedure TForm1.WMRButtonDown(var Msg : TWMMouse);
begin
MessageDlg('Right mouse button click.', mtInformation, [mbOK], 0); end;
В данном случае при нажатии правой кнопки мыши будет появляться диалог.
Вообще-то, у класса TForm уже есть унаследованный от дальнего предка обработчик данного события, который называется точно также и вызывает то самое pop-up меню. Если в новом обработчике сообщения нужно выполнить действия, которые производились в старом, то для этого применяется ключевое слово inherited. Если слегка модифицировать наш обработчик, то после диалога будет появляться pop-up меню:
procedure TForm1.WMRButtonDown(var Msg : TWMMouse);
begin
MessageDlg('Right mouse button click.', mtInformation, [mbOK], 0); inherited;
end;
Однако, есть еще способ обработки всех сообщений, которые получает приложение. Для этого используется свойство OnMessage объекта Application, который автоматически создается при запуске программы. Если определен обработчик события OnMessage, то он получает управление при любом событии, сообщение о котором направлено в программу. Следующий код будет приводить к появлению диалога при двойном щелчке мыши на любом объекте в приложении.
procedure TForm1.FormCreate(Sender: TObject);
begin
Application.OnMessage:=AOM;
end;
procedure TForm1.AOM(var Msg: TMsg; var Handled: Boolean);
begin
Handled:=False;
if Msg.Message = WM_LBUTTONDBLCLK then begin
MessageDlg('Double click.', mtInformation, [mbOK], 0);
Handled:=True;
end;
end;
Конечно, в обработчике нельзя выполнять операции, требующие длительного времени, поскольку это приведет к замедлению выполнения всего приложения.
