Delphi события. Метод Сlose — закрывает форму. Автоматическое создание обработчиков событий

Оставьте комментарий 6,950

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

Где найти события?

В одном из первых уроков было упомянуто, что каждый объект имеет свойства и события и всё это доступно через Object Inspector . Список всех событий, которые поддерживает объект, находится на вкладке Events Инспектора Объектов. Формат данных аналогичен закладке со свойствами: слева указывается название события, а справа - обработчик, который присвоен событию. Обратите внимание, что всем событиям обычно даются названия, начинающиеся со слова "On " (англ. - "на "). Это хороший тон и довольно устоявшаяся традиция. Такие названия позволяют быстро отличить события от свойств. По аналогии со свойствами, событиям дают вполне логичные имена. Увидев незнакомое событие, в 95% случаев только по названию можно догадаться, когда событие происходит. Если же событие не совсем понятно, либо хочется больше узнать о нём, можно воспользоваться встроенной справочной системой Delphi . Для этого нужно установить курсор на строку с интересующим событием и просто нажать F1 - справочная система откроется на странице с информацией о выбранном событии (если, конечно, оно описано в справке). Для всех стандартных компонент в справочной системе информации предостаточно. Если используется какой-либо сторонний компонент, то описание следует искать в документации, которая идёт вместо с самим компонентом. Некоторые компоненты (в основном - крупные пакеты из большого числа компонент) самостоятельно интегрируют свою документацию в справочную систему Delphi при установке.

Автоматическое создание обработчиков событий

Обработчик события - это набор команд, которые выполняются при вызове события. Создавать обработчики можно двумя способами: прямо в среде Delphi - автоматически, и программным путём, т.е. во время выполнения программы. Создать обработчик очень просто: достаточно дважды щёлкнуть по полю рядом с названием события в Инспекторе Объектов и откроется редактор кода с заготовкой обработчика. Остаётся лишь написать требуемый код между begin и end (курсор уже будет стоять в том месте) и обработчик готов. Как видите, всё довольно просто и быстро. Однако в предыдущих уроках Вы видели, что обработчик создавался и просто при двойном щелчке по объекту на форме... Да, действительно, в этом случае тоже создаётся обработчик. Но этот способ ничем не отличается от только что описанного, просто для каждого объекта задано событие по умолчанию, для которого создаётся обработчик при двойном щелчке. Как правило, это самые используемые события. Например, для кнопки это конечно же будет щелчок по ней. Для нестандартных компонент, если событие по умолчанию не обозначено, берётся первое попавшееся из всех, а если событие всего одно, то выбор тем более очевиден.
После того, как обработчик создан, на вкладке Events рядом с названием события появится название обработчика для него. Это название также можно вписать и вручную или выбрать из списка, в котором содержатся названия всех обработчиков. Имена обработчикам даются также не случайно: берётся имя объекта и к нему дописывается название события. Например, если есть кнопка Button1 и её событие OnClick , то обработчик получит название Button1Click . Опять-таки, по имени обработчика можно догадаться о событии, к которому он относится.

Событие может иметь только один обработчик! Тем не менее, если требуется задать несколько обработчиков, можно сделать следующим образом: единственный указанный обработчик просто программно запускает другие обработчики. Такой приём часто используется.
Однако, обратного запрета не существует: один обработчик может быть привязан к разным событиям объекта и даже к разным объектам . Для этого нужно в строке интересующего события у объекта выбрать имя обработчика из списка.

Обработчик с точки зрения программного кода

Теперь посмотрим, что из себя представляет обработчик в программном коде. А представляет он из себя процедуру, т.е. набор команд и является мини-программой.
Обработчик содержит раздел реализации - он расположен между begin и end (на рисунке выделен рамкой цвета ). В этом блоке, как Вы уже знаете, следует писать код, который и будет выполнен.
Самая верхняя строка обработчика - это его заголовок (выделен цветом ). Элементы заголовка:
- Ключевое слово procedure (процедура);
- Имя объекта, которому принадлежит данная процедура (в данном случае она принадлежит форме - поэтому TForm1 );
- Имя обработчика (цвет );
- Переданные параметры (цвет ).

