11. Veranstaltungen Forms

11.1. Derivate TCustomForm

OnActivate

Das Event wird erzeugt, wenn Sie erstellen oder Form verändert app als eine Form zu einem anderen innerhalb der EU. Um festzustellen, wenn eine andere Anwendung ist es, unseren Ereignis übergeben wird OnActivate Taplication Objekt.

 __property Klassen:: TNotifyEvent OnActivate = {read = FOnActivate, schreiben = FOnActivate, gelagert = ISForm}; 

Der folgende Code fügt, um die Beschriftung von Form2 auf, wenn Sie zu Form1 Listenfeld auf Form2 wird aktiviert.

 # Include "Unit1.h" / / so können wir zu Form1 finden.

void __fastcall TForm2: FormActivate (TObject * Sender)
{
	Form1-> ListBox1-> Items-> Add (Screen-> ActiveForm-> Caption);
} 

OnClose

Wenn Sie Formular schließen Sie das Formular OnClose-Ereignis eintritt. Das macht einen Aufruf an die OnCloseQuery zu überprüfen, ob die es in der Nähe Recht. Wenn OnCloseQuery false zurückgibt, wird das Formular nicht schließen.

 enum {TCloseAction Geschütze, Cahide, caFree, caMinimize};
typedef void __fastcall (__closure * TCloseEvent) (System:: TObject * Sender, TCloseAction & Action);
__property TCloseEvent OnClose = {read = FOnClose, schreiben = FOnClose, gelagert = ISForm}; 

Das Formular wird geschlossen mit der Close ()-Methode.

Die Methode gibt an, wie TcloseEvent schließen Sie das Formular. Der Wert der Parameter der Aktion Variable bestimmt, ob das Formular geschlossen wird.

Dieses Beispiel zeigt eine Meldung im Dialogfeld wenn der Benutzer versucht die Form zu schließen. Klickt der Benutzer auf die Schaltfläche Ja, das Formular zu schließen, andernfalls Form bleibt öffnen Sie die.

 void __fastcall TForm1:: FormClose (TObject * Sender, TCloseAction & Action)
{
if (Application-> MessageBox ("Anwendung schließen?", "Close?" MB_YESNO) == mrYes)
	Action = caFree;
sonst
	Action = Gebühr;
} 

OnCloseQuery

Tritt ein, wenn die Close-Methode aufgerufen wird oder wenn der Benutzer wirkt auf das Schließen-Symbol in der Symbolleiste des Formulars.

 typedef void __fastcall (__closure * TCloseQueryEvent) (System:: TObject * Sender, bool & CanClose)
__property TCloseQueryEvent OnCloseQuery = {read = FOnCloseQuery, schreiben = FOnCloseQuery, gelagert = ISForm}; 

CanClose Variable bestimmt, ob das Formular geschlossen werden kann. Der Standardwert ist true.

Zum Beispiel können Sie das Ereignis OnCloseQuery, um ein Dokument in einer Datei vor dem Schließen der Form zu speichern.

Wenn der Benutzer versucht, beispielsweise schließen Sie das Formular in diesem, eine Nachricht Dialog erscheint, die fragt den Benutzer, wenn sie Form ist OK die sich zu schließen. Wählt der Benutzer die Schaltfläche Ja, das Formular zu schließen. Wählt der Benutzer Abbrechen oder Nein, nicht das Formular zu schließen.

 void __fastcall TForm1:: FormCloseQuery (TObject * Sender, bool & CanClose)
{
if (Application-> MessageBox ("Schließen Sie das Formular?", "Close?" MB_YESNOCANCEL)! = mrYes)
	CanClose = false;
} 

OnCreate

Tritt ein, wenn das Formular zum ersten Mal erstellt. Mit dieser Veranstaltung bilden führen alle notwendigen Aufgaben vor der Operation der. Nur OnCreate-Ereignis tritt für jede Form.

 __property Klassen:: TNotifyEvent OnCreate = {read = FOnCreate, schreiben = FOnCreate, gelagert = ISForm}; 

Diese sehr einfache OnCreate Ereignishandler Form versichert, dass die die gleiche Farbe wie die Farbe Ihres Windows-Systems Anwendung Arbeitsbereich:

 void __fastcall TForm1:: FormCreate (TObject * Sender)
{
Farbe = clAppWorkSpace;
} 

Hinweis: Die Color-Eigenschaft in diesem Beispiel ist nicht Vorrede mit dem Namen des Formulars. Wenn Sie schreiben die Anweisung wie folgt,

 Form1-> Color = clAppWorkSpace; 

Ohne die Anwendung wird nicht ausgeführt, Fehler, Form1 Da noch nicht ausgeführt existieren zum Zeitpunkt dieser Code

OnDeactivate

Tritt ein, wenn das Formular den Fokus verliert. Diese Veranstaltung dient zur Anwendung Kontrolle der Übergang von den derzeit aktiven Form in eine andere Form desselben. Wenn Sie unsere Anwendung übergeben zum anderen, führt dieses Ereignis nicht auftreten. Zur Steuerung der Geschwindigkeit der Umsetzung, Anwendung des Ereignisobjekts OnDeactivate Taplication.

 __property Klassen:: TNotifyEvent OnDeactivate = {read = FOnDeactivate, schreiben = FOnDeactivate, gelagert = ISForm}; 

OnDestroy

Gegenüber OnCreate-Ereignis. Dient zur Reinigung frei dynamisch zugewiesenen Speicher, eine Form, oder für.

 __property Klassen:: TNotifyEvent OnDestroy = {read = FOnDestroy, schreiben = FOnDestroy, gelagert = ISForm}; 

