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

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

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

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

Таблица 9

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

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

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

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

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

Рис. 21. На вкладке Events перечислены события, которые может воспринимать компонент

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

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

Рис. 22. Пример процедуры обработки события, сгенерированной Delphi

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

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

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

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

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 . Исходные данные вводятся из полей редактирования Edit1 и Edit2 путем обращения к свойству Text.

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

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

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

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

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

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

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

procedure TForm1.Button2Click(Sender: TObject);

begin

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

end;

Цели:

Обучающая: дать понятие события в ОС Windows и обработчика события в среде Delphi. Изучить основные события и возможности компонентов: Edit, Button, Label.

Оборудование:

персональные компьютеры с приложением Boland Delphi for Microsoft Windows;
компьютер учителя;
мультимедийный проектор;

Учебный и раздаточный материал:

учебное пособие;
электронный практикум;
карточки с заданиями для самостоятельной работы;

План урока:

Повторение темы предыдущего урока в форме опроса.
Изучение нового материала.
Самостоятельная работа.
Итог урока.
Домашнее задание.

Ход урока

1. Повторение темы предыдущего урока в форме опроса. Тема предыдущего занятия: "Компонент. Свойства компонента".

что такое компонент?
как выбрать и разместить компоненты на форме?
какие общие свойства компонентов вы знаете?
как можно поменять свойства компонента (например, поменять размер или цвет компонента)?

2. Изучение нового материала.

Сопровождается показом презентации (Приложение1).

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

Обработчик событий

Любой объект реальной жизни вынужден реагировать на те или иные события окружающего мира: зазвонил телефон - человек берёт трубку, пошёл дождь - мы открываем зонт.

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

Событие - это реакция компонента на определённое воздействие.

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

В общем случае это выглядит следующим образом:

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

Среда Delphi хранит для каждого компонента имена всех его обработчиков событий и выводит их на экран в окне "Инспектор объектов" (Object Inspector) во вкладке "События" (Events).

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

выберите компонент, для которого необходимо обработать событие.
откройте вкладку "События" (Events) и два раза щелкните по правому столбцу выбранного события.

В результате этих действий Delphi автоматически сгенерирует процедуру

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

Для удаления события нужно только очистить содержимое процедуры (код между словами Begin и End), а при следующей компиляции, Delphi сам удалит ненужный код процедуры.

Событие OnClick

Самый простой способ сообщить приложению о событии - это щёлкнуть мышью на каком-либо компоненте. При щелчке по кнопке мышью в работающей программе возникает событие OnClick (по щелчку). Пока это событие не обрабатывается программой, поэтому нажатие кнопки не приведёт ни к каким последствиям. Чтобы заставить программу реагировать на нажатие кнопки, необходимо написать на языке Object Pascal фрагмент программы, который называется обработчиком события.

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

Чтобы заставить Delphi самостоятельно сделать заготовку для процедуры обработчика события OnClick, необходимо дважды щёлкнуть по вставленному компоненту. В ответ Delphi активизирует окно кода, в котором можно увидеть следующий фрагмент:

Слово procedure извещает компилятор о начале процедуры. За ним следует имя метода TForm1.Button1Click. Это имя составное: оно состоит из имени класса TForm1 и собственно имени метода Button1Click.

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

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

Будет вызван метод Close (закрыть) для объекта Form1 (окно программы).

Примеры программ с обработчиком события OnClick можно посмотреть в:

procedure TForm1.Button1Click(Sender: TObject);

Label1.Caption:="ул. Базарова, дом 35, кв 35";

Label2.Caption:="Проспект Программистов, корпус 3/1, кв. 275";

procedure TForm1.Button3Click(Sender: TObject);

Label3.Caption:="переулок Ковалевской, дом 27, кв 181";

procedure TForm1.Button4Click(Sender: TObject);

Label4.Caption:="ул. Беринга, дом 22, кв 209";

Фрагменты кода на языке Object Pascal приложения "Прыгающая кнопка" (Приложении 6):

procedure TForm1.Button1Click(Sender: TObject);

Button1.Visible:=False;

Button2.Visible:=True;

procedure TForm1.Button2Click(Sender: TObject);

Button2.Visible:=False;

Button3.Visible:=True;

procedure TForm1.Button7Click(Sender: TObject);

Button7.Visible:=False;

Button8.Visible:=True;

procedure TForm1.Button8Click(Sender: TObject);

Button8.Visible:=False;

Button1.Visible:=True;

Другие события

Название события	Когда возникает
OnKeyPress	Наступает, когда пользователь нажимает какую-либо клавишу.
OnDBClick	Возникает при двойном щелчке на компоненте
OnMouseMove	Возникает при перемещении курсора мыши над компонентом
OnMouseDown	Возникает при нажатии на кнопку мыши
OnMouseUp	Возникает при отпускании кнопки мыши
OnEnter	Возникает при получении компонентом фокуса ввода
OnExit	Возникает при потере компонентом фокуса ввода
OnCreate	Возникает в момент создания формы. Существует только у формы

3. Самостоятельная работа.