Между именем объектам (TForm1 ) и именем обработчика (Button1Click ) находится точка - это символ указания на то, что Button1Click принадлежит TForm1 . При работе с любыми структурами точка указывает на принадлежность элемента этой структуре. Сейчас это не играет большой роли - просто небольшое отступление. К примеру, в языке C++ таким разделителем служит комбинация "минус и знак больше": ->

Раздел описаний здесь тоже присутствует, просто он является пустым. Как и положено, расположен он между заголовком обработчика и разделом реализации, т.е. между первой и второй строкой. При необходимости объявления переменных или констант этот раздел описывается обычным образом - добавление ключевого слово var или const и описанием переменных или констант.

Пример обработки событий №1

procedure
begin
ShowMessage("Нажата Button1" )
end ;

procedure TForm1.Button2Click(Sender: TObject);
begin
ShowMessage("Нажата Button2" )
end ;

procedure TForm1.Button3Click(Sender: TObject);
begin
ShowMessage("Нажата Button3" )
end ;

Конечно, работать будет... Но настоящие программисты так не делают... Судите сами: а если бы было 100 кнопок - что тогда? 100 обработчиков? Конечно нет!

Можно создать один обработчик сразу для всех кнопок. Выше было сказано, что это можно сделать, если выбрать в Инкспекторе Объектов обработчик события из списка... Но в случае, если 100 кнопок, такой способ тоже непригоден - уйдёт много времени. Есть ещё один: если выбрать на форме сразу несколько объектов, то в Инспекторе Объектов среди свойств и событий останутся только те, которые есть у всех выбранных объектов. Этим и следует воспользоваться.

Итак, выбираем на форме все 3 кнопки (очерчивая область мышью, либо удерживая Shift), далее переходим на вкладку Events в ИО и создаём обработчик события OnClick . Что происходит: открывается редактор кода, но создаётся только один обработчик, хотя он присваивается всем трём кнопкам.

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

procedure TForm1.Button1Click(Sender: TObject);
begin
ShowMessage("Нажата " +(Sender as TButton).Name)
end ;

Как именно это работает и что делает оператор as сейчас объяснить довольно сложно. Всему своё время. Пример создан с целью показать, что дублирования всегда можно каким-то способом избежать.

Параметры, передаваемые обработчикам

У событий есть параметры. У многих событий параметр один, но у некоторых их бывает и больше - зависит от типа события. Из переданных параметров можно узнать дополнительные данные и условия, при которых произошло событие. Например, если мы знаем, что пользователь передвинул курсор мыши, это ещё ни о чём не говорит и полезной информации практически не несёт. А вот если мы знаем, что курсор был передвинут в точку экрана с некоторыми известными координатами (x;y) - это уже что-то.
Параметр, который встречается практически во всех событиях - Sender . Он указывает на объект, который данное событие инициировал. Использовать его удобно в случае с несколькими объектами, у которых установлен один обработчик одного и того же события (как в нашем примере №1).

События

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

OnClick - щелчок мышью по объекту. У кнопки событие также срабатывает, если нажать Enter или Пробел в тот момент, когда фокус ввода находится на кнопке.

OnDblClick - двойной щелчок мышью.

OnContextPopup - при вызове контекстного меню объекта, т.е. при щелчке правой кнопкой мыши. Среди параметров есть MousePos - координаты курсора в момент щелчка. Координата по X доступна как MousePos.X , а по Y - как MousePos.Y .

OnEnter - момент, когда объект получает фокус ввода (фокус ввода обычно изображается пунктирной рамкой на объекте; в поле ввода - это курсор; фокус один на всё приложение, т.е. работать одновременно можно лишь с одним объектом).

OnExit - момент, когда объект теряет фокус ввода.

OnMouseDown - при нажатии кнопки мыши (не обязательно левой). Параметр Button - нажатая кнопка (mbLeft - левая кнопка, mbRight - правая, mbMiddle - средняя). Shift - множество, указывающее, какие функциональные клавиши были зажаты при щелчке. Таким образом можно отслеживать, например, нажатия при зажатых Ctrl +Alt и т.п. X , Y - координаты курсора во время нажатия (относительно левого верхнего угла самого компонента, а не формы!).

