Wat is een gebeurtenis in Delphi en wat zijn in Delphi.

Laten we als voorbeeld van het beschrijven van een gebeurtenis in Delphi het voorbeeld nemen dat in eerdere artikelen is beschreven. Het uiterlijk van het gemaakte formulier vertelt u hoe de applicatie werkt. Uiteraard moet de gebruiker de initiële gegevens in de bewerkingsvelden invoeren en op de knop klikken Berekenen. Het klikken op een opdrachtknopafbeelding is een voorbeeld van wat in Windows een gebeurtenis wordt genoemd.

Evenement ( Evenement) in Delphi is wat er gebeurt terwijl het programma actief is. In Delphi krijgt elke gebeurtenis een naam. Een muisklik is bijvoorbeeld een gebeurtenis AanKlik, dubbelklik - gebeurtenis opDblClick.

Tabel 9 vermeldt enkele Windows-gebeurtenissen.

Tabel 9. Enkele Windows-gebeurtenissen.

Evenement	Gebeurt
Aanklik	Bij muisklik
AanDblClick	Bij dubbelklikken muisknop
AanMuisOmlaag	Wanneer de muisknop wordt ingedrukt
OpMouseUp	Wanneer u de muisknop loslaat
Bij MuisMove	Bij het bewegen van de muis
OpToetsdruk	Wanneer u op een klaviertoets drukt
OpKeyDown	Wanneer u op een klaviertoets drukt. Evenementen OpKeyDown En OpToetsdruk- dit zijn afwisselende, zich herhalende gebeurtenissen die plaatsvinden totdat de vastgehouden toets wordt losgelaten (op welk punt de OnKeyUp-gebeurtenis plaatsvindt)
AanKeyUp	Wanneer u een ingedrukte klaviertoets loslaat
Aanmaken	Bij het maken van een object (formulier, besturingselement). De procedure voor het afhandelen van deze gebeurtenis wordt meestal gebruikt om variabelen te initialiseren en voorbereidende acties uit te voeren
OpVerf	Wanneer aan het begin van het programma een venster op het scherm verschijnt, na het verschijnen van een deel van het venster dat bijvoorbeeld werd bedekt door een ander venster, en in andere gevallen
Bij Enter	Wanneer een besturingselement focus krijgt
Bij Afsluiten	Wanneer een controle de focus verliest

De reactie op een gebeurtenis in Delphi moet een soort actie zijn. In Delphi wordt de reactie op een gebeurtenis geïmplementeerd als procedure voor gebeurtenisafhandeling in taal Delphi-programmering . Om een ​​programma dus enig werk te laten doen als reactie op gebruikersacties, moet de programmeur een procedure schrijven om de overeenkomstige gebeurtenis af te handelen. Opgemerkt moet worden dat een aanzienlijk deel van de gebeurtenisverwerking in Delphi wordt overgenomen door de component. Daarom moet de programmeur alleen een procedure voor het afhandelen van gebeurtenissen in Delphi ontwikkelen als de reactie op de gebeurtenis afwijkt van de standaard of niet is gedefinieerd. Als er bijvoorbeeld, volgens de voorwaarden van de taak, geen beperkingen gelden voor de tekens die in het veld Bewerken worden ingevoerd, dan wordt de gebeurtenisverwerkingsprocedure opToetsdruk schrijven is niet nodig, omdat tijdens de werking van het programma de standaardprocedure (verborgen voor de programmeur) voor het verwerken van deze gebeurtenis zal worden gebruikt.

Methodologie voor het creëren van in Delphi Laten we eens kijken naar het voorbeeld van een gebeurtenisverwerkingsprocedure klik voor opdrachtknop Berekenen.

Om te beginnen met het maken van een gebeurtenisverwerkingsprocedure, moet u eerst in het venster zijn Objectinspecteur selecteer de component waarvoor de is gemaakt. Vervolgens moet u in hetzelfde venster het tabblad Gebeurtenissen selecteren.

Afbeelding 21. Het tabblad Gebeurtenis (Delphi) geeft een overzicht van de gebeurtenissen die een Delphi-component kan waarnemen

In de linkerkolom van het tabblad Gebeurtenissen (Afbeelding 21) staan ​​de namen van gebeurtenissen in de programmeertaal Delphi die de geselecteerde component (object) kan waarnemen. Als voor een gebeurtenis een gebeurtenisverwerkingsprocedure is gedefinieerd (geschreven), wordt de naam van deze procedure weergegeven in de rechterkolom, naast de gebeurtenisnaam.

Om een ​​gebeurtenisverwerkingsfunctie in de programmeertaal Delphi te creëren, moet u dubbelklikken in het naamveld van de procedure voor het verwerken van de overeenkomstige gebeurtenis. Als gevolg hiervan wordt een code-editorvenster geopend, waarin het sjabloon voor de gebeurtenisverwerkingsfunctie wordt toegevoegd, en in het venster Objectinspecteur naast de gebeurtenisnaam verschijnt de naam van de functie voor het verwerken ervan (Afbeelding 22).

Delphi geeft de gebeurtenishandler een naam die uit twee delen bestaat. Het eerste deel van de naam identificeert het formulier dat het object (component) bevat waarvoor de is gemaakt. Het tweede deel van de naam identificeert het object en de gebeurtenis zelf. In ons voorbeeld is de formuliernaam Vorm1, naam opdrachtknop - Knop1, en de naam van de gebeurtenis is Klik.

Figuur 22. Voorbeelden van door Delphi gegenereerdes

In het code-editorvenster tussen woorden beginnen En einde U kunt instructies afdrukken die de gebeurtenisafhandelingsfunctie implementeren in de programmeertaal Delphi.

Lijst 1 toont de tekst van de gebeurtenisafhandelingsfunctie klik voor opdrachtknop Berekenen. Let op hoe het programma wordt gepresenteerd. Haar algemeen beeld komt overeen met hoe het eruit ziet in het code-editorvenster: trefwoorden zijn vetgedrukt, commentaar is cursief (de markering wordt gedaan door de code-editor). Bovendien zijn de programma-instructies ingesprongen, in overeenstemming met de regels van goede stijl die onder programmeurs worden aanvaard.

Functie Knop1Klik voert een snelheidsberekening uit en geeft het berekeningsresultaat weer in het Label4-veld. De initiële gegevens worden ingevoerd vanuit de bewerkingsvelden Bewerken1 En Bewerken2 door het pand te betreden Tekst. Eigendom Tekst bevat een reeks tekens die de gebruiker invoert terwijl het programma actief is. Om het programma correct te laten werken, mag de string alleen cijfers bevatten. Om een ​​string in getallen om te zetten, gebruikt het programma functies StrToInt En StrToFloat. Functie StrToInt controleert de karakters van de string die eraan wordt doorgegeven als parameter ( Bewerken1.Tekst is de inhoud van het veld Bewerken1), voor geldigheid, en als alle tekens geldig zijn, wordt het overeenkomstige getal geretourneerd. Dit getal wordt naar een variabele geschreven afstand. De functie werkt op een vergelijkbare manier StrToFloat, dat het breukgetal retourneert dat overeenkomt met de inhoud van het veld Bewerken2. Dit getal wordt naar een variabele geschreven T.

Nadat de originele gegevens in variabelen zijn geplaatst afstand En T worden voorbereidende handelingen en berekeningen uitgevoerd. In eerste instantie met behulp van de functie Stam, die "weggooit" fractioneel deel getallen, wordt het gehele deel van de variabele toegewezen T is het aantal minuten. De betekenis van de uitdrukking Trunc(t*l00) mod 100 is het aantal seconden. Deze uitdrukking wordt als volgt berekend. Nummer eerst T vermenigvuldigd met 100 . De resulterende waarde wordt doorgegeven aan de functie Stam, dat het gehele deel van het vermenigvuldigingsresultaat retourneert T op 100 . Het aldus verkregen getal wordt modulo gedeeld door 100 . Het resultaat van de modulo-deling is de rest van de deling.

Nadat alle gegevens gereed zijn, wordt de berekening uitgevoerd. Omdat de snelheid moet worden uitgedrukt in km/u, worden afstands- en tijdwaarden uitgedrukt in meters en minuten omgezet in kilometers en uren.

De berekende snelheidswaarde wordt in het veld weergegeven Etiket4 door een waarde aan een eigenschap toe te kennen Ondertiteling. Functies worden gebruikt om getallen naar tekenreeksen te converteren IntToStr En FloatToStr.