Учащимся предлагается создать приложение с обработчиком события OnClick компонента Button.

4. Итог урока.

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

обработчик события - это процедура, которая выполняется при возникновении заданного события;
для выбора события служит вкладка "События" (Events) "Инспектора объектов" (Object Inspector);
научились создавать обработчик для самого популярного события OnClick.

Результаты самостоятельной работы учеников можно посмотреть:

5. Домашнее задание.

Выполнить задания из "Электронного практикума"

Список литературы.

В. В. Кузнецов, И.В. Абдрашитова "Основы объектно-ориентированного программирования в DELPHI", "Школьный Университет, Томск, 2008.
"Delphi для учителя в примерах и задачах" часть I, "Образование и Информатика", Москва, 2006.
Г.В. Галисеев "Программирование в среде Delphi 7", "Диалектика", Москва · Санкт-Петербург · Киев, 2003.
http: //umnic.rikt.ru/everest/distant.

События в программировании, как и события реального мира - это какие-либо операции, происходящие в установленное время. Установленное время - это не конкретное время с точки зрения часов, это просто отклики на какие-то другие действия и изменения. События присущи объектно-ориентированному программированию и являются одной из важных черт операционной системы 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 определяет, что произошло событие именно в нашей программе, и посылает ей сообщение об этом. Наша программа должна соответствующим образом отреагировать на него. Для этого мы, как программисты, должны написать код-обработчик этого события. Таким образом, структура программы для Windows представляет собой набор подпрограмм, каждая из которых ответственна за обработку конкретного события и вызывается только при его возникновении. Удобство Delphi состоит в том, что мы избавлены от необходимости получать сообщения от Windows сами, Delphi это делает за нас. Каждый компонент имеет впечатляющий набор событий, на которые он может реагировать. Программист сам определяет, какие события в программе требуется обрабатывать.

Изменим нашу программу так, чтобы текст на форме появлялся прямо в момент его ввода. В момент ввода у Edit1 меняется свойство Text - в нём появляется новая буква! Значит, воспользуемся событием onChange (change - изменение (англ.)), которое и происходит в этот момент. Итак:

Теперь рассмотрим событие onClick . Как вы догадываетесь, это событие возникает при щелчке мышкой на компоненте. Воспользуемся им, чтобы очищать строку ввода от уже введённых символов. Вы сами уже должны сообразить, что сделать. В обработчике нужно присвоить свойству Text значение пустой строки. Строка в Delphi образуется заключением текста в одинарные кавычки (находятся на кнопке Э ):
" Так в Delphi образуется строка"
Значит, пустая строка - это кавычки без текста: "" . Не должно быть даже пробела, иначе он окажется в строке ввода:

Edit1.Text:="";

Есть другой способ, воспользоваться специально предназначенным для этого методом компонента Edit, который так и называется Clear (очистка англ.):

Edit1.Clear;

Но подумайте о пользователе, который будет работать с вашей программой. Ему должно быть удобно. Если при вводе текста он захочет что-то исправить, и щёлкнет мышкой в том месте текста, где нужно внести изменение?! И всё сотрётся! Поэтому лучше использовать событие onEnter , которое происходит, когда вы "входите" в него и компонент получает фокус ввода, или использовать для очистки специальную кнопку и её событие onClick .
Конечно, у каждого компонента свой набор событий. Мы познакомились с тремя из них:

onChange
onClick
onEnter

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

onExit - возникает, когда компонент теряет фокус ввода;
onDblClick - возникает при двойном щелчке мышкой по компоненту;
onKeyDown - когда при нажатии на кнопку на клавиатуре она оказалась в нижнем положении;
onKeyUp - когда при отпускании клавиатурной кнопки она оказалась в верхнем положении;
onKeyPress - возникает при нажатии на клавиатурную кнопку. От событий onKeyDown и onKeyUp оно отличается типом используемого параметра Key ;
onMouseDown - когда при нажатии кнопки мышки она оказалась в нижнем положении;
onMouseUp - когда при отпускании кнопки мышки она оказалась в верхнем положении;
onMouseMove - возникает при перемещении указателя мышки над компонентом.

В начале работы любой программы происходит очень важное событие событие нашего основного компонента - Формы, onCreate . Оно происходит перед появлением Формы на экране. Это событие используется для задания свойств тех элементов программы, которые нуждаются в настройке, например, размеры и положение Формы на экране. Если вы захотите сделать невидимую программу, можно приравнять нулю ширину Width и высоту Height Формы. На этапе проектирования сделать этого нельзя, т.к. это помешает работе, поэтому делаем это по событию onCreate:

Form1.Width:= 0;
Form1.Height:= 0;

Дополнительно нужно убрать и заголовок Формы, выбрав в Инспекторе Объектов параметр BorderStyle равным None. Теперь Форма на экране не появится. Единственным визуальным признаком останется появление её "значка" на панели задач. В дальнейшем я расскажу, как избавиться и от него.

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

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

Имеется два вида событий: взаимодействие пользователя и изменение состояния. События взаимодействия пользователя почти всегда вызываются в соответствии с сообщениями 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 ;