OnMouseUp - событие, аналогичное OnMouseDown . Происходит при отпускании кнопки мыши. Пример комбинации этих двух событий - графический редактор: когда кнопка мыши нажата, происходит рисование, а когда отпущена - не происходит.

OnMouseMove - ещё одно событие мыши, происходящее при перемещении курсора над объектом. X , Y - координаты нового положения, Shift - множество нажатых функциональных клавиш.

OnKeyDown - при нажатии какой-либо клавиши клавиатуры в тот момент, когда фокус ввода находится на объекте. Key - код нажатой клавиши, Shift - всё то же множество функциональных клавиш (этот параметр встречается во многих событиях).

OnKeyUp - при отпускании клавиши (антипод OnKeyDown ).

OnKeyPress - при нажатии клавиши, которая печатает какой-либо символ (буква, цифра, знак). Key - уже не код клавиши, а сам символ (тип данных: Char - один символ).

OnResize - при изменении размеров объекта.

OnPaint - при отрисовке объекта на экране (например, формы).

У самой формы также есть множество событий. Отметим некоторые из них:

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

OnClose - при закрытии формы.

OnCloseQuery - при попытке закрыть форму. Это событие можно использовать, если нужно заблокировать закрытие формы. В обработчике присутствует параметр CanClose (англ. - "можно закрыть "): логическое значение, тип данных - Boolean . Если после выполнения обработчика значение переменной CanClose окажется False , то закрытие формы произведено не будет. Значение этой переменной устанавливается программно. Пример использования этого события - текстовый редактор. Если пользователь ввёл текст, но не сохранил его в файл, при выходе из программы нужно спросить, следует ли сохранить изменения.

Пример обработки событий №2

Цель: запретить "прямое" закрытие формы, а спрашивать, действительно ли пользователь хочет закрыть программу. Используем событие формы OnCloseQuery . В обработчике выведем диалоговое окно и, если пользователь ответит "Нет ", заблокируем закрывание. Для вывода окна диалога воспользуемся функцией MessageDlg . Подробнее о ней и о её параметрах Вы узнаете в одном из следующих уроков. Наш обработчик:

procedure TForm1.FormCloseQuery(Sender: TObject; var CanClose: Boolean);
begin
if MessageDlg("Вы действительно хотите выйти?" ,mtWarning,,0) = mrNo then
CanClose:= False
end ;

Проверяемое условие - нажата ли кнопка "Нет ". Если она нажата, блокирум закрытие присвоением переменной CanClose значения False . В результате при закрытии увидим следующее:

События (продолжение)

OnDestroy - при уничтожении формы (после закрытия форма уничтожается и освобождается занятая ей память).

OnShow - при показе формы на экран.

OnHide - при скрытии формы с экрана.

OnActivate - момент, когда форма становится активной, т.е. когда ей передаётся фокус ввода (например, когда пользователь щёлкнул по форме).

OnDeactivate - соответственно, когда форма теряет фокус.

OnChange - при изменении чего-либо (например, у поля ввода TEdit это событие срабатывает, когда изменяется текст в этом поле).

OnDragDrop , OnDragOver , OnEndDock , OnEndDrag , OnStartDock , OnStartDrag - все эти события связаны с технологией Drag&Drop (т.е. когда объект "захватывается" мышью и переносится в другое место), а также с Dock -технологией. Суть этой (Dock) технологии во встраивании одних объектов в другие. Например, если взять Object Inspector за заголовок и переместить на нижнюю часть Object TreeView , а затем отпустить, то окна объединятся, а если переместить его в центр Object TreeView , то закладок станет 3 (Object TreeView станет третьей закладкой).

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

Заключение

Мы рассмотрели работу с событиями - одни из принципов объектно-ориентированного программирования. Таким образом, разработка визуальной программы для Windows сводится к написанию обработчиков на события, в которых описывается взаимодействие объектов друг с другом.

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

Если разработчик реализовал код обработчика события, то он выполняется, когда это событие происходит. В противном случае обычно ничего не происходит.

Имеется два вида событий: взаимодействие пользователя и изменение состояния. События взаимодействия пользователя почти всегда вызываются в соответствии с сообщениями Windows, указывая, что пользователь делал кое-что, поэтому компонент может ответить. События изменения состояния также могут быть сведены к сообщениям Windows.

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

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

Объявление событий