Als gevolg van het indrukken van de knop Compleet het programma zou moeten afsluiten. Om dit te laten gebeuren, moet u het hoofdprogrammavenster sluiten en van het scherm verwijderen. Dit gebeurt met behulp van de methode Dichtbij. Procedure voor gebeurtenisverwerking AanKlik voor knop Compleet wordt weergegeven in Lijst 2.

Op Windows het belangrijkste element gebruikersinterface- formulier. In Delphi heeft bijna elk project dit ten minsteéén venster is het hoofdvenster van de applicatie. Alle vensters in Delphi zijn gebaseerd op het TForm-object. In dit artikel zullen we kijken naar de belangrijkste gebeurtenissen die betrokken zijn bij het ‘leven van vorm’.

Delphi-formulier

Formulieren hebben hun eigen eigenschappen, gebeurtenissen en methoden waarmee u het uiterlijk en het gedrag van het formulier kunt bepalen. Het formulier is een reguliere Delphi-component, maar staat, in tegenstelling tot andere, niet in het componentenpaneel. Meestal wordt het formulier aangemaakt bij het aanmaken van een nieuw project (Bestand | Nieuwe aanvraag). Opnieuw bevolkt dit formulier zal de hoofdvorm van de aanvraag zijn.

Extra formulieren in het project worden aangemaakt via Bestand | Nieuw formulier. Er zijn ook andere manieren om formulieren te maken, maar die zullen we hier niet bespreken...

Net als elk ander onderdeel (object) heeft de vorm zijn eigen methoden en reageert op gebeurtenissen. Laten we eens kijken naar enkele van deze gebeurtenissen...

De geboorte van een formulier in Delphi

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

OnCreate De gebeurtenis OnCreate vindt plaats wanneer een TForm wordt gemaakt, en slechts één keer. Wanneer een formulier wordt gemaakt (waarbij de eigenschap Visible is ingesteld op True), vinden gebeurtenissen plaats in de volgende volgorde: OnCreate, OnShow, OnActivate, OnPaint. In de OnCreate-gebeurtenishandler kunt u enkele initialisatieacties uitvoeren. Alle objecten die in OnCreate zijn gemaakt, worden echter vernietigd tijdens de OnDestroy-gebeurtenis.

OnShow Deze gebeurtenis wordt geactiveerd wanneer het formulier zichtbaar wordt. OnShow wordt direct aangeroepen voordat het formulier zichtbaar wordt. Deze gebeurtenis vindt plaats wanneer de eigenschap Visible van het formulier is ingesteld op True, of wanneer de methoden Show of ShowModal worden aangeroepen.

OnActivate Deze gebeurtenis wordt geactiveerd wanneer het formulier actief wordt, dat wil zeggen wanneer het formulier invoerfocus krijgt. Deze gebeurtenis kan worden gebruikt om het formulierelement te wijzigen dat focus moet krijgen.

OnPaint, OnResize Deze gebeurtenissen worden geactiveerd elke keer dat het formulier voor het eerst wordt gemaakt. In dit geval wordt OnPaint elke keer aangeroepen wanneer een element van het formulier opnieuw moet worden getekend (deze gebeurtenis kan worden gebruikt als u iets speciaals op het formulier moet tekenen).

Het leven van een vorm in Delphi

Wanneer een formulier wordt gemaakt en alle elementen ervan wachten op verwerking van hun gebeurtenissen, gaat het formulier door totdat iemand op het kruisje in de rechterbovenhoek van het formulier klikt!

Een formulier vernietigen in Delphi

Wanneer een formulier wordt vernietigd, worden gebeurtenissen in de volgende volgorde gegenereerd:

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

Bij CloseQuery Als we proberen het formulier te sluiten met de methode Sluiten of een andere beschikbare methode (Alt+F4 of via systeemmenu), dan wordt de OnCloseQuery-gebeurtenis gegenereerd. Daarom kan deze gebeurtenis worden gebruikt om te voorkomen dat het formulier wordt gesloten. Meestal wordt de gebeurtenis OnCloseQuery gebruikt om de gebruiker te vragen of hij het zeker weet (misschien zijn er niet-opgeslagen gegevens in de toepassing).

Procedure TForm1.FormCloseQuery(Afzender: TObject; var CanClose: Boolean); begin if MessageDlg("Dit venster echt sluiten?", mtConfirmation, , 0) = mrCancel then CanClose:= False; einde;

De gebeurtenishandler OnCloseQuery bevat een CanClose-variabele, die bepaalt of het formulier kan worden gesloten. De beginwaarde van deze variabele is True. U kunt de CloseQuery-retourwaarde echter instellen op False in de OnCloseQuery-handler om de uitvoering van de Close-methode af te breken.

AanSluiten Als OnCloseQuery CanClose=True retourneert (wat aangeeft dat het formulier moet worden gesloten), wordt de OnClose-gebeurtenis geactiveerd. De OnClose-gebeurtenis biedt nog een laatste kans om te voorkomen dat het formulier wordt gesloten. De OnClose-handler heeft een Action-parameter met de volgende vier mogelijke waarden:

• kanGeen. Het formulier mag niet worden gesloten. Het is hetzelfde alsof we CanClose in OnCloseQuery op False instellen.
• caVerbergen. In plaats van te sluiten, wordt het formulier verborgen.
• caGratis. Het formulier wordt gesloten en de bronnen die erin worden gebruikt, worden vrijgegeven.
• caMinimaliseren. In plaats van te sluiten, wordt de vorm geminimaliseerd. Deze waarde wordt standaard ingesteld voor onderliggende MDI-formulieren.

Opmerking: wanneer de gebruiker Windows afsluit, wordt OnCloseQuery aangeroepen en niet OnClose. Als u niet wilt dat Windows wordt afgesloten, plaatst u uw code in de gebeurtenishandler OnCloseQuery, hoewel CanClose=False niet zal doen wat het hier doet.

AanVernietigen Nadat de OnClose-methode is verwerkt en het formulier is gesloten, wordt de OnDestroy-gebeurtenis aangeroepen. OnCreate doet meestal het tegenovergestelde van wat er in OnCreate is gedaan, namelijk het vernietigen van de gemaakte objecten en het vrijmaken van het toegewezen geheugen.

Wanneer de hoofdvorm van het project wordt afgesloten, is de aanvraag uiteraard voltooid.

Gebeurtenissen in de programmering zijn, net als gebeurtenissen in de echte wereld, alle handelingen die op een vast tijdstip plaatsvinden. Tijd instellen- dit is geen specifieke tijd vanuit het oogpunt van de klok, dit zijn eenvoudigweg reacties op enkele andere acties en veranderingen. Gebeurtenissen zijn inherent aan objectgeoriënteerd programmeren en vormen een van de belangrijke kenmerken van het Windows-besturingssysteem. Het werk van programma's met een visuele (grafische) interface is ondenkbaar zonder evenementen. Delphi biedt volledige toegang voor het werken met gebeurtenissen en maakt het programmeren van gebeurtenishandlers een beetje eenvoudiger. Het doel van de les is om vertrouwd te raken met de meest gebruikte gebeurtenissen, evenals technieken voor het schrijven van handlers daarvoor.

