Добавить параметр в метод события делфи. События Delphi

Лабораторная работа № 4

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

Управление программой в Windows основано на обработке сообщений о событиях,

которые происходят в этой многозадачной системе.

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

События можно разделить на следующие типы:

1. События, обусловленные действиями пользователя (UserEvents), которые,в своюочередь, можно классифицировать следующим образом:

События щелчка мыши;

События типа Drag&Drop, что означает "Перетащить и бросить" объект мышью;

События клавиатуры (возникающие при нажатии клавиш);

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

3. События, обусловленные исключительными ситуациями ,которые могут возникать

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

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

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

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

Для того чтобы создать в Delphi нужный обработчик событий, следует выбрать интересующий Вас компонент, щелкнув по нему мышкой, перейти на закладку Events (События) Инспектора Объектов и, выбрав необходимое событие, дважды щелкнуть по его полю ввода. Раскроется Редактор Кода программы, куда Delphi автоматически поместит заготовку процедуры обработчика. Вам остается только вставить между служебными словами begin и end операторы программного кода, реализующие какую либо реакцию Вашей программы на данное событие. Для каждого компонента, в том числе и для формы, можно создать свои собственные обработчики событий

Списки событий, относящихся к конкретному компоненту, в том числе и к форме, заданы на странице Events (События) Инспектора Объектов.

Наиболее часто встречающиеся события для компонентов:

Название	Событие
OnCreate	При создании объекта (формы, элемента управления).
OnClick	Одинарный щелчок левой клавиши мыши на объекте
OnDblClick	Двойной щелчок левой клавиши мыши на объекте
OnMouseDown	При нажатии кнопки мыши
OnMouseUp	При отпускании кнопки мыши
OnMouseMove	При перемещении мыши над заданным компонентом
OnKeyDown	Нажатие клавиши возвращает значение
	Key(тип: Word)-код нажатой клавиши
	Shift(Тип: TShiftState)–состояние клавиши
OnKeyPress	Нажатая символьная клавиша возвращает значение
	Key(тип: Char)-код нажатой клавиши
ОпКеyUр	При отпускание клавиши клавиатуры
OnEnter	При получении элементом управления фокуса
OnExit	При потере элементом управления фокуса

Для каждого события Delphi автоматически определяет имя обработчика в соответствии с именем компонента, для которого эта процедура предназначена. Например, заголовок процедуры обработчика события щелчка левой клавиши мыши (Click) для компонента кнопка (Buttonl), размещенного в окне стартовой формы (Forml) будет выглядеть следующим образом:

Procedure TForm1.Button1Click(Sender:TObject);

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

Задание 1. Создание обработчика событий для формы"Одинарный щелчок мышью ".

Поместите на форму компонент Label (Метка). Цвет метки, тип и размер шрифта на ней задайте по желанию.

Активизируйте форму, щелкнув по ней левой клавишей мыши. Заголовку формы дайте название "Обработка событий".

Перейдите на страницу Events (События) Инспектора Объектов и внимательно рассмотрите, какие события для формы там присутствуют.

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

Обратите внимание на заголовок обработчика! Между ключевыми словами begin и end

вставьте подчеркнутый текст, приведенный ниже: procedure TForm1.FormСliсk(Sеndеr: TObject);

Label1.Caption: = "ПРИВЕТ! ЭТО ОДИНАРНЫЙ ШЕЛЧОК!"; end;

Запустите приложение и проверьте выполнение одинарного щелчка мышью на форме.

Задание 2. Создание обработчика событий для формы“Двойной щелчок мышью”.

Активизируйте форму, и на странице Events (События) Инспектора Объектов выберете событие OnDblClick (Двойной щелчок левой клавишей мыши).

Раскройте Редактор Кода и вставьте в заготовку обработчика события подчеркнутый текст, приведенный ниже.

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

Таблица В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; // закрыть главное окно программы

Обзор

События в Delphi

Понимание событий

Обработка сообщений Windows в Delphi

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

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

   Delphi предоставляет полный доступ к подструктуре событий, предоставляемой Windows. С другой стороны, Delphi упрощает программирование обработчиков таких событий.

   В данном уроке приводится несколько примеров того, как обрабатывать события в Delphi, дается более детальное объяснение работы системы, ориентированной на события.

3. События в Delphi
4. Объекты из библиотеки визуальных компонент (VCL) Delphi, равно как и объекты реального мира, имеют свой набор свойств и свое поведение - набор откликов на события, происходящие с ними. Список событий для данного объекта, на которые он реагирует, можно посмотреть, например, в Инспекторе Объектов на странице событий. (На самом деле, на этой странице представлен список свойств, которые имеют тип вроде TMouseMoveEvent и представляют из себя процедуры-обработчики событий. Существует соглашение по названиям данных свойств. Например, OnDblClick соответствует двойному щелчку мыши, а OnKeyUp - событию, когда нажатая клавиша была отпущена.) Среди набора событий для различных объектов из VCL есть как события, портируемые из Windows (MouseMove, KeyDown), так и события, порождаемые непосредственно в программе (DataChange для TDataSource).

   Поведение объекта определяется тем, какие обработчики и для каких событий он имеет. Создание приложения в Delphi состоит из настройки свойств используемых объектов и создания обработчиков событий.

   Простейшие события, на которые иногда нужно реагировать - это, например, события, связанные с мышкой (они есть практически у всех видимых объектов) или событие Click для кнопки TButton. Предположим, что вы хотите перехватить щелчок левой кнопки мыши на форме. Чтобы сделать это - создайте новый проект, в Инспекторе Объектов выберите страницу событий и сделайте двойной щелчок на правой части для свойства OnClick. Вы получите заготовку для обработчика данного события:

   begin

   end;

   Напишите здесь следующее:

   procedure TForm1.FormClick(Sender: TObject);

   begin

   MessageDlg("Hello", mtInformation, , 0);

   end;

   Каждый раз, когда делается щелчок левой кнопки мыши над формой будет появляться окно диалога (см. рис.1).

   procedure TForm1.FormKeyDown(Sender: TObject;

   var Key: Word;

   Shift: TShiftState);

   begin

   MessageDlg(Chr(Key), mtInformation, , 0);

   end;

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

5. Понимание событий

Событийное программирование есть не только в 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, но и внутренними процессами.

1. 1. 1. Обработка сообщений 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 нужно написать обработчик:

begin

, 0);

end;

В данном случае при нажатии правой кнопки мыши будет появляться диалог.

Вообще-то, у класса TForm уже есть унаследованный от дальнего предка обработчик данного события, который называется точно также и вызывает то самое pop-up меню. Если в новом обработчике сообщения нужно выполнить действия, которые производились в старом, то для этого применяется ключевое слово inherited . Если слегка модифицировать наш обработчик, то после диалога будет появляться pop-up меню:

procedure TForm1.WMRButtonDown(var Msg: TWMMouse);

begin

MessageDlg("Right mouse button click.", mtInformation,

, 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, , 0);

Handled:=True;

end;

end;

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

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

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

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

В 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, то есть уничтожение созданных объектов и освобождение выделенной памяти.

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