Синтаксически события объявляются почти полностью аналогично свойствам:

Property :
[Index Read ]
[Write }
[Stored Логическое выражение>} [Default Nil|NoDefault ];

Примечания:
Хотя в командах чтения и записи могут использоваться методы, на практике они не используются. Обычно используется прямой доступ к полю.
Команда Index используется вместе с методами записи или чтения. Поскольку методы практически не используются, то и команда Index также.
Команда Default фактически допускает только одно значение по умолчанию — Nil, которое и так устанавливается компилятором. Поэтому использование команды Default и, соответственно, NoDefault нецелесообразно.
Все события в Delphi принято именовать с «On «: OnCreate, OnClick и т.д.
В данном случае событие и соответствующее поле имеют тип TNotifyEvent.

Таким образом, в общем случае для объявления события необходимо сделать следующее:
определить или выбрать тип данных события (тип указателя на метод)(процедурный тип);
объявить поле соответствующего типа для хранения значения события;
объявить (корреспондирующий — event-dispatching method) метод, который будет вызывать обработчик события, когда оно произойдет. Представить реализацию этого метода и определить механизм его вызова;
объявить собственно событие.

а) Объявление типа события
Событие — это механизм, с помощью которого связывается некоторое происшествие с некоторым кодом. Код оформляется в виде метода, тип которого объявляется до объявления класса, включающего объявление события. Этот метод должен принадлежать не классу, а экземпляру класса, поскольку даже для объектов одного класса исполняемый код обычно бывает различным. Создание кода метода, реагирующего на событие — это привилегия программиста, Delphi же обеспечивает связь этого метода с событием для вызова этого метода.

Связь события и метода, выполняющего в ответ на это событие, осуществляется в Delphi с помощью указателя на метод. Точнее — это указатель на метод в экземпляре класса. Указатели на метод работают точно также как любой другой процедурный тип, но еще они поддерживают скрытый указатель на объект. Как и всякий указатель, это фактически адрес, в данном случае, адрес метода, и он требует четыре байта для размещения в памяти. Поскольку эти методы предназначены для обработки событий, их называют обработчиками событий (event handler), а управление объектами — управлением по событиям (event driven).

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

Type =Procedure (Sender : TObject [; }) Of Object ;

Дополнительные ключевые слова Of Object указывают компилятору о том, что это указатель на метод объекта, а не самостоятельная процедура. Таким образом, для обработки событий в Delphi предусмотрено объявление указателей на метод, обеспечивающих неявную передачу указателя на экземпляр (переменная Self), вызвавший то или иное событие.

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

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

Примеры типовых указателей на методы.
Список событий в Delphi:

TNotyfyEvent=Procedure(Sender: TObject) Of Object;
OnClick; OnDblClick; OnCreate; OnDestroy;
TMouseMoveEvent=Procedure(Sender: TObject; Shift: TShiftState; X,Y: Integer) Of Object; =>OnMouseMove

Б) Определение механизма возбуждения события
Этот механизм должен фактически реагировать на какие-то ситуации, происшествия, в ответ на возникновение которых и должно возбуждаться события.

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

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

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

Так, в задачу динамического метода Click, помимо изменения внешнего представления кнопки (кнопка «утопает»), входит проверка наличия обработчика события, и если он есть, передача управления ему.

Синтаксис объявления такого метода следующий:

Procedure [()]; Dynamic ;

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

Стандартный синтаксис для реализации метода уведомления о событии имеет следующий вид:

Procedure .[()];
Begin
If Assigned ()
Then (Self [,]);
End ;

Вычислить. событием.

Таблица В9. События


	Событие	Происходит
		При щелчке кнопкой мыши

		При нажатии кнопки мыши
		При отпускании кнопки мыши
		При перемещении мыши

Вычислить.

Object Inspector Events (События).

Рис. В26. На вкладке Events

В левой колонке вкладки Events

Object Inspector

Рис. В27.

Вычислить.

Листинг В1.

// нажатие кнопки Вычислить

procedure

dist: integer; // дистанция, метров

t: real; // время как дробное число

min: integer; // время, минуты

sek: integer; // время, секунды

v: real; // скорость

begin

min:= Trunc(t); //

sek:= Trunc(t*100) mod 100;