Waar kan ik evenementen vinden? In een van de eerste lessen werd vermeld dat elk object eigenschappen en gebeurtenissen heeft en dat dit allemaal toegankelijk is Objectinspecteur. Op het tabblad vindt u een lijst met alle gebeurtenissen die het object ondersteunt Evenementen Objectinspecteur. Het gegevensformaat is vergelijkbaar met het tabblad Eigenschappen: de naam van de gebeurtenis wordt aan de linkerkant aangegeven en aan de rechterkant wordt de handler aangegeven die aan de gebeurtenis is toegewezen. Houd er rekening mee dat alle evenementen meestal een naam krijgen die begint met het woord ' Op" (Engels - " op"). Dit zijn goede manieren en een redelijk gevestigde traditie. Met dergelijke namen kun je gebeurtenissen snel van eigenschappen onderscheiden. Naar analogie met eigenschappen krijgen gebeurtenissen vrij logische namen. Als je een onbekende gebeurtenis ziet, kun je in 95% van de gevallen alleen op naam raden wanneer de gebeurtenis plaatsvindt, of als u er meer over wilt weten, kunt u het ingebouwde Delphi-helpsysteem gebruiken, u moet de cursor op de regel plaatsen met het gewenste evenement en klik gewoon. F1- het helpsysteem wordt geopend op een pagina met informatie over de geselecteerde gebeurtenis (als dit uiteraard in de help wordt beschreven). Voor iedereen standaard componenten Er is veel informatie in het helpsysteem. Als er een component van derden wordt gebruikt, moet de beschrijving te vinden zijn in de documentatie die bij de component zelf wordt geleverd. Sommige componenten (voornamelijk grote pakketten van groot aantal componenten) integreren tijdens de installatie zelfstandig hun documentatie in het Delphi-helpsysteem. Automatische creatie van gebeurtenishandlers Gebeurtenishandler is een reeks opdrachten die worden uitgevoerd wanneer er een gebeurtenis plaatsvindt. U kunt op twee manieren handlers aanmaken: rechtstreeks in Delphi-omgeving- automatisch en programmatisch, d.w.z. tijdens de uitvoering van het programma. Het maken van een handler is heel eenvoudig: dubbelklik gewoon op het veld naast de gebeurtenisnaam in de Object Inspector en de code-editor met een handler-sjabloon wordt geopend. Het enige dat overblijft is het schrijven van de benodigde code ertussen beginnen En einde(de cursor staat al op die plaats) en de handler is klaar. Zoals je kunt zien, is alles vrij eenvoudig en snel. In eerdere lessen zag je echter dat een handler eenvoudigweg werd aangemaakt door te dubbelklikken op een object op het formulier... Ja, inderdaad, in dit geval wordt er ook een handler gemaakt. Maar deze methode verschilt niet van degene die zojuist is beschreven; het is alleen zo dat voor elk object een standaardgebeurtenis wordt ingesteld, waarvoor een handler wordt gemaakt wanneer er dubbel op wordt geklikt. Meestal zijn dit de meest gebruikte evenementen. Voor een knop is dit bijvoorbeeld uiteraard een klik erop. Voor niet-standaardcomponenten geldt dat als de standaardgebeurtenis niet is gespecificeerd, de eerste beschikbare gebeurtenis wordt gebruikt, en als er maar één gebeurtenis is, ligt de keuze zelfs nog duidelijker. Nadat de handler is gemaakt, op het tabblad Evenementen De naam van de handler ervoor verschijnt naast de gebeurtenisnaam. Deze naam kan ook handmatig worden ingevoerd of worden geselecteerd uit een lijst die de namen van alle handlers bevat. Ook de namen van de handlers worden niet toevallig gegeven: de naam van het object wordt overgenomen en de naam van de gebeurtenis wordt eraan toegevoegd. Als er bijvoorbeeld een knop is Knop1 en haar evenement AanKlik, dan krijgt de handler een naam Knop1Klik. Nogmaals, aan de hand van de naam van de handler kunt u raden op welke gebeurtenis deze betrekking heeft. Een gebeurtenis kan slechts één handler hebben! Als u echter meerdere handlers moet opgeven, kunt u dit doen: de opgegeven enkele handler voert eenvoudigweg de andere handlers programmatisch uit. Deze techniek wordt vaak gebruikt. Er bestaat echter geen omgekeerd verbod: een waaraan de handler gebonden kan zijn diverse evenementen bezwaar maken en zelfs tegen verschillende objecten. Om dit te doen, selecteert u in de regel van de gebeurtenis die van belang is voor het object de naam van de handler uit de lijst. Handler vanuit code-oogpunt Laten we nu eens kijken waar de handler in zit programmacode. En het is een procedure, d.w.z. een reeks opdrachten is een miniprogramma. De handler bevat een implementatiesectie - deze bevindt zich ertussen beginnen En einde(in de figuur is dit gemarkeerd met een kleurenkader). In dit blok moet u, zoals u al weet, de code schrijven die wordt uitgevoerd. Het meest bovenste regel handler is de titel (gemarkeerd in kleur). Kopelementen: - Trefwoord procedure(procedure); - Naam van het object waartoe het behoort deze procedure(V in dit geval het behoort tot de vorm - daarom TForm1); - Naam geleider (kleur); - Doorgegeven parameters (kleur). Tussen de naam van de objecten ( TForm1) en handlernaam ( Knop1Klik) er staat een punt - dit is een symbool dat dat aangeeft Knop1Klik behoort TForm1. Wanneer u met structuren werkt, geeft een punt aan dat het element tot deze structuur behoort. Dit speelt geen grote rol - slechts een kleine uitweiding. In de taal C++ is zo'n scheidingsteken bijvoorbeeld de combinatie van "minteken en groter dan teken": -> Het beschrijvingsgedeelte is hier ook aanwezig, het is gewoon leeg. Zoals verwacht bevindt deze zich tussen de handlerheader en de implementatiesectie, d.w.z. tussen de eerste en tweede lijn. Als het nodig is om variabelen of constanten te declareren, wordt deze sectie op de gebruikelijke manier beschreven: door een trefwoord toe te voegen var of const en beschrijvingen van variabelen of constanten.

Voorbeeld van gebeurtenisverwerking nr. 1

procedure TForm1.Button1Click(Afzender: TObject);
beginnen
ShowMessage("Knop1 ingedrukt")
einde ;

procedure TForm1.Button2Click(Afzender: TObject);
beginnen
ShowMessage("Knop2 ingedrukt" )
einde ;

procedure TForm1.Button3Click(Afzender: TObject);
beginnen
ShowMessage("Knop3 ingedrukt")
einde ;

Natuurlijk zal het werken... Maar echte programmeurs doen dat niet... Oordeel zelf: wat als er 100 knoppen waren - wat dan? 100 begeleiders? Natuurlijk niet!

U kunt één handler voor alle knoppen tegelijk maken. Hierboven werd gezegd dat dit kan worden gedaan als u een gebeurtenishandler selecteert uit de lijst in de Object Inspector... Maar als er 100 knoppen zijn, is deze methode ook niet geschikt - het zal veel tijd kosten. Er is nog één ding: als u meerdere objecten tegelijk op het formulier selecteert, blijven in de Object Inspector onder de eigenschappen en gebeurtenissen alleen de objecten over die alle geselecteerde objecten hebben. Dit is waar u van moet profiteren.

Selecteer dus alle 3 de knoppen op het formulier (geef het gebied aan met de muis of houd Shift ingedrukt) en ga vervolgens naar het tabblad Evenementen in de IO en maak een gebeurtenishandler AanKlik. Wat er gebeurt: de code-editor wordt geopend, maar er wordt slechts één handler gemaakt, hoewel deze aan alle drie de knoppen is toegewezen.

De berichtuitvoer wordt ook op één regel geïmplementeerd, waarin de naam van de ingedrukte knop wordt vervangen.

procedure TForm1.Button1Click(Afzender: TObject);
beginnen
ShowMessage("Ingedrukt" +(Afzender als TKnop).Naam)
einde ;

Hoe werkt het precies en wat doet de operator? als Het is heel moeilijk om het nu uit te leggen. Alles heeft zijn tijd. Het voorbeeld is gemaakt om te laten zien dat duplicatie altijd op de een of andere manier kan worden vermeden.

Parameters doorgegeven aan handlers

Gebeurtenissen hebben parameters. Veel gebeurtenissen hebben één parameter, maar sommige hebben er meer, afhankelijk van het type gebeurtenis. Uit de doorgegeven parameters kunt u aanvullende gegevens en omstandigheden achterhalen waaronder de gebeurtenis plaatsvond. Als we bijvoorbeeld weten dat de gebruiker de muiscursor heeft verplaatst, betekent dit niets en nuttige informatie praktisch niet draagt. Maar als we weten dat de cursor is verplaatst naar een punt op het scherm met enkele bekende coördinaten (x;y)- dit is al iets.
Een parameter die bij bijna alle gebeurtenissen voorkomt - Afzender. Het verwijst naar het object dat de gebeurtenis heeft geactiveerd. Het is handig om dit te gebruiken bij meerdere objecten waarop één handler voor dezelfde gebeurtenis is geïnstalleerd (zoals in ons voorbeeld nr. 1).

Nu we veel weten over evenementen, kunnen we eindelijk kijken naar de standaard en meest gebruikte evenementen.

OnClick - muisklik op een object. Voor een knop wordt de gebeurtenis ook geactiveerd als u op Enter of Spatie drukt terwijl de invoerfocus op de knop ligt.

OnDblClick - dubbelklik.