Der folgende Code dynamisch Called BtnMyButton Erstellen Sie eine Schaltfläche mit der Beschriftung "My Button". Der Speicher-Taste im Zusammenhang mit der gelöscht wird, wenn das Formular zerstört wird.

 __fastcall TForm1:: TForm1 (TComponent * Owner) 

 : TForm (Eigentümer) 
 { 
 BtnMyButton = new TButton (this); 
 BtnMyButton-> Parent = this; 
 BtnMyButton-> Caption = "My Button"; 
 } 
 //------------------------------------------------ ------------------ 
 void __fastcall TForm1:: FormDestroy (TObject * Sender) 
 { 
 löschen BtnMyButton; 
 } 

Reihenfolge der Ereignisse zu erstellen und zu zerstören Form

Da die Form erstellt wird und die Visible-Eigenschaft true ist, treten die folgenden Ereignisse in der Reihenfolge der Liste:

Da die Form wird geschlossen und gibt den Speicher, treten die folgenden Ereignisse in der Reihenfolge der Liste:

OnHelp

Tritt ein, wenn das Formular mit einem Antrag für Unterstützung.

typedef bool __fastcall (__closure * THelpEvent) (Word-Befehl, int Daten, bool & CallHelp)
__property Klassen:: THelpEvent OnHelp = {read = FOnHelp, schreiben = FOnHelp};

OnHide

Tritt ein, wenn das Formular ausgeblendet wird (wenn die Visible-Eigenschaft falsch eingestellt)

 __property Klassen:: TNotifyEvent OnHide = {read = FOnHide, schreiben = FOnHide, gelagert = ISForm}; 

Dieses Beispiel verwendet zwei Formen, jeweils mit einem Label und einem Button. Klickt der Benutzer auf eine Schaltfläche, die andere Form erscheint und verschwindet das aktuelle Formular. Auch erscheint eine Meldung auf dem Etikett des Formulars, das zeigt, angibt, dass die andere Form ist versteckt. Dies ist der Abschnitt "Implementierung von Unit1:

 # Include "Unit2.h"

//------------------------------------------------ ------------------
__fastcall TForm1:: TForm1 (TComponent * Owner)
: TForm (Eigentümer)
{
}
//------------------------------------------------ ------------------
void __fastcall TForm1:: Button1Click (TObject * Sender)
{
Form2-> Show ();
Hide ();
}
//------------------------------------------------ ------------------
void __fastcall TForm1:: FormHide (TObject * Sender)
{
Form2-> Label1-> Caption = "Form1 versteckt"
}

Dies ist der Abschnitt "Implementierung von Unit2:

# Include "Unit1.h"
//------------------------------------------------ ------------------
# Pragma resource "*. dfm"
TForm2 * Form2;
//------------------------------------------------ ------------------
__fastcall TForm2: TForm2 (TComponent * Owner)
: TForm (Eigentümer)
{
}
//------------------------------------------------ ------------------
void __fastcall TForm2: Button1Click (TObject * Sender)
{
Form1-> Show ();
Hide ();

}
//------------------------------------------------ ------------------
void __fastcall TForm2: FormHide (TObject * Sender)
{
Form1-> Label1-> Caption = "Form2 versteckt"
} 

OnPaint

Tritt ein, wenn das Formular neu gezeichnet werden. Wenn Sie ständig Anzeige eines Objekts auf eine Form haben, oder als Ergebnis der Größenänderung des Formulars.

 __property Klassen:: OnPaint TNotifyEvent = {read = FOnPaint, schreiben = FOnPaint, gelagert = ISForm}; 

Der folgende Code lädt eine Bitmap-Hintergrund auf die Leinwand des Hauptformulars in der OnPaint-Event-Handler. In der Header-Datei für Unit 1. zu Grafik fügen Sie einen privaten Member des Typs TForm1:: TBitmap namens TheGraphic;

 void __fastcall TForm1:: FormPaint (TObject * Sender) / / Event-Handler OnPaint
{
Form1-> Canvas-> Draw (0, 0, TheGraphic) / / Zeichnen Sie die Grafik auf der Leinwand
}
void __fastcall TForm1:: FormCreate (TObject * Sender) / / Event-Handler OnCreate
{
TheGraphic = new Graphics:: TBitmap (); / / Erstellen der Bitmap-Objekt
TheGraphic-> LoadFromFile ("C: \ APP \ BKGRND.BMP") / / Lade das Bitmap aus einer Datei
} 

OnResize

Aktiviert wird jedes Mal, wenn die Größe der Form. Dieses Ereignis wird verwendet, um Form die Position der Komponenten auf dem oder neu zu ziehen.

 __property Klassen:: TNotifyEvent OnResize = {read = FOnResize, schreiben = FOnResize, gelagert = ISForm}; 

Hält den folgenden Code an der rechten Kante Button1 gegen den rechten Rand von Form1 Form1 Wann ist verkleinert.

 void __fastcall TForm1:: FormResize (TObject * Sender)
{
Button1-> Links = Form1-> clientWidth - Button1-> Breite;
} 

OnShow

Tritt unmittelbar vor der Form sichtbar ist (wenn die Visible-Eigenschaft auf true festgelegt ist). Sie können dieses Ereignis verwenden, um sichtbar zu werden nimmt alle erforderlichen Verfahren durch die Form vor.

 __property Klassen:: TNotifyEvent OnShow = {read = FOnShow, schreiben = FOnShow, gelagert = ISForm}; 

Dieses Beispiel die Form und Farben ändern, wenn es Bildunterschrift Becomes STI sichtbar:

 void __fastcall TForm1:: FormShow (TObject * Sender)
{
Farbe = clLime;
Caption = "Ich bin Anzeigen"
}