// числа t

// вычисление

// вывод результата

end;

по модулю

В результате нажатия кнопки Завершить Завершить приведена в листинге В2.

Листинг В2.

// нажатие кнопки Завершить

procedure

begin

Form1.Close; //

Событие и процедура обработки события

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

Событие (Event) - это то, что происходит во время работы программы. В Delphi каждому событию присвоено имя. Например, щелчок кнопкой мыши - это событие OnClick, двойной щелчок мышью событие OnDblClick.

В табл. В9 приведены некоторые события Windows.

Таблица В9. События


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

Реакцией на событие должно быть какое-либо действие. В Delphi реакция на событие реализуется как процедура обработки события. Таким образом, для того чтобы программа выполняла некоторую работу в ответ на действия пользователя, программист должен написать процедуру обработки соответствующего события. Следует обратить внимание на то, что значительную часть обработки событий берет на себя компонент. Поэтому программист должен разрабатывать процедуру обработки события только в том случае, если реакция на событие отличается от стандартной или не определена. Например, если по условию задачи ограничений на символы, вводимые в поле Edit, нет, то процедуру обработки события OnKeyPress писать не надо, т. к. во время работы программы будет использована стандартная (скрытая от программиста) процедура обработки этого события.

Методику создания процедур обработки событий рассмотрим на примере процедуры обработки события OnClick для командной кнопки Вычислить.

Чтобы приступить к созданию процедуры обработки события, надо сначала в окне Object Inspector выбрать компонент, для которого создается процедура обработки события. Затем в этом же окне нужно выбрать вкладку Events (События).

Рис. В26. На вкладке Events перечислены события, которые может воспринимать компонент (в данном случае - командная кнопка)

В левой колонке вкладки Events (рис. В26) перечислены имена событий, которые может воспринимать выбранный компонент (объект). Если для события определена (написана) процедура обработки события, то в правой колонке рядом с именем события выводится имя этой процедуры.

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

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

Рис. В27. Шаблон процедуры обработки события, сгенерированный Delphi

В окне редактора кода между словами begin и end можно печатать инструкции, реализующие функцию обработки события.

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

Листинг В1. Процедура обработки события OnClick на кнопке Button1 (Вычислить)

// нажатие кнопки Вычислить

procedure TForm1.ButtonlClick(Sender: TObject);

dist: integer; // дистанция, метров

t: real; // время как дробное число

min: integer; // время, минуты

sek: integer; // время, секунды

v: real; // скорость

begin

// получить исходные данные из полей ввода

dist:= StrToint(Edit1.Text); t:= StrToFloat(Edit2.Text);

// предварительные преобразования

min:= Trunc(t); // кол-во минут - это целая часть числа t

sek:= Trunc(t*100) mod 100;

// кол-во секунд - это дробная часть

// числа t

// вычисление

v:= (dist/1000) / ((min*60 + sek)/3600);

// вывод результата

label4.Caption:= "Дистанция: "+ Edit1.Text

+ " м" + #13 + "Время: " + IntToStr(min)

+ " мин " + IntToStr(sek) + " сек " + #13 +

"Скорость: " + FloatToStrF(v,ffFixed,4,2) + " км/час";

end;

Функция Button1click выполняет расчет скорости и выводит результат расчета в поле Label4. Исходные данные вводятся из полей редактирования Editl и Edit2 путем обращения к свойству Text. Свойство Text содержит строку символов, которую во время работы программы введет пользователь. Для правильной работы программы строка должна содержать только цифры. Для преобразования строки в числа в программе используются функции StrToInt и strToFloat. Функция strToInt проверяет символы строки, переданной ей в качестве параметра (Edit1.Text - это содержимое поля Editl), на допустимость и, если все символы верные, возвращает соответствующее число. Это число записывается в переменную dist. Аналогичным образом работает функция strToFioat, которая возвращает дробное число, соответствующее содержимому поля Edit2. Это число записывается в переменную t.

После того как исходные данные будут помещены в переменные dist и t, выполняются подготовительные действия и расчет. Первоначально с использованием функции Trunc, которая "отбрасывает" дробную часть числа, выделяется целая часть переменной t - это количество минут. Значением выражения Trunc(t*100) mod 100 является количество секунд. Вычисляется это выражение так. Сначала число t умножается на 100. Полученное значение передается функции Trunc, которая возвращает целую часть результата умножения t на 100. Полученное таким образом число делится по модулю на 100. Результат деления по модулю - это остаток от деления.

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