OnContextPopup - bij het oproepen van het contextmenu van een object, d.w.z. wanneer erop wordt geklikt klik met de rechtermuisknop muizen. Onder de parameters is er MuisPos- coördinaten van de cursor op het moment van klikken. Coördineren door X beschikbaar als MuisPos.X, en door Y- Hoe MuisPos.Y.

OnEnter - het moment waarop een object invoerfocus krijgt (invoerfocus wordt meestal weergegeven door een gestippeld kader op het object; in het invoerveld is dit de cursor; er is slechts één focus voor de hele applicatie, d.w.z. u kunt er maar met één werken voorwerp tegelijk).

OnExit - het moment waarop het object de invoerfocus verliest.

OnMouseDown - wanneer de muisknop wordt ingedrukt (niet noodzakelijk de linkerknop). Parameter Knop- ingedrukte knop ( mbLinks - linker knop, mbRechts- rechts, mbMidden- gemiddeld). Verschuiving- een set die aangeeft welke functietoetsen ingedrukt werden gehouden toen erop werd geklikt. Op deze manier kunt u bijvoorbeeld klikken volgen terwijl u Ctrl + Alt ingedrukt houdt, enz. X, Y- coördinaten van de cursor tijdens het indrukken (ten opzichte van links bovenste hoek het onderdeel zelf, niet de vorm!).

OnMouseUp is een evenement vergelijkbaar met AanMuisOmlaag. Treedt op wanneer de muisknop wordt losgelaten. Een voorbeeld van een combinatie van deze twee gebeurtenissen is grafische editor: Wanneer de muisknop wordt ingedrukt, wordt er getekend, maar wanneer de muisknop wordt losgelaten, gebeurt dit niet.

OnMouseMove is een andere muisgebeurtenis die plaatsvindt wanneer de cursor over een object beweegt. X, Y- coördinaten van de nieuwe positie, Verschuiving- veel ingedrukte functietoetsen.

OnKeyDown - wanneer een toetsenbordtoets wordt ingedrukt terwijl de invoerfocus op het object ligt. Sleutel- code van de ingedrukte toets, Verschuiving- dezelfde set functietoetsen (deze parameter komt in veel evenementen voor).

OnKeyUp - wanneer de sleutel wordt losgelaten (antipode OpKeyDown).

OnKeyPress - wanneer u op een toets drukt die een teken (letter, cijfer, teken) afdrukt. Sleutel- niet langer de sleutelcode, maar het symbool zelf (datatype: Char- één teken).

OnResize - wanneer de grootte van een object verandert.

OnPaint - bij het tekenen van een object op het scherm (bijvoorbeeld een formulier).

Het formulier zelf kent ook veel evenementen. Laten we er enkele noteren:

OnCreate - bij het maken van het formulier. Normaal gesproken bevat deze gebeurtenishandler acties die moeten plaatsvinden wanneer het programma start. Maar bij het opstarten wordt dit alleen uitgevoerd als het formulier het hoofdformulier in de applicatie is en op voorwaarde dat het formulier automatisch wordt aangemaakt. Als de aanvraag slechts één formulier bevat, is dit het hoofdformulier.

OnClose - bij het sluiten van het formulier.

OnCloseQuery - wanneer u probeert het formulier te sluiten. Deze gebeurtenis kan worden gebruikt als u het sluiten van een formulier wilt blokkeren. De handler bevat een parameter KanSluiten(Engels - " kan gesloten worden"): Booleaanse waarde, gegevenstype - Booleaans. Als na het uitvoeren van de handler de waarde van de variabele KanSluiten zo blijkt Vals, dan wordt het formulier niet gesloten. De waarde van deze variabele wordt programmatisch ingesteld. Een voorbeeld van het gebruik van deze gebeurtenis is teksteditor. Als de gebruiker tekst heeft ingevoerd maar deze niet in een bestand heeft opgeslagen, wordt u bij het afsluiten van het programma gevraagd of de wijzigingen moeten worden opgeslagen.

Voorbeeld van gebeurtenisverwerking nr. 2

Doel: het "direct" sluiten van het formulier verbieden, maar wel vragen of de gebruiker het programma echt wil afsluiten. Met behulp van de formuliergebeurtenis Bij CloseQuery. In de handler zullen we een dialoogvenster weergeven en als de gebruiker antwoordt " Nee", zullen we het sluiten blokkeren. Om het dialoogvenster weer te geven, zullen we de functie gebruiken BerichtDlg. U leert er meer over en de parameters ervan in een van de volgende lessen. Onze begeleider:

procedure TForm1.FormCloseQuery(Afzender: TObject; var CanClose: Booleaans);
beginnen
als MessageDlg( "Heb je echt zin om uit te gaan?",mtWaarschuwing,,0) = mrNee Dan
CanClose:= Onwaar
einde ;

De voorwaarde die wordt gecontroleerd, is of de knop " is ingedrukt Nee". Als erop wordt gedrukt, wordt het sluiten geblokkeerd door het toekennen van een variabele KanSluiten waarden Vals. Als gevolg hiervan zullen we bij het sluiten het volgende zien:

Evenementen (vervolg)

OnDestroy - wanneer het formulier wordt vernietigd (na het sluiten wordt het formulier vernietigd en wordt het geheugen dat het inneemt vrijgegeven).

OnShow - wanneer het formulier op het scherm wordt weergegeven.

OnHide - wanneer het formulier van het scherm wordt verborgen.

OnActivate - het moment waarop het formulier actief wordt, d.w.z. wanneer het invoerfocus krijgt (bijvoorbeeld wanneer de gebruiker op het formulier klikt).

OnDeactivate - respectievelijk wanneer het formulier de focus verliest.

OnChange - wanneer er iets verandert (bijvoorbeeld een invoerveld TBewerken deze gebeurtenis wordt geactiveerd wanneer de tekst in dit veld verandert).

OnDragDrop, OnDragOver, OnEndDock, OnEndDrag, OnStartDock, OnStartDrag - al deze gebeurtenissen hebben betrekking op technologie Slepen en neerzetten(dat wil zeggen wanneer een object door de muis wordt "gepakt" en naar een andere locatie wordt verplaatst), en ook met Dok-technologie. De essentie van deze (Dock)technologie is het inbedden van sommige objecten in andere. Als we bijvoorbeeld nemen Objectinspecteur achter de kop en ga naar de onderkant Objectboomweergave en laat dan los, de vensters zullen samenvloeien, en als je het naar het midden verplaatst Objectboomweergave, dan zijn er 3 bladwijzers ( Objectboomweergave wordt de derde bladwijzer).

Zoals je kunt zien, zijn er heel veel gebeurtenissen en het heeft simpelweg geen zin om ze allemaal te beschrijven; hun namen onthullen de betekenis van de gebeurtenissen zelf. Het is voldoende om te weten welke gebeurtenissen er in het algemeen bestaan.

Conclusie

We hebben gekeken naar het werken met gebeurtenissen - een van de principes van objectgeoriënteerd programmeren. Het ontwikkelen van een visueel programma voor Windows komt dus neer op het schrijven van gebeurtenishandlers die de interactie van objecten met elkaar beschrijven.

besturingssysteem Ramen- multitasken, d.w.z. Er kunnen meerdere programma's tegelijkertijd in functioneren. Wanneer we bijvoorbeeld op een knop in ons programmavenster klikken, verschijnt het systeem Ramen stelt vast dat er een gebeurtenis heeft plaatsgevonden in ons programma en stuurt er een bericht over. Ons programma moet daar dienovereenkomstig op reageren. Om dit te doen, moeten wij, als programmeurs, code schrijven om deze gebeurtenis af te handelen. Dus de programmastructuur voor Ramen is een reeks subroutines, die elk verantwoordelijk zijn voor het verwerken van een specifieke gebeurtenis en alleen worden aangeroepen als deze zich voordoet. Delphi-gemak is dat ons de noodzaak wordt bespaard om berichten van te ontvangen Ramen zich, Delphi het doet het voor ons. Elk onderdeel heeft een indrukwekkende reeks gebeurtenissen waarop het kan reageren. De programmeur bepaalt zelf welke gebeurtenissen in het programma verwerkt moeten worden.

Laten we ons programma zo veranderen dat de tekst op het formulier precies verschijnt zoals deze is ingevoerd. Op het moment van binnenkomst Bewerken1 eigendommen veranderen Tekst- er verschijnt een nieuwe letter in! Dus laten we het evenement gebruiken opWijzigen(change - change (Engels)), die op dit moment plaatsvindt. Dus:

Denk nu eens aan de gebeurtenis opKlik. Zoals u wellicht kunt raden, vindt deze gebeurtenis plaats wanneer met de muis op een onderdeel wordt geklikt. We zullen het gebruiken om de invoerregel van reeds ingevoerde tekens te wissen. Je moet zelf bedenken wat je moet doen. In de handler moet u de eigenschap toewijzen Tekst lege tekenreekswaarde. Lijn binnen Delphi gevormd door de tekst af te sluiten enkel aanhalingstekens (bevindt zich op de knop E):
" Dit is hoe de snaar wordt gevormd in Delphi "
Middelen, lege tekenreeks- dit zijn citaten zonder tekst: "" . Er mag niet eens een spatie staan, anders komt het in de invoerregel terecht:

Bewerk1.Text:="";

Er is een andere manier, gebruik een speciaal hiervoor ontworpen apparaat component methode Edit, wat zo heet Duidelijk(schoonmaken Engels):

Bewerken1.Wissen;

Maar denk eens aan de gebruiker die uw programma gaat gebruiken. Hij moet comfortabel zijn. Als hij tijdens het invoeren van tekst iets wil corrigeren en met de muis klikt op de plaats van de tekst waar hij een wijziging moet aanbrengen?! En alles zal worden gewist! Het is dus beter om gebeurtenis te gebruiken opEnter, wat gebeurt wanneer u het "binnengaat" en de component invoerfocus krijgt, of een speciale knop en de bijbehorende gebeurtenis gebruikt om deze te wissen opKlik.
Natuurlijk heeft elk onderdeel zijn eigen reeks gebeurtenissen. We hebben er drie ontmoet:

opWijzigen opKlik opEnter

Andere belangrijke gebeurtenissen die bijna elke visuele component kent:

aanAfsluiten- Treedt op wanneer een component de invoerfocus verliest; opDblClick- treedt op wanneer u dubbelklikt op een component; opKeyDown- wanneer u op een knop op het toetsenbord drukt, deze in de onderste stand staat; opKeyUp- wanneer de toetsenbordknop bij het loslaten in de bovenste positie staat; opToetsdruk- Treedt op wanneer u op een toetsenbordknop drukt. Van evenementen opKeyDown En opKeyUp het verschilt in het type parameter dat wordt gebruikt Sleutel ; op MuisOmlaag- wanneer u op de muisknop drukt, staat deze in de onderste positie; opMouseUp- wanneer, wanneer u de muisknop loslaat, deze zich in de bovenste positie bevindt; opMouseMove- treedt op wanneer u de muisaanwijzer over een onderdeel beweegt. Aan het begin van elk programma vindt er een zeer belangrijke gebeurtenis plaats, de gebeurtenis van ons hoofdbestanddeel: Formulieren. opCreëren. Het gebeurt voordat het formulier op het scherm verschijnt. Deze gebeurtenis wordt gebruikt om de eigenschappen in te stellen van de programma-elementen die moeten worden geconfigureerd, bijvoorbeeld de grootte en positie van het formulier op het scherm. Als u een onzichtbaar programma wilt maken, kunt u de breedte op nul zetten Breedte en hoogte Hoogte Formulieren. Dit kan niet in de ontwerpfase worden gedaan, omdat dit zal het werk verstoren, dus doen we het op evenementenbasis opAanmaken: Vorm1.Breedte:= 0; Vorm1.Hoogte:= 0; Bovendien moet u de titel van het formulier verwijderen door de parameter BorderStyle in de Object Inspector te selecteren die gelijk is aan Geen. Nu verschijnt het formulier niet op het scherm. De enige visueel teken het “pictogram” blijft op de taakbalk staan. In de toekomst zal ik je vertellen hoe je er vanaf kunt komen.

Samen met hen heeft het formulier ook specifieke kenmerken eigenschappen, methoden En evenementen, bepaald door zijn speciale betekenis. Sommigen karakteriseren het formulier als het hoofdobject van de applicatie, bijvoorbeeld een eigenschap, anderen karakteriseren het formulier als een container van andere componenten, bijvoorbeeld eigenschappen en .

Wanneer het Delphi-systeem een ​​nieuw formulier aan een project toevoegt, creëert het automatisch één exemplaar van de klasse (Form1, Form2, enz.), waarbij de juiste wijzigingen in het projectbestand worden aangebracht, bijvoorbeeld door een regel code toe te voegen:

Beheer het proces automatische creatie Formulieren kunnen worden gemaakt door het projectbestand rechtstreeks te bewerken (niet aanbevolen voor onervaren programmeurs) of door instellingen te maken in het venster met projectparameters (Automatische formulierenlijst maken op de formulierpagina). Als het formulier van deze lijst naar de lijst wordt overgebracht Beschikbare formulieren beschikbare projectformulieren, wordt de instructie voor het maken ervan uitgesloten van het projectbestand en moet de programmeur dynamisch een exemplaar van dit formulier maken tijdens de uitvoering van de toepassing.

In deze screenshot zien we dat Vorm1 wordt gemaakt wanneer het programma start, en Formulier2 moet dynamisch worden gemaakt wanneer het programma wordt uitgevoerd.

Methode maken

Gebruik de methode (constructor) om exemplaren van formulieren te maken Creëren. De formulierklasse zelf is doorgaans vooraf gedefinieerd wanneer de toepassing wordt ontworpen, en de formulierbestanden (dfm) en programmamodulebestanden (pas) bestaan ​​al voor het formulier.

Met de bovenstaande procedure wordt een formulier gemaakt Formulier2, dat bij het toepassingsobject hoort en een titel heeft nieuwe vorm.

Formulier gebeurtenissen

Wanneer u een formulier maakt en gebruikt, wordt het volgende gegenereerd: evenementen type TNotifyEvent, gespecificeerd in de volgorde waarin ze voorkomen:

1. Aanmaken;
2. OnShow;
3. AanActiveren;
4. OpVerf.

OnCreate-gebeurtenis

Evenement Aanmaken wordt slechts één keer gegenereerd - wanneer het formulier wordt gemaakt, vinden andere gebeurtenissen plaats telkens wanneer het formulier wordt weergegeven, geactiveerd en elke keer dat het formulier wordt getekend.

De gebeurtenishandler OnCreate bevat doorgaans code die initiële waarden instelt voor de eigenschappen van het formulier, evenals de besturingselementen ervan. Dat wil zeggen dat het de initiële formulierinitialisatie uitvoert naast de instellingen die zijn ingesteld tijdens de ontwikkeling van de applicatie. Bovendien bevat de handler aanvullende bewerkingen die moeten plaatsvinden eenmaal bij het maken van een formulier, bijvoorbeeld door bepaalde informatie uit een bestand te lezen en deze in een lijst te laden.

Laten we een voorbeeld nemen van een procedure die de OnCreate-gebeurtenis afhandelt Formulier 2:

Wanneer het formulier is aangemaakt, krijgt het een nieuwe titel, voorbeeldformulier, in de keuzelijst met invoervak ComboBox2 gegevens uit bestand laden lijst.txt, knop Knop 3 is geblokkeerd en de invoerfocus is ingesteld op de Edit1-editor.

Zichtbare eigendom

Van alles geschapen Delphi-vormen Wanneer de applicatie draait, wordt automatisch het hoofdformulier zichtbaar, hiervoor de eigenschap Zichtbaar dit formulier is ingesteld Echte waarde. Voor andere vormen de waarde van dit pand de standaardwaarde is False en na het starten van de applicatie worden ze niet op het scherm weergegeven. Als formulieren handmatig worden gemaakt, wordt het weergeven en verbergen ervan tijdens de werking van de applicatie beheerd door de programmeur via de eigenschap Zichtbaar. Zelfs als een formulier onzichtbaar is, kunnen de componenten ervan bijvoorbeeld vanuit andere formulieren worden bestuurd.

Onderliggende formulieren van een multidocumentaanvraag worden zichtbaar op het scherm zodra ze zijn aangemaakt.

In de bovenstaande procedures drukt u op de knoppen btnShowForm2 En btnVerbergFormulier2, gelegen in Form1, leidt er respectievelijk toe om Form2 weer te geven en te verbergen.

Methoden tonen en verbergen

U kunt ook de zichtbaarheid van formulieren op het scherm regelen met behulp van de methoden Show En Verbergen. De Show-procedure geeft het formulier weer in de modelloze modus, waarbij de eigenschap Visible is ingesteld op True en het formulier zelf naar de voorgrond wordt gebracht. De procedure Verbergen verbergt het formulier door de eigenschap Visible in te stellen op False.

