Операционна система Windows- многозадачност, т.е. няколко програми в него могат да функционират едновременно. Когато например щракнем върху бутон в прозореца на нашата програма, системата Windowsопределя, че в нашата програма е възникнало събитие и му изпраща съобщение за това. Нашата програма трябва да реагира по подходящ начин. За да направим това, ние, като програмисти, трябва да напишем код на манипулатор за това събитие. По този начин структурата на програмата за Windowsе набор от подпрограми, всяка от които отговаря за обработката на конкретно събитие и се извиква само когато то се случи. Delphi удобствое, че сме освободени от необходимостта да получаваме съобщения от Windowsсебе си, Delphiправи го за нас. Всеки компонент има впечатляващ набор от събития, на които може да реагира. Програмистът сам определя кои събития в програмата трябва да бъдат обработени.
Нека променим нашата програма, така че текстът във формуляра да се показва точно в момента, в който е въведен. В момента на влизане Редактиране1промени в собствеността Текст- в него се появява нова буква! Така че, нека използваме събитието при промяна(change - change (eng.)), което настъпва в този момент. Така:
Сега помислете за събитието onClick... Както може би се досещате, това събитие се случва при щракване с мишката върху компонента. Нека го използваме, за да изчистим входния ред от вече въведени знаци. Вие сами трябва да разберете какво да правите. В манипулатора трябва да присвоите на свойството Текстстойността на празен низ. Подравнявам Delphiобразувано от заключението на текста в единиченкавички (намерени на бутона NS):
"
Ето как Delphi създава линията "
Следователно празният низ е кавички без текст: ""
... Дори не трябва да има интервал, в противен случай ще се окаже на реда за въвеждане:
Редактиране1.Текст: = "";
Има и друг начин, използвайте специално предназначения за това компонентен методРедактиране, което се нарича Ясно(почистване на английски):
Редактиране1.Изчистване;
Но помислете за потребителя, който ще работи с вашата програма. Трябва да му е удобно. Ако при въвеждане на текст той иска да коригира нещо и щракне с мишката на мястото на текста, където трябва да направите промяна ?! И всичко ще бъде изтрито! Затова е по-добре да използвате събитието onEnterкоето се случва, когато го „въведете“ и компонентът получи входния фокус, или използвайте специален бутон и неговото събитие, за да го изчистите onClick.
Разбира се, всеки компонент има свой собствен набор от събития. Срещнахме трима от тях:
|
Форма1.Ширина: = 0; Освен това трябва да премахнете заглавието на формуляра, като изберете параметъра BorderStyle, равен на None в Инспектора на обекти. Сега формулярът няма да се появи на екрана. Единственият визуален знак ще остане появата на неговата "икона" в лентата на задачите. В бъдеще ще ви кажа как да се отървете и от него. |
Външният вид на генерирания формуляр подсказва как работи приложението. Очевидно потребителят трябва да въведе първоначалните данни в полетата за редактиране и да щракне върху бутонаИзчисли. Щракването върху изображение на командния бутон е пример за това, което Windows извиквасъбитие.
Събитие е това, което се случва по време програмна работа... В Delphi всяко събитие получава име. Например, щракване с мишката е събитие О nЩракнете, двойно щракване - събитие O nDblClick.
Таблица 9 показва някои събития на Windows.
Таблица 9
|
Събитие |
Се случва |
|
OnClick |
При щракване с мишката |
|
OnDblClick |
Кликнете два пъти |
|
OnMouseDown |
При щракване с мишката |
|
OnMouseUp |
Когато бутонът на мишката е освободен |
|
OnMouseMove |
При преместване на мишката |
|
OnKeyPress |
Когато натиснете клавиш на клавиатурата |
|
OnKeyDown |
Когато натиснете клавиш на клавиатурата. Развития OnKeyDown и OnKeyPress се редуват, повтарящи се събития, които се случват, докато задържаният клавиш не бъде освободен (в този момент събитието настъпва OnKeyUp) |
|
OnKeyUp |
Когато освободите натиснатия клавиш на клавиатурата |
|
OnCreate |
При създаване на обект (форма, контрол). Процедурата за обработка на това събитие обикновено се използва за инициализиране на променливи, извършване на подготвителни действия |
|
OnPaint |
Когато на екрана се появи прозорец в началото на програмата, след появата на част от прозореца, която например е била затворена от друг прозорец, и в други случаи |
|
OnEnter |
Когато контролът получи фокус |
|
OnExit |
Когато контролът загуби фокус |
Реакцията на събитието трябва да бъде някакво действие. В Delphi реакцията на събитие се реализира като процедура за обработка на събития.По този начин, за да може програмата да свърши някаква работа в отговор на въвеждане от потребителя, програмистът трябва да напише процедура за обработка на съответното събитие. Имайте предвид, че компонентът поема голяма част от обработката на събития. Следователно, програмист трябва да разработи процедура за обработка на събития само ако реакцията на събитие се различава от стандартната или не е дефинирана. Например, ако според състоянието на проблема има ограничения за въведените в полето знациРедактиране, не, тогава процедурата за обработка на събития onKeyPress не е необходимо да пишете, тъй като по време на работата на програмата ще се използва стандартната (скрита от програмиста) процедура за обработка на това събитие.
Нека разгледаме метода за създаване на процедури за обработка на събития, като използваме пример за процедура за обработка на събития. OnClick за команден бутонИзчисли.
За да започнете да създавате процедура за обработка на събития, първо трябва да влезете в прозорецаИнспектор на обекти изберете компонента, за който е създадена процедурата за събитие. След това в същия прозорец трябва да изберете разделаСъбития.
Лявата колона на раздела Събития (фиг. 21) изброява имената на събития, които могат да бъдат възприети от избрания компонент (обект). Ако процедура за обработка на събитие е дефинирана (написана) за събитие, тогава името на тази процедура се показва в дясната колона, до името на събитието.
Ориз. 21.В раздела Събития са изброени събитията, които компонентът може да възприеме
За да създадете функция за обработка на събития, трябва да щракнете двукратно в полето за име на съответната процедура за обработка на събития. В резултат на това ще се отвори прозорецът на редактора на код, в който ще бъде добавен шаблонът на функцията за обработка на събития и в прозорецаИнспектор на обекти , до името на събитието ще се появи името на функцията за обработката му (фиг. 22).
Delphi присвоява име на функцията за обработка на събития, която има две части. Първата част от името идентифицира формата, която съдържа обекта (компонента), за който е създадена процедурата за събитие. Втората част на името идентифицира самия обект и събитие. В нашия пример името на формата еформуляр 1, име на командния бутон - Button1 и името на събитието е Click.
Ориз. 22.Пример за процедура за обработка на събития, генерирана от Delphi
В прозореца на редактора на код, между думитеначало и край можете да отпечатате инструкции, които изпълняват функцията за обработка на събития.
Списък 1 показва текста на функцията за обработка на събития OnClick за команден бутонИзчисли. Обърнете внимание на това как се представя програмата. Тя обща формасъответства на това как изглежда в прозореца на редактора на код: ключови думис удебелен шрифт, коментари в курсив (маркирането се извършва от редактора на кода). Освен това програмните инструкции са с отстъп в съответствие с добрата програмна практика.
Списък 1.Процедура за обработкаСъбития OnClick на бутона Изчисляване
// натискане на бутона Изчисли
процедура TForm1.ButtonlClick (Подател: TObject);
dist: цяло число; // разстояние, метри
t: истински; // време като дробно число
min: цяло число; // време, минути сек: цяло число; // време, секунди
v: истински; // скорост
започнете
// получавате необработени данни от полета за въвеждане
dist: = StrToInt (Edit1.Text);
t: = StrToFloat (Edit2.Text);
// предварителни трансформации
min: = Trunc (t); // брой минути е цялата част от t
sek: = Trunc (t * 100) mod 100; // броят на секундите е дробната част от числото t
// изчисление
v: = (разстояние / 1000) / ((мин * 60 + сек) / 3600);
// резултатен изход
label4.Caption: = "Разстояние:" + Редактиране1.Текст + "m" + # 13 +
"Време:" + IntToStr (мин) + "мин" + IntToStr (сек) + "сек" + # 13 +
„Скорост: "+ FloatToStrF (v, ffFixed, 4,2) +"км / час";
край;
Функция Button1Click изчислява скоростта и извежда резултата от изчислението в полетоЕтикет4. Първоначалните данни се въвеждат от полетата за редактиранеРедактиране1 и Редактиране2 чрез достъп до имотаТекст.
Текстово свойство съдържа символен низ, който потребителят въвежда, докато програмата работи. За правилна работапрограмният низ трябва да съдържа само числа. За да преобразува низове в числа, програмата използва функциите S trToInt и S trToFloat. Функция StrToInt чекове низ символиму се предава като параметър(Редактиране1.Текст е съдържанието на полето Editl), за валидност и ако всички знаци са правилни, връща съответното число. Това число се записва в променливата dist. Функцията работи по подобен начин. StrToFloat, който връща дробно число, съответстващо на съдържанието на полетоРедактиране2. Това число се записва в променливата T.
След като първоначалните данни се поставят в променливи dist и t, се извършват подготвителни действияи изчисление. Първоначално използвайки функцията Trunc, който "изхвърля" дробната част от числото, се разпределя цялата част на променливата T е броят на минутите. Стойност на израза Trunc (t * l00) mod 100 е броят на секундите. Този израз се изчислява по следния начин. Първо номер T умножено по 100. Получената стойност се предава на функцията Trunc, който връща цялата част от резултата от умножението T на 100. Така полученото число се разделяпо модул по 100. Резултатът от деление по модул е остатъкът от делението.
След като всички данни са готови, изчислението се извършва. Тъй като скоростта трябва да бъде изразена в km/h, стойностите на разстоянието и времето, изразени в метри и минути, се преобразуват в километри и часове.
Изчислената стойност на скоростта се показва в полетоЕтикет4 чрез присвояване на стойност на свойството C aption. За да конвертирате числа в низове, използвайте функциите IntToStr и EloatToStr.
В резултат на натискане на бутонаДа завърши програмата трябва да излезе. За да се случи това, трябва да затворите, премахнете от екрана главния прозорец на програмата. Това се прави по метода Cгубят. Процедура за обработка на събития OnClick за бутона Finish показано в листинг 2.
Списък 2.Процедура за обработка на събития OnClickна бутона Да завърши
// щракване върху бутона Край
процедура TForm1.Button2Click (Изпращач: TObject);
започнете
Form1.Close; // затворете главния прозорец на програмата
край;
Лабораторна работа No4
Цел на работата:научете се да програмирате различни манипулатори на събития
Управление на програми в Windows въз основа на обработка на съобщения за събития,
което се случва в тази многозадачна система.
Събитие-това е някаква ситуация, която може да възникне в хардуера или софтуеркомпютър под въздействието на външни влияния.
Събитията могат да бъдат разделени на следните видове:
1. Събития, причинени от действия на потребителя (UserEvents),които от своя страна могат да бъдат класифицирани, както следва:
Събития за щракване на мишката;
Drag & Drop събития, което означава "плъзгане и пускане" на обект с мишката;
Събития на клавиатурата (възникващи при натискане на клавиш);
2. Редовни (събития, контролирани от софтуера),които са косвен резултат от действията на потребителя. Примери за такива събития са: събития на активиране и завършване на процес, събития на промяна на състоянието на отделни компоненти (компонент придобива или губи активност) и др.;
3. Изключителни събитиятова може да се случи
в резултат на работата на програми или хардуер и да доведе до сериозни последици. Примери за такива събития са: опит за деление на нула, опит за четене на информация от несъществуващ файл, устройство, което не е готово за работа (например принтер или дисково устройство) и редица други.
Програмирането в Delphi е основно за организиране на обработка на съобщения за събития, тоест писане на код манипулатори на събития.
Манипулатор на събития-това е специална подпрограма, отговорна за реакцията на основната програма към това или онова събитие.Делфи манипулаторът на събития е стилизиран като процедура.
Подобно на Windows, Delphi се опитва да намери манипулатор за входящо съобщение за събитие. Такава подпрограма може да бъде стандартна, тоест написана за Windows и известна от Delphi, или може да бъде създадена от самия програмист.
За да създадете необходимия манипулатор на събития в Delphi, трябва да изберете компонента, който ви интересува, като щракнете върху него с мишката, отидете на раздела Събития(Събития) на Инспектора на обекти и след като изберете необходимото събитие, щракнете двукратно върху полето за въвеждане. Ще се отвори редакторът на програмния код, където Delphi автоматично ще постави заглавието на процедурата на манипулатора. Просто трябва да вмъкнете между служебните думи започнетеи крайоператори програмен кодкоито изпълняват всяка реакция на вашата програма към това събитие. За всеки компонент, включително формуляра, можете да създадете свои собствени манипулатори на събития
списъци със събития,свързани към конкретен компонент, включително формата, са зададени на страницатаСъбития (Събития) Инспектор на обекти.
Най-често срещаните събития за компоненти:
| име | Събитие |
| OnCreate | При създаване на обект (форма, контрол). |
| OnClick | Еднократно щракване с ляв бутон върху обект |
| OnDblClick | Щракнете двукратно с левия бутон на мишката върху обект |
| OnMouseDown | При щракване с мишката |
| OnMouseUp | Когато бутонът на мишката е освободен |
| OnMouseMove | При преместване на мишката върху даден компонент |
| OnKeyDown | Натискането на клавиш връща стойност |
| Ключ (тип: Word) - кодът на натиснатия клавиш | |
| Shift (Тип: TShiftState) - ключово състояние |
|
| OnKeyPress | Натиснатият клавиш връща стойността |
| Ключ (тип: Char) - кодът на натиснатия клавиш | |
| OpKeyUp | Когато пуснете клавиш на клавиатурата |
| OnEnter | Когато контролът получи фокус |
| OnExit | Когато контролът загуби фокус |
За всеки Делфи събитияавтоматично определя името на манипулатора според името на компонента, за който е предназначена тази процедура. Например, заглавката на процедурата за манипулиране на събития за събитие с левия бутон на мишката (Щракване) за компонента Buttonl, поставен в прозореца Forml, ще изглежда така:
Процедура TForm1.Button1Click (Изпращач: TObject);
Няколко събития могат да се обработват едновременно, което не само опростява програмирането, но и е причинено от крайна необходимост, тъй като самият Windows работи едновременно с голяма сумаразлични събития.
Упражнение 1.Създаване на манипулатор на събития за формуляра с едно щракване".
Поставете компонент Label върху формуляра. Задайте цвета на етикета, вида и размера на шрифта върху него по желание.
Активирайте формуляра, като щракнете върху него с левия бутон на мишката. Дайте име на заглавието на формуляра „Обработка на събития“.
Отидете на страницата СъбитияИнспектор на обекти и разгледайте отблизо какви събития за формуляра присъстват там.
Изберете събитие OnClick (единично щракване с ляв бутон)и в празното поле вдясно от него щракнете двукратно. В отворения прозорец на Code Editor ще бъде създаден шаблон за тази процедура за обработка на събития за формуляра.
Обърнете внимание на заглавката на манипулатора!Между ключови думи започнетеи край
вмъкнете подчертания текст по-долу: процедура TForm1.FormClisk (Изпращач: TObject);
Label1.Caption: = "ЗДРАВЕЙТЕ! ТОВА Е ЕДНА ГЛЪТКА!"; край;
Стартирайте приложението и тествайте изпълнението с едно щракване с мишката върху формуляра.
Задача 2.Създайте манипулатор на събитие за формуляра Double Click.
Активирайте формуляра и на страницата СъбитияСъбитие за избор на инспектор на обекти OnDblClick (Щракнете двукратно с левия бутон на мишката).
Разгънете редактора на кода и поставете подчертания текст по-долу в заглавието на манипулатора на събития.
На какво е събитие Делфи езики какви са рутините за събития в Delphi.
Като пример за описание на събитие в Delphi, нека вземем примера, описан в предишни статии. Външният вид на генерирания формуляр подсказва как работи приложението. Очевидно потребителят трябва да въведе първоначалните данни в полетата за редактиране и да щракне върху бутона Изчисли... Щракването върху изображение на командния бутон е пример за това, което Windows нарича събитие.
Събитие ( Събитие) в Delphi е това, което се случва, докато програмата работи. В Delphi всяко събитие получава име. Например, щракване с мишката е събитие OnClick, двойно щракване - събитие onDblClick.
Таблица 9 изброява някои от събитията на Windows.
Таблица 9. Някои събития на Windows.
| Събитие | Се случва |
| OnСlick | При щракване с мишката |
| OnDblClick | Кликнете два пъти |
| OnMouseDown | При щракване с мишката |
| OnMouseUp | Когато бутонът на мишката е освободен |
| OnMouseMove | При преместване на мишката |
| OnKeyPress | Когато натиснете клавиш на клавиатурата |
| OnKeyDown | Когато натиснете клавиш на клавиатурата. Развития OnKeyDownи OnKeyPressсе редуват, повтарящи се събития, които се случват, докато задържаният клавиш не бъде освободен (в който момент настъпва събитието OnKeyUp) |
| OnKeyUp | Когато освободите натиснатия клавиш на клавиатурата |
| OnCreate | При създаване на обект (форма, контрол). Процедурата за обработка на това събитие обикновено се използва за инициализиране на променливи, извършване на подготвителни действия |
| OnPaint | Когато на екрана се появи прозорец в началото на програмата, след появата на част от прозореца, която например е била затворена от друг прозорец, и в други случаи |
| OnEnter | Когато контролът получи фокус |
| OnExit | Когато контролът загуби фокус |
Отговорът на събитие в Delphi трябва да бъде някакво действие. В Delphi реакцията на събитие се реализира като процедура за обработка на езикови събития Програмиране на Delphi ... По този начин, за да може програмата да свърши някаква работа в отговор на въвеждане от потребителя, програмистът трябва да напише процедура за обработка на съответното събитие. Трябва да се отбележи, че значителна част от обработката на събития в Delphi се поема от компонента. Следователно, програмист трябва да разработи процедура за обработка на събития на езика Delphi само ако реакцията на събитие се различава от стандартната или не е дефинирана. Например, ако според условието на проблема няма ограничения за символите, въведени в полето Редактиране, тогава процедурата за обработка на събитие onKeyPressне е необходимо да пишете, тъй като по време на работата на програмата ще се използва стандартната (скрита от програмиста) процедура за обработка на това събитие.
Методология за създаване на процедури за обработка на събития в DelphiНека разгледаме пример за процедура за обработка на събития onclickза команден бутон Изчисли.
За да започнете да създавате процедура за обработка на събития, първо трябва да влезете в прозореца Инспектор на обектиизберете компонента, за който е създадена процедурата за събитие. След това в същия прозорец изберете раздела Събития.
Фигура 21. Разделът Събитие (Delphi) изброява събития, които компонентът на Delphi може да възприеме
Лявата колона на раздела Събития (Фигура 21) изброява имената на събития в езика за програмиране Delphi, които избраният компонент (обект) може да възприеме. Ако процедура за обработка на събитие е дефинирана (написана) за събитие, тогава името на тази процедура се показва в дясната колона, до името на събитието.
За да създадете функция за обработка на събития на езика за програмиране Delphi, трябва да щракнете двукратно в полето за име на съответната процедура за обработка на събития. В резултат на това ще се отвори прозорецът на редактора на код, в който ще бъде добавен шаблонът на функцията за обработка на събития и в прозореца Инспектор на обекти, до името на събитието ще се появи името на функцията за обработката му (Фигура 22).
Delphi присвоява име на функцията за обработка на събития, която има две части. Първата част от името идентифицира формата, която съдържа обекта (компонента), за който е създадена процедурата за събитие. Втората част на името идентифицира самия обект и събитие. В нашия пример името на формата е Формуляр 1, името на командния бутон е Бутон 1и името на събитието е Щракнете върху.
Фигура 22. Примери за процедура за обработка на събития, генерирана от Delphi
В прозореца на редактора на код, между думите започнетеи крайможете да отпечатате инструкции, които изпълняват функцията за обработка на събития в езика за програмиране Delphi.
Списък 1 показва текста на функцията за обработка на събития onclickза команден бутон Изчисли... Обърнете внимание на това как се представя програмата. Общият му вид съответства на начина, по който изглежда в прозореца на редактора на код: ключовите думи са удебелен шрифт, коментарите са в курсив (редакторът на кода извършва осветяването). Освен това програмните инструкции са с отстъп в съответствие с добрата програмна практика.
Функция Button1Clickизчислява скоростта и извежда резултата от изчислението в полето Label4. Първоначалните данни се въвеждат от полетата за редактиране Редактиране1и Редактиране2чрез достъп до имота Текст... Имот Текстсъдържа символен низ, който потребителят въвежда, докато програмата работи. За да работи програмата правилно, низът трябва да съдържа само числа. За да преобразува низове в числа, програмата използва функциите StrToIntи StrToFloat... Функция StrToIntпроверява символите на низа, предаван към него като параметър ( Редактиране1.Тексте съдържанието на полето Редактиране1), за валидност и, ако всички знаци са правилни, връща съответното число. Това число се записва в променливата dist... Функцията работи по подобен начин. StrToFloatкойто връща дробно число, съответстващо на съдържанието на полето Редактиране2... Това число се записва в променливата T.
След като първоначалните данни се поставят в променливи distи T, се извършват подготвителни действия и изчисление. Първоначално използване на функцията Trunc, който "изхвърля" дробната част от числото, се разпределя цялата част на променливата Tе броят на минутите. Стойност на израза Trunc (t * l00) mod 100е броят на секундите. Този израз се изчислява по следния начин. Първо номер Tумножено по 100 ... Получената стойност се предава на функцията Truncкойто връща цялата част от резултата от умножението TНа 100 ... Полученото по този начин число се дели по модул на 100 ... Резултатът по модул е остатъкът от делението.
След като всички данни са готови, изчислението се извършва. Тъй като скоростта трябва да бъде изразена в km/h, стойностите на разстоянието и времето, изразени в метри и минути, се преобразуват в километри и часове.
Изчислената стойност на скоростта се показва в полето Етикет4чрез присвояване на стойност на свойството Надпис... За да конвертирате числа в низове, използвайте функциите IntToStrи FloatToStr.
В резултат на натискане на бутона Да завършипрограмата трябва да излезе. За да се случи това, трябва да затворите, премахнете от екрана главния прозорец на програмата. Това се прави с помощта на метода Затвори... Процедура за обработка на събития OnClickза бутон Да завършипоказано в листинг 2.
Преглед
Делфи събития
Разбиране на събитията
Лечение Windows съобщенияв Делфи
- Преглед
- Една от ключовите цели на средата за визуално програмиране е да скрие сложността на програмирането на Windows от потребителя. В същото време обаче искам подобна среда да не се опростява много, не до такава степен, че програмистите да загубят достъп до самата операционна система.
Програмирането, управлявано от събития, е основна характеристика на Windows. някои софтуерни средиБързата разработка на приложения (RAD) се опитва да скрие тази черта от потребителя като цяло, сякаш е толкова сложна, че повечето хора не могат да я разберат. Истината е, че програмирането, управлявано от събития, не е толкова трудно само по себе си. Има обаче някои особености при реализацията на тази концепция в Windows, които в някои ситуации могат да причинят затруднения.
Delphi предоставя пълен достъп до подструктурата на събитията, предоставена от Windows. От друга страна, Delphi улеснява програмирането на манипулатори за тези събития.
V този урокняколко примери закак да се обработват събития в Delphi, е дадено по-подробно обяснение работа на систематаориентиран към събитието.
- Делфи събития
- Обектите от библиотеката за визуални компоненти на Delphi (VCL), както и обектите в реалния свят, имат свой собствен набор от свойства и собствено поведение - набор от отговори на събития, случващи се с тях. Списъкът със събития за даден обект, на които той реагира, може да се види например в Инспектора на обекти на страницата със събития. (Всъщност тази страница предоставя списък със свойства, които са от тип TMouseMoveEvent и са процедури за манипулиране на събития. Има конвенция за именуване на тези свойства. Например OnDblClick съответства на двойно щракване, а OnKeyUp съответства на събитие, когато ключът е бил натиснат. освободен.) Сред набора от събития за различни обекти от VCL има както събития, пренесени от Windows (MouseMove, KeyDown), така и събития, повдигнати директно в програмата (DataChange за TDataSource).
Поведението на обекта се определя от това кои манипулатори и за кои събития има. Създаването на приложение в Delphi се състои от настройка на свойствата на използваните обекти и създаване на манипулатори на събития.
Най-простите събития, на които понякога трябва да се реагира, са например събития с мишката (почти всички видими обекти ги имат) или събитието Click за бутона TButton. Да предположим, че искате да прихванете щракване с ляв бутон на мишката върху формуляр. За да направите това, създайте нов проект, в Инспектора на обекти изберете страницата на събитието и щракнете двукратно от дясната страна за свойството OnClick. Ще получите шаблон за манипулатора за това събитие:
започнете
край;
Тук напишете следното:
процедура TForm1.FormClick (Sender: TObject);
започнете
MessageDlg ("Здравей", mtInformation,, 0);
край;
При всяко щракване с левия бутон на мишката върху формуляра се появява диалогов прозорец (виж фиг. 1).
процедура TForm1.FormKeyDown (Подател: TObject;
var Ключ: Word;
Shift: TShiftState);
започнете
MessageDlg (Chr (Ключ), mtInformation,, 0);
край;
Сега, когато имате някои основни познания за програмирането на събития в Delphi, е време да се върнете назад и да разгледате теорията зад кода, който сте написали. След като получите представа как работи системата, можете да се върнете към средата на Delphi и да видите как да използвате пълната налична функционалност.
- Разбиране на събитията
Програмирането на събития не е ограничено до Windows и тази чертаможе да се внедри не само в операционната система. Например, всякакви DOS програмаможе да се основава на прост цикъл, който изпълнява целия живот на програмата в паметта. По-долу ще намерите хипотетичен пример за това как може да изглежда този код:
започнете
InitializeMemory;
повторете
CheckForMouseEvent (Събития);
CheckForKeyPress (събития)
HandleEvents (Събития);
до Готово: = Вярно;
DisposeMemory;
край.
Това е типичен пример за програма, управлявана от събития. Започва и завършва с инициализация и освобождаване на паметта. В програмата има прост цикълповторете .. докато, който проверява за събития с мишката и клавиатурата и след това позволява на програмиста да реагира на тези събития.
Променливата Events може да бъде запис с проста структура:
TEvent = запис
X, Y: цяло число;
Бутон на мишката: TButton;
Ключ: Word;
край;
Типът TButton по-горе може да бъде деклариран по следния начин:
TButton = (lButton, rButton);
Тези структури ви позволяват да следите къде се намира мишката, какво е състоянието на нейните бутони и значението на натиснатия клавиш на клавиатурата. Разбира се, това е пример за много проста структура, но принципите, изложени тук, отразяват какво се случва в Windows или в други управлявани от събития системи като Turbo Vision. Ако програмата по-горе беше текстов редактор, тогава манипулаторът на HandleEvent за такава програма може да изглежда така:
процедура HandleEvent (Събития: TEvent);
започнете
случай Събития.Ключ на
'A' .. 'z': Пишете (Събития.Ключ);
EnterKey: Пишете (CarriageReturn);
EscapeKey: Готово: = Вярно;
край;
край;
Съгласно кода по-горе, програмата ще отпечата буквата "а", когато този клавиш бъде натиснат и ще премине към нова линияако е натиснат клавишът 'Enter'. Натискането на 'Esc' ще прекрати програмата.
Този тип код може да бъде много удобен, особено ако пишете програма, която изисква анимация. Например, ако трябва да преместите няколко снимки по екрана, може да се наложи да ги преместите с няколко точки, след което да проверите дали потребителят е натиснал бутони. Ако е имало такова събитие, тогава може да се справи, ако не, тогава продължете напред.
Надяваме се, че този пример дава известна представа за това как работи системата, управлявана от събития. Единственото нещо, което остава, е защо Windows систематака проектирани.
Една от основните причини Microsoft да изгради Windows по този начин е фактът, че много задачи се изпълняват в средата едновременно. В многозадачните системи операционната система трябва да знае дали потребителят е щракнал върху конкретен прозорец. Ако този прозорец е бил частично припокрит от друг, това става известно на операционната система и тя премества прозореца отпред. Ясно е, че е неудобно да се принуди самият прозорец да извърши тези действия. По-добре е операционната система да обработва всички натискания на клавиши и бутони на мишката и след това да ги предава на други програми като събития.
Накратко, Windows програмист почти никога не трябва да тества хардуера директно. Системата изпълнява тази задача и прехвърля информация към програмата под формата на съобщения.
Когато потребителят щракне с мишката, операционната система обработва това събитие и го изпраща до прозореца, който трябва да обработва това събитие. Генерираното съобщение в този случай се препраща към някаква прозоречна процедура по подразбиране (DefWindowProc). DefWindowProc е аналогичен на процедурата HandleEvent от примера по-горе.
Всеки прозорец на Windows има свой собствен DefWindowProc. За да разберете напълно това твърдение, представете си, че всеки бутон, всеки ListBox, всяко поле за въвеждане и т.н. всъщност са прозорци и имат своя собствена процедура DefWindowProc. Той е много гъвкав и мощна система, но може да принуди програмиста да напише много сложен код. Delphi дава възможност да бъдете защитени от такава програмна структура.
Почти всичко, което се случва в Windows, е под формата на съобщения и ако искате да ги използвате в Delphi (в по-голяма степен това е необходимо при писане на собствени компоненти), тогава трябва да разберете как работят тези съобщения.
Разглеждайки DefWindowProc в препратката за Windows API, тогава можете да видите следното определение:
функция DefWindowProc (Wnd: HWnd; Msg, wParam: Word;
lParam: LongInt);
Всяко съобщение, изпратено до прозорец, се състои от четири части: първата част е манипулаторът на прозореца, който получава съобщението, Msg съобщава какво се е случило, а третата и четвъртата части (wParam и lParam) съдържат допълнителна информация за събитието. Заедно тези четири части са аналогични на структурата на TEvent, показана по-горе.
Втората част на съобщението е дълга 16 бита и разказва какъв вид събитие се е случило. Например, ако е натиснат левият бутон на мишката, тогава променливата Msg съдържа стойността WM_LBUTTONDOWN. Има десетки от различни видовесъобщения и те са наречени като WM_GETTEXT, WM_HSCROLL, WM_GETTEXTLENGTH и т.н. Списък с всички съобщения може да се види в справочника за Windows API (онлайн помощ).
Последните две променливи, дълги 16 и 32 бита, се наричат wParam и lParam. Те предоставят на програмиста важна допълнителна информация за всяко събитие. Например, когато се натисне бутон на мишката, lParam съдържа координатите на показалеца на мишката.
Един от триковете е как да подчертаете необходимата информацияот тези променливи. В повечето случаи Delphi ви освобождава от тази задача. Например, в манипулатора на събитие OnMouseDown за формуляр, вие просто използвате координатите X и Y. Като програмист не е нужно да работите усилено, за да получите съобщението и свързаните с него параметри. Всичко свързано със събития е представено по прост и директен начин:
процедура TForm1.FormMouseDown (Подател: TObject;
Бутон: TMouseButton;
Shift: TShiftState;
X, Y: цяло число);
И така, за да обобщим, трябва да стане ясно следното:
- Windows е система, управлявана от събития;
- Събитията в Windows са под формата на съобщения;
- В дълбините на VCL Delphi, Windows съобщенията се обработват и трансформират във форма, която е по-лесна за програмиста;
- Обработката на събития в Delphi се свежда до писане на собствени манипулатори за всеки обект;
- Събитията в програма Delphi се задействат не само от съобщения на Windows, но и от вътрешни процеси.
- Работа с Windows съобщения в Delphi
Разбира се, не можете да измислите библиотека от обекти, която да отговаря напълно на нуждите на програмистите. Винаги ще има нужда от добавяне или промяна на свойствата и поведението на обектите. В този случай, точно както когато създавате свои собствени компоненти в Delphi, често трябва да обработвате съобщения на Windows. Тъй като Object Pascal е разработка и продължение на Borland Pascal 7.0, това се прави по подобен начин на BP.
Общият синтаксис за деклариране на манипулатор на съобщения в Windows е:
процедура Handler_Name (var Msg: MessageType);
съобщение WM_XXXXX;
Handler_Name обозначава името на метода; Msg е името на предадения параметър; MessageType - всеки тип запис, подходящ за на това съобщение; директивата за съобщения показва, че този метод е манипулатор на съобщения; WM_XXXXX е константа или израз, който дефинира номера на съобщението на Windows за обработка.
Нека да разгледаме обработката на съобщения с помощта на пример. Например, когато щракнете с десния бутон върху формуляр, в програмата се появява изскачащо меню (изскачащо меню, ако е било прикрепено към този формуляр). Програмистът може да иска да свърже някакво друго събитие към десния бутон. Можете да го направите така:
Тип
TForm1 = клас (TForm)
PopupMenu1: TPopupMenu;
MenuItem1: TMenuItem;
MenuItem2: TMenuItem;
MenuItem3: TMenuItem;
частен
(частни декларации)
процедура WMRButtonDown (var Msg: TWMMouse); съобщение
WM_RBUTTONDOWN;
обществено
(Публични декларации)
край;
Подчертаният код е добавен ръчно към декларацията на обекта TForm1. По-нататък в разделаизпълнение трябва да напишете манипулатор:
започнете
край;
В този случай, когато щракнете с десния бутон на мишката, ще се появи диалогов прозорец.
Всъщност класът TForm вече има манипулатор, наследен от неговия далечен предшественик. това събитие, който се извиква точно по същия начин и извиква същото изскачащо меню. Ако в новия манипулатор на съобщения трябва да извършите действията, които са били извършени в стария, тогава ключовата дума се използва за тованаследени ... Ако леко модифицираме нашия манипулатор, след диалоговия прозорец ще се появи изскачащо меню:
процедура TForm1.WMRButtonDown (var Msg: TWMMouse);
започнете
MessageDlg („Направо бутон на мишкатащракнете. ", mtInformation,
наследени;
край;
Въпреки това, все още има начин за обработка на всички съобщения, които приложението получава. За да направите това, използвайте свойството OnMessage на обекта Application, което се създава автоматично при стартиране на програмата. Ако е дефиниран манипулатор на събитие OnMessage, той получава контрол върху всяко събитие, което се докладва на програмата. Следният код ще изведе диалогов прозорец, когато щракнете двукратно върху всеки обект в приложението.
процедура TForm1.FormCreate (Изпращач: TObject);
започнете
Application.OnMessage: = AOM;
край;
процедура TForm1.AOM (var Msg: TMsg; Var Handled: Boolean);
започнете
Обработено: = False;
ако Msg.Message = WM_LBUTTONDBLCLK, тогава започнете
MessageDlg ("Двойно щракване", MtInformation,, 0);
Обработено: = Вярно;
край;
край;
Разбира се, не можете да изпълнявате операции, които отнемат много време в манипулатора, тъй като това ще забави изпълнението на цялото приложение.