Вычисленное значение скорости выводится в поле Label4 путем присваивания значения свойству Caption. Для преобразования чисел в строки используются функции IntToStr И FloatToStr.

В результате нажатия кнопки Завершить программа должна завершить работу. Чтобы это произошло, надо закрыть, убрать с экрана, главное окно программы. Делается это при помощи метода close. Процедура обработки события Onclick для кнопки Завершить приведена в листинге В2.

Листинг В2. Процедура обработки события Onclick на кнопке Button2 (Завершить)

// нажатие кнопки Завершить

procedure TForm1.Button2Click(Sender: TObject);

begin

Form1.Close; // закрыть главное окно программы

В Windows основной элемент пользовательского интерфейса - форма. В Delphi каждый проект имеет по крайней мере одно окно - главное окно приложения. Все окна в Delphi основаны на объекте TForm. В данной статье мы рассмотрим основные события учавствующие в "жизни формы".

Форма

Формы имеют свои свойства, события и методы, при помощи которых Вы можете управлять видом и поведением формы. Форма, это обычный компонент Delphi, но в отличие от других, её нет на панели компонентов. Обычно форма создаётся при создании нового проекта (File | New Application). Вновь созданная форма будет главной формой приложения.

Дополнительные формы в проекте создаются через File | New Form. Так же существуют и другие способы создания форм, но здесь мы не будем рассматривать их...

Как и любой другой компонент (объект) форма имеет свои методы и реагирует на события. Давайте рассмотрим некоторые из этих событий...

Рождение

OnCreate -> OnShow -> OnActivate -> OnPaint -> OnResize -> OnPaint ...

OnCreate

Событие OnCreate возникает при создании TForm и только один раз. При создании формы (у каторой свойство Visible установлено в True), события произойдут в следующем порядке: OnCreate, OnShow, OnActivate, OnPaint. В обработчике события OnCreate можно сделать какие-либо инициализационные действия, однако, любые объекты созданные в OnCreate будут уничтожены в событии OnDestroy.

Это событие генерируется, когда форма станет видимой. OnShow вызывается сразу перед тем, как форма станет видимой. Это событие случается, если установить свойство формы Visible в True, либо при вызове методов Show или ShowModal.

OnActivate

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

OnPaint, OnResize Эти события вызываются каждый раз, когда форма изначально создаётся. При этом OnPaint вызывается каждый раз, когда какому-нибудь элементу формы необходимо перерисоваться (это событие можно использовать, если необходимо при этом рисовать на форме что-то особенное).

Жизнь

Когда форма создана и все её элементы ждут своих событий, чтобы обрабатывать их, жизнь формы продолжается до тех пор, пока кто-нибудь не нажмёт крестик в верхнем правом углу формы!

Уничтожение

При уничтожении формы, события генерируются в следующем порядке:

OnCloseQuery -> OnClose -> OnDeactivate -> OnHide -> OnDestroy

OnCloseQuery

Если мы попытаемся закрыть форму при помощи метода Close либо другим доступным способом (Alt+F4 либо через системное меню), то сгенерируется событие OnCloseQuery. Таким образом, это событие можно использовать, чтобы предотвратить закрытие формы. Обычно, событие OnCloseQuery используется для того, чтобы спросить пользователя - уверен ли он (возможно в приложении остались несохранённые данные).

procedure TForm1.FormCloseQuery(Sender: TObject; var CanClose: Boolean); begin if MessageDlg("Really close this window?", mtConfirmation, , 0) = mrCancel then CanClose:= False; end ;

Обработчик события OnCloseQuery содержит переменную CanClose, которая определяет, можно ли форме закрыться. Изначальное значение этой переменной True. Однако в обработчике OnCloseQuery можно установить возвращаемое значение CloseQuery в False, чтобы прервать выполнение метода Close.