Als het venster zichtbaar is, brengt het aanroepen van de Show-methode het formulier naar de voorgrond en geeft het invoerfocus.

Voorbeeld van het tonen en verbergen van een formulier:

Hier zijn de knopdrukken btnShowForm3 En btnVerbergForm3, gelegen in Form1, leidt respectievelijk tot de weergave en verwijdering van Form3 van het scherm.

Wanneer het formulier op het scherm wordt weergegeven, wordt de eigenschap zichtbaar evalueert naar True en de gebeurtenis wordt gegenereerd OnShow. Dienovereenkomstig, bij het verbergen van een formulier, het eigendom zichtbaar evalueert naar False en de gebeurtenis wordt gegenereerd AanVerbergen.

OnActivate- en OnDeActivate-gebeurtenissen

Wanneer een formulier invoerfocus krijgt, bijvoorbeeld wanneer een muisknop wordt ingedrukt in een gebied van het formulier, wordt het geactiveerd en wordt de gebeurtenis geactiveerd AanActiveren, en wanneer de focus verloren gaat, een gebeurtenis AanDeActiveren.

OnPaint-evenement

Evenement OpVerf wordt gegenereerd wanneer het nodig is om het formulier opnieuw te tekenen, bijvoorbeeld bij het activeren van het formulier als een deel ervan eerder door andere vensters werd bedekt.

Sluitingsmethode - sluit het formulier

Gebruik de methode om het formulier te sluiten dichtbij, waardoor het indien mogelijk van het scherm wordt verwijderd. Als het hoofdformulier wordt gesloten, werkt de applicatie niet meer.

In de bovenstaande procedure is de knop btnSluiten sluit het formulier Formulier2. De vorm wordt onzichtbaar gemaakt, maar niet vernietigd. Het is handig om een ​​passende titel voor deze knop in te stellen (eigenschap Caption), bijvoorbeeld Dichtbij.

De procedure Sluiten vernietigt het gemaakte exemplaar van het formulier niet en het formulier kan terug naar het scherm worden opgeroepen, met name met behulp van de methoden Show of ShowModaal.

Een formulier vernietigen (vrijgeven, vrijgeven of vernietigen)

Vernietiging van een formulier gebeurt met behulp van methoden Uitgave, Vrij of Vernietigen, waarna het onmogelijk wordt om met dit formulier te werken, en elke poging om toegang te krijgen tot het formulier of de componenten ervan zal een uitzondering (fout) veroorzaken. Bij het ontwerpen van splashscreens of tijdens de ontwikkeling kan de noodzaak ontstaan ​​om een ​​formulier te vernietigen grote toepassingen besparingen vereisen RAM. De gratis methode wordt beschouwd als de voorkeursmethode voor het verwijderen van een formulier, omdat er eerst wordt gecontroleerd of het kan worden verwijderd. In de procedure bijvoorbeeld

In de gegeven procedure is de knop btnVernietigen vernietigt de vorm Vorm3. Het is handig om deze knop bijvoorbeeld een passende titel te geven Verwijderen.

Gebeurtenissen bij het sluiten en vernietigen van een formulier

Wanneer een formulier wordt gesloten en vernietigd, worden de volgende gebeurtenissen gegenereerd, weergegeven in de volgorde waarin ze plaatsvinden:

1. AanDeActiveren;
2. AanVerbergen;

OnCloseQuery-gebeurtenis

Een gebeurtenis van het type TcloseQueryEvent vindt plaats als reactie op een poging om een ​​formulier te sluiten. De gebeurtenishandler ontvangt een booleaanse attribuutvariabele CanClose, die bepaalt of het formulier kan worden gesloten. Standaard staat deze variabele op True en kan het formulier worden gesloten. Als u de parameter CanClose instelt op False, blijft het formulier geopend. Deze functie moet bijvoorbeeld worden gebruikt om te bevestigen dat een venster is gesloten of om te controleren of de informatie die wordt bewerkt, op schijf is opgeslagen. De OnCloseQuery-gebeurtenis wordt altijd aangeroepen, ongeacht hoe het formulier wordt gesloten.

Hier is een voorbeeld van hoe u een formulier sluit:

Hier bij het sluiten van het formulier Formulier2 er wordt een verzoek verzonden om de bewerking te bevestigen, wat een modaal dialoogvenster is met tekst en twee knoppen - Ja En Nee. Als u op de knop Ja klikt, wordt het formulier gesloten; als u op de knop Nee klikt, wordt het formulier niet gesloten.

OnClose-gebeurtenis

Een gebeurtenis van het type TCioseEvent vindt plaats onmiddellijk voordat het formulier wordt gesloten. Het wordt meestal gebruikt om het standaardgedrag van een formulier te wijzigen wanneer het wordt gesloten. Om dit te doen, wordt een variabele doorgegeven aan de gebeurtenishandler Actie type TSluitAction, dat de volgende waarden kan aannemen:

• kanGeen(het formulier kan niet worden gesloten);
• caVerbergen(het formulier wordt onzichtbaar gemaakt);
• caGratis(het formulier wordt vernietigd en het bijbehorende geheugen wordt vrijgegeven);
• caMinimaliseren(formuliervenster is geminimaliseerd) - standaardwaarde voor MDI-formulieren.

Wanneer u een venster sluit met Dichtbij Actievariabele standaard is het ingesteld op caHide en wordt het formulier onzichtbaar gemaakt. Wanneer een formulier wordt vernietigd, bijvoorbeeld met behulp van de Destroy-methode, wordt de Action-variabele standaard ingesteld op caFree en wordt het formulier vernietigd.

De gebeurtenis vindt plaats wanneer een formulier wordt gesloten door op de knop Sluiten in het systeemmenu te klikken of door de methode Sluiten aan te roepen. Wanneer het hoofdformulier van de toepassing wordt gesloten, worden alle andere vensters gesloten zonder de gebeurtenis OnClose aan te roepen.

In de bovenstaande procedure bij het sluiten van het formulier Formulier2 het teken van wijziging van de inhoud van de Memo1-editor is aangevinkt. Als de gegevens in Memo1 zijn gewijzigd, sluit het formulier niet.

onDestroy-evenement

Een gebeurtenis van het type TNotifyEvent vindt plaats vlak voordat het formulier wordt vernietigd en wordt doorgaans gebruikt om bronnen vrij te maken.

onResize-gebeurtenis

Telkens wanneer de formuliergrootte verandert terwijl de toepassing actief is, wordt er een gebeurtenis van het type TNotifyEvent gegenereerd. De handler voor deze gebeurtenis kan code bevatten die bijvoorbeeld de grootte van vensterbesturingselementen wijzigt die geen eigenschap Align hebben.

procedure TForml. Formaat wijzigen (afzender: TObject);

beginnen

// Stel de grootte en positie van het rijraster in

StringGrid1. Links: = 10;

StringGrid1. Bovenkant := 5 ;

StringGrid1. Breedte:=Vorm1. Klantbreedte € 20;

StringGrid1. Hoogte:=Vorm1. Klanthoogte € 15;

Knop1. Hoogte ;

// Stel de knoppositie in

Knop1. Links:=Form1. Clientbreedte � 10� Knop1. Breedte ;

Knop1. Boven := Vorm1. Klanthoogte - 5 - Knop1. Hoogte ;

einde ;

• Form1 bevat twee componenten: StringGrid1 en Button1. Deze componenten zijn als volgt in de vorm gerangschikt:
• het raster StringGrid1 beslaat de gehele breedte van het clientgebied van Form3, de linker- en rechtermarges zijn 10 pixels;
• Button1 (Sluiten) is uitgelijnd met de rechterrand van StringGrid1;

De afstanden tussen het raster, de knop, de boven- en onderrand van het formulier zijn 5 pixels.

Wanneer u de grootte van Form1 wijzigt, worden de parameters die de grootte en positie van het rijraster specificeren, evenals de positie van de knop, opnieuw berekend.

Eigenschap FormStyle - formulierstijl

• De stijl van het formulier wordt bepaald door een eigenschap van het type TFormstyle, die de volgende waarden aanneemt: fsNormaal
• (standaardstijl gebruikt voor de meeste vensters, inclusief dialoogvensters); fsMDiChild
• (onderliggend formulier in een aanvraag met meerdere documenten); fsMDiForm
• (bovenliggend formulier in een aanvraag met meerdere documenten); fsBlijfOnTop (een formulier dat na het starten altijd boven andere vensters wordt weergegeven) - meestal gebruikt in de uitvoer systeeminformatie

