Le Builder, pour améliorer la VCL, introduit des notions de POO supplémentaires par rapport à la norme C++. Nous allons les étudier rapidement.
Le Mot-Clé published
Chaque composant du Builder (une classe en fait) contient un certain nombre de propriétés (données) qui sont visibles dans l’inspecteur d’objets, et qui peuvent être modifiés durant la phase de développement.
Dans la déclaration de la classe (fichier .h en général), chacune de ces donnée est précédée du mot clé __published. Les deux traits __ indiquent que ce mot-clé est propre au C++ builder et n’existe pas (encore) en C++ standard.
Par exemple :
class TMaClasse
{
private :
int P1 ;
__published :
short P2 ;
public :
TMaClasse(void) ;
} ;
Le Mot-Clé property
Lorsqu’une donnée est déclarée property, cela permet de déclarer automatiquement comment des méthodes (fonctions) associées pour lire et/ou écrire la donnée. Par exemple :
class TForm :public ....
{
private :
.....
Graphics : :TIcon *FIcon ;
.....
void __fastcall SetIcon(Graphics : :TIcon *) ;
....
public :
....
__published :
____property Graphics : :TIcon* Icone={read=FIcon,write=SetIcon} ;
} ;
Un composant VCL est donc une classe C++. Toutes les classes VCL dérivent (directement ou non) de la classe abstraite TObject. à voir hiérarchie des classes VCL
Ces classes contiennent des données (champs), pouvant être : publiques (public), privées (private), protégées (protected), publiées (__published) et être ou non des propriétés (__property).
Elles contiennent également des méthodes (fonctions), pouvant être elles aussi privées, protégées ou publiques. Comme toute classe C++, il y a des méthodes particulières : les constructeurs et le destructeur.
Elle contiennent également des événements, en fait des fonctions de réponse a un évènement donné. (par exemple, réponse à l’évènement OnClick).
Chaque classe VCL dérive d’une ou plusieurs classes VCL, et peut avoir un ou plusieurs descendants. Tous les mécanismes d’héritage du C++ sont bien entendu valables.
Une classe VCL est dite " visuelle ", on parle également de composant. Dans l’éditeur du C++ Builder, une icône représente le composant, qui peut être utilisé directement, visuellement.
Un composant peut être créé et détruit automatiquement par le Builder, mais on peut également le créé (avec new) et le détruire (avec delete) " à la main ".
TEdit encapsule l’objet Windows " zone d’édition ", c’est à dire une petite zone dans laquelle l’utilisateur peut taper un texte.
Pour affecter un texte à un TEdit, il suffit d’affecter sa propriété Text :
Edit1->Text="Texte" ;
Pour lire le texte d’un TEdit, il suffit de lire sa propriété Text :
AnsiString s=Edit1->Text ;
Windows gère lui-même l’affichage du TEdit, le curseur texte, etc....
Il y a quelques événements associés au TEdit, comme OnChange qui indique que le texte contenu à l’intérieur à changé, ou OnKeyPress indiquant la frappe d’une touche.
Un bouton est en fait une fenêtre particulière, qui réagit à un évènement utilisateur tel qu’un clic de souris. Le système s’occupe en principe de dessiner le bouton, dans tous ses états, le programme n’a qu’à répondre aux événements du bouton.
Classes TButton et TBitBtn :
Ces classes VCL gèrent les comportements et l’affichage de boutons Windows sur lesquels l’utilisateur peut cliquer à la souris. Un TButton ne comporte qu’un texte, alors qu’un TBitBtn peut comporter une ou plusieurs images. Le C++ Builder fournit les images pour les actions suivantes : OK, Annuler, Aide, Fermer.... Ces boutons sont utilisés pour produire une action particulière.
Un programmeur peut dériver une classe TButton pour créer un nouveau type de bouton.
Classe TRadioButton :
Un bouton radio est un bouton particulier, qui possède deux états (actif ou non). Ils sont en général regroupés par groupe de boutons radio s’excluant mutuellement. Ils utilisés pour des choix multiples.
Classe TCheckBox :
Une case à cocher est un bouton à 2 états (coché ou non) qui fonctionne en bascule. Ils sont utilisés pour effectuer des choix binaires.
Pour tous les boutons, l’évènement le plus important est OnClick, qui se produit quand l’utilisateur " appuie " sur le bouton avec la souris. En général, on ne définit que la réponse à cet évènement.
Les menus sont un bon moyen d’interface pour proposer les actions du programme à l’utilisateur.
Sous Windows, les menus sont de deux types : déroulant et surgissant.
Les menus déroulants sont des instances de la classe TMainMenu. Ils sont en général créés durant la phase de développement mais peuvent être modifiés dynamiquement dans le programme.
Les menus surgissants sont des instances de la classe TPopupMenu. Ils sont très semblables aux menus déroulants.
La classe TMenuItem correspond à un élément de menu.
Pour un menu, le programmeur ne traite en général que l’évènement OnClick associé à chaque TMenuItem.
Il existe une multitude de composants listes, plus ou moins complexes, qui permettent de gérer visuellement une liste. Le programmeur accède aux éléments de celle-ci par la propriété Items du composant Liste. Les composants Liste standards sont les suivants :
TListBox, TComboBox, TCheckListBox, TTreeView, TDirectoryListBox, TDriveComboBox, TFilterComboBox, TCDirectoryOutline, TCCalendar.
Durant la phase de développement, on dépose sur la fiche (classe TForm : représente une fenêtre) les composants désirés. On modifie leurs propriétés principales (Name, Caption, Enabled par ex.) par l’inspecteur d’objets.