11. Formulaires Événements

11.1. Dérivés TCustomForm

OnActivate

Cet événement se produit lorsque le formulaire est créé ou lorsque l'évolution d'une forme à une autre dans l'application. Pour détecter quand une autre application est passée à notre événement est utilisé OnActivate Taplication objet.

 Classes __property:: TNotifyEvent OnActivate = {read = FOnActivate, écrire = FOnActivate, stockées = ISForm}; 

Le code suivant ajoute à la légende de Form2 à quand la zone de liste à Form1 à Form2 est activé.

 # Include "Unit1.h" / / si nous pouvons nous référer à Form1.

void __fastcall TForm2: FormActivate (TObject * Sender)
{
	Form1-> Articles ListBox1-> Ajouter (Légende Screen-> ActiveForm->);
} 

OnClose

Lorsque vous fermez le formulaire événement OnClose se produit. Ce qui fait un appel à la OnCloseQuery pour vérifier si il est juste de fermer le formulaire. Si les rendements OnCloseQuery false, le formulaire ne se ferme pas.

 enum {canons TCloseAction, Cahide, caFree, caMinimize};
__fastcall typedef void (* __closure TCloseEvent) (System:: TObject * Sender, TCloseAction et d'action);
__property TCloseEvent OnClose = {read = FOnClose, écrire = FOnClose, stockées = ISForm}; 

Le formulaire est fermé à l'aide de la méthode Close ().

Le TcloseEvent méthode indique comment fermer le formulaire. La valeur des paramètres de la variable d'action détermine si le formulaire est fermé.

Cet exemple affiche une boîte de dialogue de message Lorsque l'utilisateur tente de fermer le formulaire. Si l'utilisateur clique sur le bouton Oui, la forme étroite; Sinon, le reste forme ouverte.

 void __fastcall TForm1:: FormClose (TObject * Sender, TCloseAction et d'action)
{
if (Application-> MessageBox ("Fermer l'application?", "Close? MB_YESNO) == mrYes)
	Action = caFree;
d'autre
	Action = taxe;
} 

OnCloseQuery

Se produit lorsque la méthode Close est appelée ou lorsque l'utilisateur agit sur ​​l'icône de fermeture dans la barre d'outils du formulaire.

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

CanClose variable détermine si le formulaire peut être fermé. La valeur par défaut est vrai.

Par exemple, vous pouvez utiliser le OnCloseQuery événement pour enregistrer un document dans un fichier avant de fermer la forme.

Lorsque l'utilisateur tente de fermer le formulaire dans cet exemple, un message de dialogue apparaît demandant à l'utilisateur si il est OK pour fermer le formulaire. Si l'utilisateur choisit le bouton Oui, la forme proche. Si l'utilisateur choisit Annuler ou Non, ne fermez pas le formulaire.

 void __fastcall TForm1:: FormCloseQuery (TObject * Sender, bool & CanClose)
{
if (Application-> MessageBox ("Fermez le formulaire?", "Close? MB_YESNOCANCEL)! = mrYes)
	CanClose = false;
} 

OnCreate

Se produit lorsque le formulaire est créé. Avec cet événement effectuer toutes les tâches nécessaires avant l'opération de la forme. Seuls OnCreate événement se produit pour chaque forme.

 Classes __property:: OnCreate TNotifyEvent = {read = FOnCreate, écrire = FOnCreate, stockées = ISForm}; 

Ce gestionnaire d'événements OnCreate très simple a assuré que la forme est la même couleur que la couleur de votre système d'espace de travail d'application Windows:

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

Note: La propriété de couleur dans cet exemple n'est pas précéder le nom de la forme. Si vous écrivez l'instruction de ce genre,

 Form1-> couleur = clAppWorkSpace; 

Sans l'application ne s'exécutera pas d'erreur, Form1, parce que non encore exister au moment de ce code est exécuté

OnDeactivate

Se produit lorsque le formulaire perd le focus. Cet événement est utilisé pour contrôler le passage de la forme active actuellement à une autre forme de la même application. Lorsque vous réussissez votre demande à l'autre, cet événement ne se produit pas. Pour contrôler le rythme de mise en œuvre, utilisez l'événement objet OnDeactivate Taplication.

 Classes __property:: TNotifyEvent OnDeactivate = {read = FOnDeactivate, écrire = FOnDeactivate, stockées = ISForm}; 

OnDestroy

Face à l'événement OnCreate. Est utilisée pour libérer la mémoire allouée dynamiquement qu'une forme, ou pour le nettoyage.

 Classes __property:: TNotifyEvent OnDestroy = {read = FOnDestroy, écrire = FOnDestroy, stockées = ISForm}; 

Le code suivant dynamiquement Appelé BtnMyButton Créer un bouton avec la légende «Mon Button". La mémoire associée à la touche est supprimé lorsque le formulaire est détruit.

 __fastcall TForm1:: TForm1 (Owner * TComponent) 

 : TForm (Owner) 
 { 
 BtnMyButton = new TButton (this); 
 BtnMyButton-> Parent = this; 
 Légende BtnMyButton-> = "Mes boutons"; 
 } 
 //------------------------------------------------ ------------------ 
 void __fastcall TForm1:: FormDestroy (TObject * Sender) 
 { 
 supprimer BtnMyButton; 
 } 

Ordre des événements pour créer et détruire le formulaire

Depuis la création du formulaire et la propriété Visible est vrai, les événements suivants se produisent dans l'ordre de la liste:

Puisque la forme est fermée et libère la mémoire, les événements suivants se produisent dans l'ordre de la liste:

OnHelp

Se produit lorsque le formulaire reçoit une demande d'assistance.

bool __fastcall typedef (* __closure THelpEvent) (mot de commande, des données int, bool & CallHelp)
Classes __property:: OnHelp THelpEvent = {read = FOnHelp, écrire = FOnHelp};

OnHide

Se produit lorsque le formulaire est masqué (lorsque la propriété Visible la valeur false)

 Classes __property:: TNotifyEvent OnHide = {read = FOnHide, écrire = FOnHide, stockées = ISForm}; 

Cet exemple utilise deux formes, chacune avec une étiquette et un bouton. Lorsque l'utilisateur clique sur un bouton, l'affichage de l'Autre forme et disparaît sous la forme actuelle. En outre, un message apparaît sur ​​l'étiquette de la forme qui montre, indiquant que d'autres forment le est caché. Cette section est la mise en œuvre de Unit1:

 # Include "Unit2.h"

//------------------------------------------------ ------------------
__fastcall TForm1:: TForm1 (Owner * TComponent)
: TForm (Owner)
{
}
//------------------------------------------------ ------------------
void __fastcall TForm1:: Button1Click (TObject * Sender)
{
Afficher Form2-> ();
Hide ();
}
//------------------------------------------------ ------------------
void __fastcall TForm1:: FormHide (TObject * Sender)
{
Form2-> Légende Label1-> = "Form1 se cache"
}

Cette section est la mise en œuvre de Unit2:

# Include "Unit1.h"
//------------------------------------------------ ------------------
# Ressources Pragma "*. dfm"
TForm2 Form2 *;
//------------------------------------------------ ------------------
__fastcall TForm2:: TForm2 (Propriétaire * TComponent)
: TForm (Owner)
{
}
//------------------------------------------------ ------------------
void __fastcall TForm2:: Button1Click (TObject * Sender)
{
Afficher Form1-> ();
Hide ();

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

OnPaint

Se produit lorsque le formulaire doit être redessinée. Lorsque vous devez constamment afficher un objet sur un formulaire, ou à la suite de redimensionnement du formulaire.

 Classes __property:: OnPaint TNotifyEvent = {read = FOnPaint, écrire = FOnPaint, stockées = ISForm}; 

Le code suivant charge un fond bitmap sur la toile du formulaire principal dans le gestionnaire d'événement OnPaint. Dans le fichier d'en-tête de l'unité 1. pour ajouter un membre privé de type TForm1 Graphics:: TBitmap nommé TheGraphic;

 void __fastcall TForm1:: FormPaint (TObject * Sender) / / gestionnaire d'événement OnPaint
{
Form1-> Canvas-> Draw (0, 0, TheGraphic) / / Dessine le graphique sur la toile
}
void __fastcall TForm1:: FormCreate (TObject * Sender) / / gestionnaire d'événements OnCreate
{
TheGraphic Graphics = new:: TBitmap (); / / Créer l'objet bitmap
TheGraphic-> LoadFromFile ("C: \ APP \ BKGRND.BMP") / / Charge l'image à partir d'un fichier
} 

OnResize

Est activé à chaque fois que vous redimensionnez le formulaire. Cet événement est utilisé pour ajuster la position des composants sur le formulaire ou de redessiner.

 Classes __property:: TNotifyEvent OnResize = {read = FOnResize, écrire = FOnResize, stockées = ISForm}; 

Maintient le code suivant sur ​​le bord droit Button1 contre le bord droit de Form1 Form1 Quand est redimensionnée.

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

OnShow

Se produit juste avant que le formulaire est visible (lorsque la propriété Visible a la valeur true). Vous pouvez utiliser cet événement pour effectuer toute procédure requise par le formulaire avant de devenir visible.

 Classes __property:: TNotifyEvent OnShow = {read = FOnShow, écrire = FOnShow, stockées = ISForm}; 

Cette couleurs par exemple la forme et le changement quand il devient visible IST légende:

 void __fastcall TForm1:: FormShow (TObject * Sender)
{
Couleur = clLime;
Caption = "Je suis affichage"
}