of het programma-informatiepaneel.

Het formulier kan dynamisch van stijl veranderen - tijdens de uitvoering van het programma, bijvoorbeeld bij het selecteren van een menu-item. Wanneer het formulier de stijl verandert, wordt de OnShow-gebeurtenis geactiveerd. dynamische verandering vorm stijl:

Bij het selecteren van een menu-item mnuTop het formulier wisselt van stijl tussen waarden De stijl van het formulier wordt bepaald door een eigenschap van het type TFormstyle, die de volgende waarden aanneemt: En (bovenliggend formulier in een aanvraag met meerdere documenten);. De stijlwijziging wordt grafisch weergegeven met een vinkje in de titel van dit menu-item.

BorderStyle-eigenschap: randeigenschappen van formulieren

Elk formulier heeft een selectiekader. Het uiterlijk en gedrag van de rand wordt bepaald door een eigenschap van het type TFormBorderstyle. Het kan de volgende waarden aannemen:

• bsDialoog(dialoogformulier);
• bsEnkel(formulier met onveranderlijke afmetingen);
• bsGeen(het formulier heeft geen zichtbaar frame of titel en kan niet worden vergroot of verkleind) - vaak gebruikt voor screensavers;
• bsAanzienlijk(normale, aanpasbare vorm) - heeft standaard een titelbalk en kan elke reeks knoppen bevatten;
• bsToolvenster(werkbalkformulier);
• bsSizeToolwin(aanpasbare werkbalkvorm).

Het visuele verschil tussen dialoogformulieren en gewone formulieren is dat een dialoogformulier alleen sluit- en helpknoppen in de titel kan bevatten. Bovendien kan de gebruiker het formaat van het dialoogvenster niet wijzigen.

Het onvermogen om de grootte van formulieren van sommige stijlen te wijzigen geldt alleen voor de gebruiker; u kunt de muis niet gebruiken om de rand van het formulier in de ene of de andere richting te verplaatsen. Wanneer u een toepassing voor een formulier van welke stijl dan ook uitvoert, kunt u programmatisch alle toegestane venstergroottes instellen en wijzigen.

Het formulier kan dynamisch van stijl veranderen - tijdens de uitvoering van het programma, bijvoorbeeld bij het selecteren van een menu-item. Wanneer het formulier de stijl verandert, wordt de OnShow-gebeurtenis geactiveerd. programma verandering vorm maten:

Wanneer de knop wordt ingedrukt btnResizeForm De breedte van Form2 neemt met 100 pixels toe, zelfs als de eigenschap BorderStyle is ingesteld op bsDialog, bsSingle of bsNone.

ShowModal-methode

Als u de dialoogstijl van het formulier instelt, wordt deze niet modaal en kan de gebruiker naar andere toepassingsvensters navigeren. Gebruik de methode om een ​​formulier, inclusief een dialoogvenster, in de modale modus te starten ShowModaal. Stijl bepaalt dus verschijning vorm, maar niet zijn gedrag.

BorderIcons-eigenschap

Er zijn 4 soorten knoppen die in het titelgebied kunnen worden weergegeven. De set knoppen die wordt geïmplementeerd, definieert een eigenschap van het type TBorderIcons, die combinaties van de volgende waarden kan aannemen:

• blSysteemMenu(het venster heeft een systeemmenu en kan systeemmenuknoppen bevatten);
• blMinimaliseren(het venster bevat een minimaliseerknop);
• blMaximaliseren(het venster bevat een knop voor maximaliseren/herstellen);
• blHelp(het venster bevat een helpknop met een vraagteken en contextgevoelige hulp).

Het systeemmenu is een gemeenschappelijke reeks voor iedereen Windows-ramen commando's, bijvoorbeeld Instorten of Dichtbij. Als een venster een systeemmenu heeft, wordt er aan de linkerkant een applicatiepictogram weergegeven in het titelgedeelte; wanneer u erop klikt, verschijnen de opdrachten van dit menu en in het titelgedeelte aan de rechterkant bevindt zich een knop om het formulier te sluiten. (zie schermafdruk).

De verschillende vastgoedwaarden zijn niet onafhankelijk van elkaar. Dus als er geen systeemmenu is, wordt er geen enkele knop weergegeven. Als er knoppen voor uitvouwen en samenvouwen zijn, verschijnt de Help-knop niet. Of er knoppen verschijnen, hangt ook af van de stijl van het formulier. Het weergeven van knoppen voor uitvouwen en samenvouwen is bijvoorbeeld alleen mogelijk voor normale en aanpasbare werkbalkvormen.

Normaal gesproken worden de formulierstijl en de set koptekstknoppen ingesteld tijdens de ontwikkeling van de applicatie in het Object Inspector-venster. In dit geval zijn in het ontworpen formulier het gebruikelijke frame en drie knoppen (uitvouwen, samenvouwen en sluiten van het formulier) altijd zichtbaar, ongeacht de waarde van de eigenschappen en. De opgegeven formulierstijl en set knoppen worden zichtbaar wanneer het programma wordt uitgevoerd.

Vorm omvat cliënt En niet-klant gebieden. Niet-klantgedeelte bezet door het frame, de titel en de hoofdmenubalk. Normaal gesproken wordt dit gebied getekend door Windows en wordt het niet aangeraakt door de programmeur. Indien nodig kan de programmeur het bericht in het niet-clientgedeelte onderscheppen en verwerken WM_NCPaint.

ClientWidth- en ClientHeight-eigenschappen

Het klantengedeelte bevat meestal verschillende elementen controle, tekst wordt uitgevoerd of afbeeldingen worden weergegeven. Vergelijkbaar met hoe eigenschappen Breedte En Hoogte bepaal de afmetingen van het gehele formulier, eigenschappen Klantbreedte En KlantHoogte typ geheel getal stel de breedte en hoogte (in pixels) van het clientgedeelte van het formulier in.

In de bovenstaande procedure worden de groottewaarden van het klantengebied weergegeven in de kop van het formulier.

Meestal wordt het formulier met de muis gesleept, waarvan de aanwijzer ergens in het titelgebied staat. Indien nodig kunt u het formulier verplaatsen door de aanwijzer op het clientgebied te plaatsen, waarvoor u de bijbehorende bewerkingen programmatisch moet beschrijven. Eén manier is om het systeembericht te onderscheppen WM_NCHitTest. Hiervoor is een procedure opgesteld FormMove, dat analyseert waar de muisaanwijzer zich op het formulier bevindt wanneer op de knop wordt geklikt. De locatiecode van de muisaanwijzer staat in het veld Resultaat systeembericht van het type TMessage. Als de Resultaatwaarde 1 is, wat overeenkomt met een muisklik in het klantengebied, dan krijgt het Resultaatveld de nieuwe waarde 2 toegewezen, waarmee wordt gesimuleerd dat de muisaanwijzer zich in het titelgebied bevindt. In procedure FormMove eerste instructie geërfd roept een vooraf gedefinieerde handler aan voor de onderschepte gebeurtenis.

Om aan Delphi aan te geven dat de FormMove-procedure een handler is voor de WM_NCHitTest-gebeurtenis, wordt deze gedeclareerd in de TForm1-formulierklasse met behulp van een speciale syntaxis die het sleutelwoord bevat bericht. Als systeemberichthandler bevat de procedure één parameter van het type TMessage.

Namen Verplaatsformulier En Bericht De procedure en de parameters ervan kunnen worden gewijzigd.

Menu-eigenschap

Het menu dat door het formulier wordt weergegeven, wordt gespecificeerd door de accommodatie Menu typ THoofdmenu. Bij het ontwikkelen van een applicatie het plaatsen van een component Hoofdmenu Het hoofdmenu op het formulier zorgt ervoor dat de waarde MainMenu1 automatisch wordt toegewezen aan de eigenschap Menu. Dit is de gemakkelijkste manier om naar het hoofdmenu te linken. Als tijdens de uitvoering van een toepassing een formulier verschillende menu's moet weergeven, kunt u via de eigenschap Menu een ander hoofdmenu opgeven, bijvoorbeeld als volgt: Form1.Menu:= MainMenu2;

Icoon eigendom