Если OnCloseQuery вернул CanClose=True (что указывает на то, что форма должна быть закрыта), то будет будет сгенерировано событие OnClose. Событие OnClose даёт последний шанс, чтобы предотвратить закрытие формы. Обработчик OnClose имеет параметр Action со следующими четырьмя возможными значениями: caNone. Форме не разрешено закрыться. Всё равно, что мы установим CanClose в False в OnCloseQuery. caHide. Вместо закрытия, форма будет скрыта. caFree. Форма будет закрыта, и занятые ей ресурсы будут освобождены. caMinimize. Вместо закрытия, форма будет минимизирована. Это значение устанавливается поумолчанию у дочерних форм MDI.

Замечание: Когда пользователь шутдаунит Windows, то будет вызвано OnCloseQuery, а не OnClose. Если Вы не хотите, чтобы Windows завершила свою работу, то поместите свой код в обработчик события OnCloseQuery, хотя CanClose=False не сделает, того, что сделано здесь.

OnDestroy

После того, как метод OnClose будет обработан и форма будет закрыта, то будет вызвано событие OnDestroy. В OnCreate обычно делаются действия, противоположные тем, которые проделывались в OnCreate, то есть уничтожение созданных объектов и освобождение выделенной памяти.

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

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

Форма Delphi

Рождение формы в Delphi

OnCreate -> OnShow -> OnActivate -> OnPaint -> OnResize -> OnPaint ...

OnCreate Событие OnCreate возникает при создании TForm и только один раз. При создании формы (у каторой свойство Visible установлено в True), события произойдут в следующем порядке: OnCreate, OnShow, OnActivate, OnPaint. В обработчике события OnCreate можно сделать какие-либо инициализационные действия, однако, любые объекты созданные в OnCreate будут уничтожены в событии OnDestroy.

OnShow Это событие генерируется, когда форма станет видимой. OnShow вызывается сразу перед тем, как форма станет видимой. Это событие случается, если установить свойство формы Visible в True, либо при вызове методов Show или ShowModal.

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

OnPaint, OnResize Эти события вызываются каждый раз, когда форма изначально создаётся. При этом OnPaint вызывается каждый раз, когда какому-нибудь элементу формы необходимо перерисоваться (это событие можно использовать, если необходимо при этом рисовать на форме что-то особенное).

Жизнь формы в Delphi

Уничтожение формы в Delphi

При уничтожении формы, события генерируются в следующем порядке:

OnCloseQuery -> OnClose -> OnDeactivate -> OnHide -> OnDestroy

OnCloseQuery Если мы попытаемся закрыть форму при помощи метода Close либо другим доступным способом (Alt+F4 либо через системное меню), то сгенерируется событие OnCloseQuery. Таким образом, это событие можно использовать, чтобы предотвратить закрытие формы. Обычно, событие OnCloseQuery используется для того, чтобы спросить пользователя - уверен ли он (возможно в приложении остались несохранённые данные).

Procedure TForm1.FormCloseQuery(Sender: TObject; var CanClose: Boolean); begin if MessageDlg("Really close this window?", mtConfirmation, , 0) = mrCancel then CanClose:= False; end;

OnClose Если OnCloseQuery вернул CanClose=True (что указывает на то, что форма должна быть закрыта), то будет будет сгенерировано событие OnClose. Событие OnClose даёт последний шанс, чтобы предотвратить закрытие формы. Обработчик OnClose имеет параметр Action со следующими четырьмя возможными значениями:

caNone. Форме не разрешено закрыться. Всё равно, что мы установим CanClose в False в OnCloseQuery.
caHide. Вместо закрытия, форма будет скрыта.
caFree. Форма будет закрыта, и занятые ей ресурсы будут освобождены.
caMinimize. Вместо закрытия, форма будет минимизирована. Это значение устанавливается поумолчанию у дочерних форм MDI.

Замечание: Когда пользователь выключает Windows, то будет вызвано OnCloseQuery, а не OnClose. Если Вы не хотите, чтобы Windows завершила свою работу, то поместите свой код в обработчик события OnCloseQuery, хотя CanClose=False не сделает, того, что сделано здесь.

OnDestroy После того, как метод OnClose будет обработан и форма будет закрыта, то будет вызвано событие OnDestroy. В OnCreate обычно делаются действия, противоположные тем, которые проделывались в OnCreate, то есть уничтожение созданных объектов и освобождение выделенной памяти.

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