FAQ C++ BuilderConsultez toutes les FAQ

Dans beaucoup de méthodes, on trouve comme argument TObject *Sender. Cet argument est utilisé pour savoir quel est l'objet qui a appelé la méthode.
Voici un exemple simple pour clarifier : dans un nouveau projet, placez sur votre fiche deux boutons et double-cliquez sur le premier (Button1). Vous obtenez alors le code suivant :

1
2
3
4
void __fastcall TForm1::Button1Click(TObject *Sender) 
{ 
  
}

1
2
3
4
5
6
7
8
9
10
11
void __fastcall TForm1::Button1Click(TObject *Sender) 
{ 
  if (dynamic_cast <TButton *>(Sender) == Button1)  
  { 
    ShowMessage("Button1"); 
  } 
  else 
  { 
    ShowMessage("Button2"); 
  } 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
void __fastcall TForm1::Button1Click(TObject *Sender) 
{ 
  TButton *Button; 
  Button = dynamic_cast <TButton *> (Sender); 
  if (Button == Button1) 
  { 
    ShowMessage("Button1"); 
  } 
  else 
  { 
    if (Button == Button2) 
    { 
      ShowMessage("Button2"); 
    } 
    else 
    { 
      ShowMessage("Sender innatendu"); 
    } 
  } 
  Button->Caption = "Appuyé"; 
}

Confusion facile. Cependant, Parent et Owner sont deux concepts différents. Le Parent est quelque chose de visuel : le parent d'un composant est celui qui contient ce composant. Le parent d'un TEdit placé directement sur la fiche est la fiche (Form1). Le Owner d'un composant est le composant qui a la charge de détruire celui-ci lors de sa propre destruction. (Mais le Owner peut tout-à-fait être le Parent).

Quand vous créez dynamiquement un composant, vous devez passer le Owner en argument du constructeur. Vous devez ensuite affecter le Parent du contrôle afin qu'il s'affiche.

1
2
3
4
TPanel *Panel; 
// ... 
TLabel *Label = new TLabel(Form1); 
Label->Parent = Panel;

Tous les composants de C++ Builder peuvent être créés au moment de l'exécution du programme. Pour instancier un composant, il suffit d'appeler le constructeur de la classe correspondante par l'intermédiaire du mot clé new. Pour les composants visuels, il faut absolument définir la propriété Parent sinon le composant n'apparaitra pas.

Le composant donné en paramètre du constructeur est le propriétaire du composant nouvellement créé.

1
2
3
4
5
6
7
8
9
10
11
TButton *MonBouton; 
void __fastcall TForm1::Button1Click(Sender: TObject); 
{ 
   // La fenêtre est propriétaire du nouveau bouton 
   MonBouton := new TButton(this); 
   // mais c'est dans Panel1 qu'il doit s'afficher 
   MonBouton->Parent = Panel1; 
   // ensuite on définit les autres propriétés 
   MonBouton->Caption = "Bouton !"; 
   MonBouton->Left = 10; 
}

Le problème est qu'il faut garder trace des pointeurs pour pouvoir les utiliser et libérer la mémoire à la fin. Pour cela, il est possible d'utiliser la classe TList. La classe TList est une liste de pointeurs toute simple, avec un certain nombre de fonctionnalités pour gérer cette liste.

Création d'une TList :

liste = new TList;

liste->Add((void *)monObjet);

1
2
3
TLabel *label; 
label = (TLabel *)liste->Items[2]; // Accède au troisième élément de la liste 
// utilisation classique possible de label

Que le composant soit créé dynamiquement ou non, le lien entre un évènement et son implémentation se fait de la même manière. Comme pour un attribut ou une propriété, il suffit d'affecter le nom de la méthode qui va prendre en charge la gestion de l'évènement.
Bien entendu, lorsqu'on conçoit son application avec l'inspecteur d'objets, le fait de renseigner le nom des méthodes à côté du nom de l'évènement (onglet évènements de l'inspecteur d'objets) va générer cette association dans le dfm (il vous suffit de faire un clic droit sur la fiche puis Voir comme texte pour le constater).

Exemple :

1
2
3
4
void __fastcall TForm1::MonTraiteKeyPress(TObject *Sender, char &Key) 
{ 
   // traitement 
}

1
2
3
TEdit *EditDynamique = new TEdit(this); 
// diverses initialisations 
EditDynamique->OnKeyPress = MonTraiteKeyPress;