Bij elk formulier wordt aan de linkerkant van het titelgebied een pictogram weergegeven, bepaald door de eigenschap Icon Ticon-type. Als het formulier niet het hoofdformulier in de applicatie is, wordt dit pictogram weergegeven wanneer het formulier wordt geminimaliseerd. Voor elke vormeigenschap Icon kan worden ingesteld met behulp van Objectinspecteurs of dynamisch (terwijl de applicatie actief is). Als er geen pictogram is opgegeven, gebruikt het formulier het pictogram dat in de eigenschap is opgegeven Icon Toepassingsobject. Dit laatste wordt ook weergegeven wanneer het is geminimaliseerd en weergegeven in de taakbalk Windows-pictogram hoofdvorm van de aanvraag.

In de bovenstaande procedure wordt het pictogram dynamisch vanuit het bestand geladen Afbeelding1.ico bij het maken van een formulier Vorm1.

Positie eigendom

De plaatsing en grootte van het formulier wanneer het wordt weergegeven, wordt bepaald door een eigenschap van het type TPosition. Het kan de volgende waarden aannemen:

• poOntworpen(het formulier wordt weergegeven in de positie en met de afmetingen die zijn ingesteld tijdens het ontwerp) - de standaardwaarde. De positie en afmetingen van het formulier worden bepaald door de eigenschappen Links, boven, breedte En Hoogte. Als de applicatie wordt uitgevoerd op een monitor met een lagere resolutie dan die waarop deze is ontwikkeld, kan een deel van het formulier buiten het scherm uitsteken;
• poSchermCentrum(het formulier wordt in het midden van het scherm weergegeven, de hoogte en breedte ervan - de eigenschappen Hoogte en breedte - veranderen niet);
• poStandaard(Windows bepaalt automatisch de startpositie en afmetingen van het formulier) - met deze waarde heeft de programmeur geen controle over deze parameters, dus dit is niet toegestaan ​​voor formulieren in toepassingen met meerdere documenten;
• poDefaultPosOnly(Windows bepaalt de beginpositie van het formulier, de afmetingen veranderen niet);
• poDefaultSizeOnly(Windows bepaalt de initiële breedte en hoogte van het formulier en plaatst het formulier op de positie die tijdens het ontwerp is bepaald);
• PoDesktopCenter(het formulier wordt in het midden van het scherm weergegeven, de hoogte en breedte veranderen niet);
• PoMainFormCenter(het formulier wordt weergegeven in het midden van het hoofdformulier van de applicatie, de hoogte en breedte veranderen niet) - deze waarde wordt gebruikt voor secundaire formulieren, wanneer toegepast op het hoofdformulier fungeert het als de poScreenCenter-waarde;
• PoOwnerFormCenter(het formulier wordt weergegeven in het midden van het formulier dat de eigenaar is, de hoogte en breedte van het formulier veranderen niet) - als de eigenaar niet is opgegeven voor het formulier (de eigenschap Eigenaar), dan gegeven waarde hetzelfde als poMainFormCenter.

De applicatie kan de locatie en grootte van de formulieren onthouden en de volgende keer dat deze wordt uitgevoerd de formulieren correct op het scherm weergeven. Om dit te doen, moet de programmeur de overeenkomstige gegevens naar het applicatie-initialisatiebestand of naar het systeem schrijven Windows-register, en wanneer de applicatie vervolgens draait, leest u deze gegevens uit en stelt u deze in voor de formulieren.

Actief eigendom

Eigendom Actief Met het Booleaanse type kunt u de activiteit van het formulier bepalen. Er kan slechts één formulier tegelijk actief zijn en de titel ervan wordt gemarkeerd in een speciale kleur (meestal blauw). Als de eigenschap Active True is, is het formulier actief (bevindt zich in de invoerfocus). Als False is het inactief. Deze eigenschap is leesbaar tijdens de uitvoering van het programma. Als u het formulier programmatisch wilt activeren, moet u de eigenschap of methode gebruiken Show(toon Modaal).

ChildActiveForm-eigenschap

In een toepassing met meerdere documenten kan het bovenliggende venster niet actief zijn, ongeacht de titelkleur. Gebruik de eigenschap om het actieve onderliggende venster van een toepassing met meerdere documenten te bepalen ChildActiveForm typ TForm van het bovenliggende formulier.

procedure TForm1CheckFormActive van de hoofdformuliermodule voert een activiteitscontrole uit voor de twee formulieren van de applicatie en geeft de bijbehorende informatie weer in de formulierkoppen.

WindowState-eigenschap



Een eigenschap van het type TWindowsstate bepaalt de weergavestatus van het formulier en kan een van de volgende drie waarden aannemen:

• wsNormal (normale status) - standaard;
• wsGeminimaliseerd(samengevouwen);
• wsGemaximaliseerd (uitgevouwen).

Knoppen btnMiniForm En btnNormaalForm in het formulier Form1 wordt samengevouwen en de normale toestand van het formulier Form2 wordt dienovereenkomstig hersteld.

Het formulier waarvoor de weergavestatus op het scherm wordt gewijzigd, moet eerst worden gemaakt met behulp van de methoden Formulier maken of Creëren. Als het formulier niet is gemaakt, wordt er bij het openen ervan een uitzondering gegenereerd, ondanks het feit dat de formuliervariabele in de module is gedeclareerd. Als een formulier wordt aangemaakt maar niet op het scherm wordt weergegeven, treden er wijzigingen in de status (windowstate-eigenschappen) op, maar de gebruiker ziet dit pas als het formulier op het scherm wordt weergegeven.

ActiveControl-eigenschap

Omdat het een container is, bevat het formulier andere besturingselementen. Vensterbesturingselementen (afstammelingen van de klasse TWinControl) kunnen invoerfocus krijgen. Een eigenschap van het type TWinControl bepaalt welk formulierelement focus heeft. Om een ​​element te selecteren dat invoerfocus heeft (het actieve element), kunt u deze eigenschap bij het uitvoeren van het programma op de gewenste waarde instellen:

Dezelfde bewerking wordt uitgevoerd door de methode Focus instellen waarmee de invoerfocus voor de vensterbediening wordt ingesteld:

AutoScroll-eigenschap



Als de venstergrootte niet groot genoeg is om alle interfacecomponenten in het formulier weer te geven, kunnen er schuifbalken op het formulier verschijnen. De eigenschap AutoScroll van het type Boolean bepaalt of ze automatisch verschijnen. Als de eigenschap AutoScroll True is (de standaardinstelling), verschijnen en verdwijnen schuifbalken automatisch, zonder enige actie van de programmeur. De behoefte aan schuifbalken kan bijvoorbeeld ontstaan ​​als de gebruiker het formaat van het formulier verkleint, zodat niet alle besturingselementen volledig zichtbaar zijn. Als de eigenschap AutoScroll is ingesteld op False, implementeert de programmeur de controle over de weergave van informatie handmatig via de eigenschappen HorzScrollBar (horizontaal scrollen) En VertScrollBar(verticaal scrollen) typ TControlScrollBar van het formulier.

ScrollInView-methode

Om schuifbalken programmatisch te besturen, kunt u de methode gebruiken ScrollInView. De ScrollInView (AControl: TControl) procedure verandert automatisch de posities van de schuifbalken zodat gespecificeerd per parameter De AControl-bediening is nu zichtbaar in het weergavegebied.

KeyPreview-eigenschap



Een Booleaanse eigenschap bepaalt of het formulier toetsenbordgebeurtenissen afhandelt voordat de besturingselementen van het formulier deze afhandelen. Als de eigenschap False is (de standaardinstelling), gaan toetsenbordgebeurtenissen naar het actieve besturingselement (die met invoerfocus). Wanneer u de eigenschap KeyPreview instelt op True, is het formulier het eerste dat toetsaanslagberichten ontvangt en hierop kan reageren, wat doorgaans wordt gebruikt om toetscombinaties af te handelen, ongeacht of de besturingselementen van het formulier actief zijn.

In de bovenstaande procedure het formulier Vorm1 verwerkt alfanumerieke toetsaanslagen en geeft het ingevoerde teken weer in een dialoogvenster Informatie.

Het formulier kan geen toetsaanslagen verwerken<ТаЬ>vanwege het speciale doel ervan.

MDichildCount-eigenschap en Cascade-methode

Het formulier bevat een rij eigenschappen En methoden, Bijvoorbeeld MDichildCount-eigenschap En Cascade-methode, ontworpen voor het organiseren van toepassingen met meerdere documenten.