Composants standards de Lazarus
Sans vouloir être exhaustif, Nous décrivons ici quelques uns des composants Lazarus, que vous pouvez trouver sous l'onglet Standard:
Sans vouloir être exhaustif, Nous décrivons ici quelques uns des composants Lazarus, que vous pouvez trouver sous l'onglet Standard:
Nous utilisons depuis longtemps des zones de texte pour lire des données ou afficher des résultats avec les procédures de la librairie entrees_sortie.pas (Lire, LireEntier, LireNombre, Afficher, AfficherEntier, AfficherNombre). Avec ce qui suit, vous allez enfin savoir comment faire ceci sans utiliser ces procédures.
Pour afficher une expression de type chaine de caractère dans une zone de texte, il suffit d'affecter cette expression à l'attribut .Text de cet objet.
Exemple:
ZT.Text :='Toto';
affiche Toto dans la zone de texte ZT.
Si l'expression n'est pas de type chaine de caractère, il faut au préalable la convertir en chaine de caractère. On utilisera par exemple IntToStr pour afficher un nombre entier et FloatToStr pour afficher un nombre décimal.
Remarque: il peut paraitre étrange qu'une simple affectation produise un affichage à l'écran, étant donné qu'une affectation ne fait que copier de l'information en mémoire. En réalité, l'affectation d'une valeur à l'attribut Text d'une zone de texte, n'est pas une simple affectation. Nous reviendrons là dessus dans le deuxième cours de programmation objet.
Inversement, pour lire le contenu d'une zone de texte dans une variable de type chaine de caractères, on affecte à la variable la valeur de l'attribut .Text de la zone de texte.
Exemple:
Toto := ZT.Text;
affecte à Toto la chaine de caractères contenue dans ZT.Text.
De même que pour l'affichage, il faudra utiliser les fonctions de conversion si la variable n'est pas de type String. On utilisera par exemple StrToInt pour une variable de type Integer et StrToFloat pour une variable de type Double.
La méthode Clear() apliquée à une zone de texte permet d'effacer son contenu.
Reprenons notre bon vieux projet d'addition qui permettait d'additionner deux nombres entiers (la version présentée ici se trouve dans Exemple-ProgObjet1/ZoneTexte). Voici son interface graphique:
Nous avons ici trois zones de texte nommées ZoneTexteX, ZoneTexteY et ZoneTexteSomme. Et voici la nouvelle version de la procédure évènementielle associée au bouton Additionner:
procedure TForm1.BoutonAdditionnerClick(Sender: TObject); begin x := StrToInt(zoneTexteX.Text); y := StrToInt(ZoneTexteY.Text); somme := x + y; ZoneTexteSomme.Text := IntToStr(somme); end;
La classe TStrings ne représente pas un composant graphique particulier, mais elle est utilisée dans les classes TListBox (zones de liste), TMemo (mémo) et TComboBox (combobox) que nous présentons plus loin. C'est la raison pour laquelle il nous faut commencer par présenter cette classe.
Tout comme la classe TStringList que nous avons présenté dans la première partie du cours, TStrings est une classe qui permet de manipuler des listes de chaines de caractères.
En fait, TStringList n'est qu'une sous-classe de TStrings et toutes les méthodes Clear, Add, LoadFromFile, IndexOf ainsi que les attributs count et strings dont nous avions déjà parlé (voir classe TStringList), ne sont pas des attributs spécifiques de TStringList, mais des attributs hérités de la classe TStrings.
TStrings possède d'autres méthodes dont nous n'avons pas encore parlé comme SaveToFile et Delete. La première permet de sauvegarder son contenu dans un fichier et la deuxième, de supprimer un élément d'indice donnée (la première chaine est indicée 0).
Jusqu'à présent nous avons utilisé les zones de liste pour afficher du texte sur plusieurs lignes à l'aide des procédures Afficher, AfficherEntier, ... de la librairie entrees_sorties.pas.
En réalité, les zones de liste servent à autre chose. Elles sont utilisées pour permettre à l'utilisateur de choisir un élément dans une liste de choix.
Dans Lazarus, les zones de liste sont représentées par la classe TListBox. Cette dernière contient parmis ses attributs, un attribut nommé Items de type TStrings. C'est dans cet attribut que sont stockés les différents choix possibles sous la forme d'un objet de la classe TStrings.
On pourra donc ajouter un choix dans une zone de liste en appliquant la méthode Add à son attribut Items. De même, on pourra initialiser la liste des choix à partir d'un fichier, en appliquant la méthode LoadFromFile à cet attribut.
L'attribut ItemIndex est l'indice de l'élément sélectionné (le premier est indicé 0). S'il vaut -1, cela signfie qu'aucun élément n'est sélectionné.
L'attribut Sorted est un booléen qui détermine si la liste des choix doit être triée automatiquement par ordre alphabétique.
TlistBox contient (entre autres) une méthode nommée GetSelectedText. Il s'agit d'une fonction qui retourne le choix sélectionné par l'utilisateur. Si aucun choix n'est sélectionné, elle retourne la chaine vide.
Pour illustrer l'utilisation des zones de liste, nous présentons ici un exemple de projet simulant le site d'un magasin de bricolage. Ce projet se trouve dans le dossier Exemple-ProgObjet1/ZoneDeListe (ouvrir le fichier MagasinBricolage.lpi) . Voici son interface graphique:
La zone de liste de gauche (ZL_Categorie) est initialisée dès le démarrage du programme dans la procédure FormCreate:
procedure TForm1.FormCreate(Sender: TObject);
begin
ZL_Categorie.Items.Add ('Electricite');
ZL_Categorie.Items.Add ('Jardinage');
ZL_Categorie.Items.Add ('Materiaux');
ZL_Categorie.Items.Add ('Plomberie');
end;
Nous avons utilisée ici la méthode Add de la classe TStrings.
Une autre manière de procéder aurait été de saisir manuellement les différentes chaines de caractères "Electricite", "Jardinage", etc ... via l'inspecteur d'objet de Lazarus: on sélectionne la zone de liste ZL_Categorie, puis sa propriété Items dans l'inspecteur d'objet et enfin on clique sur les ... :
l'éditeur de chaînes permet alors de saisir les différents choix.
Lorsque l'utilisateur clique sur une des catégories de produit, les types de produits de cette catégorie sont affichés dans la deuxième zone de liste (nommée ZL_TypeProduit):
Voici le code de la procédure évènementielle gérant cet évènement:
1: procedure TForm1.ZL_CategorieClick(Sender: TObject); 2: var NomCategorie, NomFichierCategorie : String; 3: begin 4: NomCategorie := ZL_Categorie.GetSelectedText; 5: NomFichierCategorie := NomCategorie+'.txt'; 6: ZL_TypeProduit.Items.LoadFromFile(NomFichierCategorie); 7: ZL_TypeProduit.ItemIndex:=0; 8: end;
Pour comprendre son fonctionnement, il faut savoir que les types de produits d'une certaine catégorie se trouvent dans un fichier texte de même nom que la catégorie et d'extension '.txt'. Les types de produits de la catégorie Materiaux, se trouvent par exemple dans le fichier 'Materiaux.txt'.
Détaillons à présent les instructions de cette procédure évènementielle.
La ligne 4 permet de récupérer le nom de la catégorie de produit sélectionnée en appliquant la méthode GetSelectedText à la zone de liste ZL_Categorie.
La ligne 5 construit le nom du fichier contenant les différents types de produit de cette catégorie en concaténant l'extension '.txt' au nom de la catégorie.
La ligne 6 initialise la zone de liste ZL_TypeProduit avec les types de produit contenus dans ce fichier. Pour cela, la méthode LoadFromFile est appliquée à l'attribut Items de la zone de liste.
La ligne 7 enfin, définit le premier choix (choix d'indice 0) comme étant sélectionné. Cela explique pourquoi la premier type de produit apparait sélectionné dès que la liste des types de produit est affichée.
Si vous comparez le contenu du fichier Materiaux.txt avec la liste des matériaux affichés par le programme, vous constaterez que le programme les affiche dans l'ordre alphabétique alors qu'ils ne sont pas dans l'ordre alphabétique dans le fichier. Cela s'explique par le fait que l'attribut Sorted de la zone liste ZL_TypeProduit vaut True. Elle est donc automatiquement triée.
Un combobox est une sorte de combinaison entre une zone de texte et une zone de liste. La zone de texte permet à l'utilisateur de saisir un choix qui n'est pas présent dans la zone de liste.
De plus, un combobox prend moins de place qu'une zone de liste, car la liste des choix n'est pas systématiquement déployée.
Voici quelques attibuts utiles de la classe TComboBox:
On retrouve les attributs Items et Sorted des zones de listes. Par contre, la méthode GetSelectedText a disparu car le texte sélectionné se retrouve automatiquement dans l'attribut Text.
Autocomplete permet la complétion automatique des choix. Par exemple, s'il existe un choix commencant par un f, dès que l'utilisateur tape f, la zone de texte contiendra automatiquement le premier choix de la liste commencant par f et ce choix sera sélectionné dans la zone de liste. Si ce n'est pas le bon choix, il lui suffira en général de saisir quelques caractères de plus.
Enfin, lorsque l'attibut AutoDropDown vaut True, la liste est déployée dès que l'utilisateur tape un caractère dans la zone de texte.
L'exemple présenté ici se trouve dans le dossier ComboBox du dossier Exemple (projet ProjetMoyenTransport). Voici l'allure de l'interface graphique au démarrage du programme:
Le combobox est initialement vide. Comme nous avons mis AutoDropDown à True, la liste est automatiquement déployée dès que l'on tape un caractère:
Comme nous avons mis AutoComplete à True, si on tape M dans le combobox, ce choix est automatiquement complèté en Mobilette car c'est le premier choix de la liste commencant par un M:
L'utilisateur peut également saisir un choix qui ne se trouve pas dans la zone de liste:
Lorsqu'il clique sur le bouton "Afficher le choix", le choix sélectionné est affiché dans la zone de texte (ZT_Vehicule). Voici le code de la procédure évènementielle associée à ce bouton:
procedure TForm1.BT_AfficherChoixClick(Sender: TObject); begin ZT_Vehicule.Text := CB_Vehicule.Text; end;
Les cases à cocher sont utilisées pour saisir des informations du type vrai/faux ou oui/non. L'état coché/décoché de la case est mémorisé dans l'attribut Checked de type booléen. Avec Checked = True, la case est cochée. Sinon, elle ne l'est pas.
L'exemple présenté ici se trouve dans le dossier Exemple-ProgObjet1/CaseACocher (ouvrir ProjetHotel.lpi). Voici la fenêtre de l'application:
Lorsque l'utilisateur sélectionne ou dé-selectionne les options petit déjeuner ou douche, le prix de la chambre est autoamtiquement actualisé. Avec petit déjeuner:
Avec la douche en plus:
C'est trop cher. On enlève le petit déjeuner:
Voici la procédure évènementielle associée à la case à cocher "Petit déjeuner" (CC_PetitDej):
procedure TForm1.CC_PetitDejChange(Sender: TObject); begin AfficherLePrix (); end;
et voici celle associée à la case à cocher "Douche" (CC_Douche):
procedure TForm1.CC_DoucheChange(Sender: TObject); begin AfficherLePrix (); end;
Ces deux procédures appellent la procédure non-évènementielle AfficherLePrix que voici:
procedure AfficherLePrix (); var Prix : Double; begin Prix := 40; if Form1.CC_PetitDej.Checked then Prix := Prix + 5; if Form1.CC_Douche.Checked then Prix := Prix + 10; Form1.ZT_Prix.Text := FloatToStr(Prix); end;
Les boutons radio s'utilisent pour définir un choix parmis n, lorsque n n'est ni trop petit (pour n=2 on peut tout aussi bien prendre une case à cocher), ni trop grand (il vaut mieux dans ce cas utiliser une zone de liste ou un combobox).
Comme pour les cases à cocher, c'est l'attribut Checked qui définit le fait qu'un bouton radio soit coché ou non.
Par contre, les boutons radio ne se comportent pas exactement comme des cases à cocher. En effet, des boutons radio directement déposés sur le formulaire s'excluent mutuellement: si l'on coche un des boutons radio, les autres sont automatiquement décochés.
Cette interdépendance des boutons radio est gênante lorsque l'on souhaite utiliser des boutons radio pour des choix independants. C'est ici qu'intervient le composant GroupBox. Pour rendre deux groupes de boutons radio indépendants, on peut déposer deux GroupBox sur le formulaire, puis mettre les boutons radio du premier groupe dans le premier GroupBox et ceux du second groupe dans le second.
Un petit conseil pour terminer: pour mettre des composants à l'intérieur d'un autre, il vaut mieux commencer par le plus gros (le conteneur donc) puis déposer les petits composants dedans. Si on procède dans le sens inverse, les petits composants seront cachés par le gros. Dans ce cas, il faut faire un clic droit sur le conteneur , puis sélectionnez Z-Order, puis déplacer en arrière.
L'exemple présenté ici se trouve dans le dossier Exemple-ProgObjet1/BoutonRadio (ouvrir StationEssence.lpi ). Voici la fenêtre de l'application à son démarrage:
Nous avons utilisé ici un GroupBox pour chaque pompe. Vous constaterez que les boutons radio d'une même pompe s'excluent mutuellement (un seul choix s'essence possible), mais que les boutons radio de la pompe 1 sont indépendants de ceux de la pompe 2. Ici, par exemple, on a choisit E10 à la pompe 1 et SP95 à la pompe 2:
Voici les procédures évènementielles des boutons radio de la pompe 1:
procedure TForm1.BR_SP95_P1Change(Sender: TObject); begin AfficherPrixPompe1 (); end; procedure TForm1.BR_E10_P1Change(Sender: TObject); begin AfficherPrixPompe1 (); end; procedure TForm1.BR_Gazole_P1Change(Sender: TObject); begin AfficherPrixPompe1 (); end;
Elles appellent toutes la procédure AfficherPrixPompe1 que voici:
procedure AfficherPrixPompe1 (); var Prix :double; begin if Form1.BR_SP95_P1.Checked Then Prix:=PRIX_SP95; if Form1.BR_E10_P1.Checked Then Prix:=PRIX_E10; if Form1.BR_Gazole_P1.Checked Then Prix:=PRIX_Gazole; Form1.ZT_Prix_P1.Text := FloatToStr (Prix); end;
Pour les boutons radio de la pompe 2, nous avons utilisé le même principe.
Les mémos sont en quelque sorte des zones de texte étendues sur plusieurs lignes. Le texte contenu dans un mémo est stocké dans son attribut Lines de type TStrings.
L'attribut WordWarp définit la manière de gèrer le passage à la ligne dans le mémo. Sa valeur par défaut est True, ce qui signifie qu'une ligne de texte sera automatiquement coupée et donc répartie sur plusieurs lignes, lorsque la largeur du mémo n'est pas suffisante pour l'afficher en entier. Dans ce cas chaque chaine de caractère contenue dans l'attribut Lines ne représente pas nécessairement une ligne de texte unique dans le mémo (tel qu'il est affiché).
Si WordWrap vaut False, une ligne trop longue pour être affichée en entier sera affichée en partie (ce qui dépasse n'est pas visible). Dans ce cas chaque chaine de caractères dans Lines correspond à une unique ligne affichée.
L'attribut Scrollbars définit les barres de défilement horizontales ou verticales. Il ne peut y avoir de barre de défilement horizontale que si Wordwrap vaut False, car dans le cas contraire elle n'est d'aucune utilité. Scrollbars a sept valeurs possibles qui sont des constantes prédéfinies de Lazarus:
L'exemple présenté ici se trouve dans le dossier Exemple-ProgObjet1/Memo (ouvrir le fichier EditeurDeTexte.lpi). Il s'agit d'un éditeur de texte très simplifié qui permet d'ouvrir un fichier, de le modifier et de l'enregistrer. Le fichier ouvert est affiché à l'intérieur d'un mémo. Voici par exemple l'affichage du fichier Dylan.txt (que vous trouverez dans le même répertoire que le projet):
Dans cet exemple, nous avons mis WordWrap à False et Scrollbar à ssAutoBoth. Comme le texte est trop large et trop long, deux barres de défilements ont été ajoutées et on voit que la première ligne est affichée en partie. Si vous n'avez pas très bien compris le rôle des attributs WordWrap et Scrollbar, amusez vous à modifier leurs valeurs pour en voir l'effet.
Comme l'attribut Lines d'un mémo est de type TStrings, le chargement d'un fichier dans un mémo se fait simplement en appliquant la méthode LoadFromFile à cet attribut. Nous utilisons ceci dans la procédure évènementielle associée au bouton Ouvrir (ZT_NomFichier est le nom de la zone de texte contenant le nom du fichier et MM_Editeur, le nom du mémo):
procedure TForm1.BT_OuvrirClick(Sender: TObject); var NomFichier : String; begin NomFichier := ZT_NomFichier.Text; MM_Editeur.Lines.LoadFromFile(NomFichier); end;
Pour enregistrer le fichier, même principe avec la méthode SaveToFile:
procedure TForm1.BT_EnregistrerClick(Sender: TObject); var NomFichier : String; begin NomFichier := ZT_NomFichier.Text; MM_Editeur.Lines.SaveToFile(NomFichier); end;
Les menus comme les boutons, servent à activer différents traitements d'un logiciel. Lorsque le nombre de traitements est important, l'utilisation d'un bouton pour chaque traitement prend trop de place. Dans ce cas, il est préférable d'utiliser des menus. Ce sont en quelque sorte des boutons organisés en listes déroulantes qui ne se deploient que lorsque l'on clique dessus.
Nous reprenons ici l'exemple précédent de l'éditeur de texte en y intégrant une barre de menu. Ce projet se trouve dans Exemple-ProgObjet1/Menu (fichier EditeurDeTexte.lpi ).
Voici la nouvelle interface graphique du programme telle qu'elle apparait à son démarrage:
La fenêtre comprend à présent une barre de menus contenant deux menus intitulés Fichier et Affichage. Le menu Fichier permet d'ouvrir un fichier, de l'enregistrer ou de quitter l'application:
Remarquez qu'à chaque entrée du menu est associée un racourci clavier. Nous verrons un peu plus loin comment les définir.
Le menu Affichage offre deux possilités intitulées WordWrap et FullWindow que nous détaillerons un peu plus loin:
Ce menu est un peu différent du précedent car chacune de ses entrées peut être cochée ou décochée.
Pour commencer voyons comment construire ce menu avec Lazarus.
Vous pouvez si vous le désirez effectuer les manipulations suivantes à partir de la version précédente de l'éditeur de texte (dans Exemple-ProgObjet1/Memo).
Commencez par déposer un menu principal (objet MainMenu1 de la classe TMainMenu) sur le formulaire. Cet objet représente la barre de menus.
Pour modifier le contenu de la barre des menus, il faut utiliser l'éditeur de menu que l'on ouvre par un double clic sur le composant MainMenu1 déposé sur le formulaire :
Pour l'instant, le menu principal ne contient qu'une seule entrée nommée New Item1. Pour en ajouter une deuxième, on fait un clic droit sur le New Item1 affiché dans l'éditeur de menu et on sélectionne Insérer un nouvel élément après.
Notre barre de menu contient à présent deux entrées (donc deux menus). Pour faire apparaitre les libellés Fichier et Affichage à la place de New Item1 et New Item2, utilisez l'inspecteur d'objet et modifiez les propriétés caption de ces deux composants (attention: cela n'est possible que si l'éditeur de menu est ouvert !).
Vous pouvez ensuite ajouter une première entrée au menu Fichier par un clic droit sur Fichier (dans l'éditeur de menu) et en sélectionant Créer un sous menu. On obtient ainsi une première entrée dans le menu Fichier. Elle est libellée New Item3 :
Pour ajouter une deuxième entrée après New Item3, faites un clic droit sur New Item3, puis sélectionnez Insérer un nouvel élément après:
A ce stade vous avez certainement compris le principe de construction d'un menu sous Lazarus. Nous allons donc arrêter ici les explications concernant l'utilisation de l'éditeur de menu.
Encore deux petits détails avant de passer à l'aspect programmation:
Pour accéder au gestionnaire du clic sur une entrée de menu (ou le générer s'il n'existe pas encore) il suffit de cliquer une fois dessus.
En cliquant par exemple sur l'entrée Ouvrir du menu fichier, vous êtes automatiquement redirigé sur la procédure évènementielle suivante:
procedure TForm1.MN_OuvrirClick(Sender: TObject); var NomFichier : String; begin NomFichier := ZT_NomFichier.Text; MM_Editeur.Lines.LoadFromFile(NomFichier); end;
Nous avons simplement réutilisé ici le code qui se trouvait précédemment dans la procédure évènementielle associée au bouton Ouvrir.
Notez que si un raccourci clavier a été défini, l'exécution de la procédure évènementielle sera également déclenchée lorsque l'utilisateur tape ce raccourci. Dans notre exemple, la procédure évènementielle associée à l'entrée Ouvrir sera donc également déclenchée si l'utilisateur tape CTRL O.
Même principe pour l'entrée Enregistrer :
procedure TForm1.MN_EnregistrerClick(Sender: TObject); var NomFichier : String; begin NomFichier := ZT_NomFichier.Text; MM_Editeur.Lines.SaveToFile(NomFichier); end;
Enfin, pour déclencher la fermeture de l'application (entrée Quitter), nous appliquons simplement la méthode Close à Form1:
procedure TForm1.MN_QuitterClick(Sender: TObject); begin Form1.Close(); end;
Les gestionnaires du menu Affichage provoquent une action différente selon que l'entrée du menu correspondante est cochée ou non.
L'entrée WordWrap active ou désactive le mode WordWrap du mémo:
procedure TForm1.MN_WordWrapClick(Sender: TObject); begin MM_Editeur.WordWrap:= Not MM_Editeur.WordWrap; end;
Il est inutile de cocher ou décocher l'entrée dans le code, car nous avons mis AutoCheck à True et dans ce cas, cela se fait automatiquement.
Lorsque l'entrée FullWindow est cochée, le mémo occupe la quasi-totalité de la fenêtre et la zone de texte permettant de saisir le nom du fichier disparait:
Si on la décoche, le mémo revient à sa taille originale et la zone de texte réappararait. Nous avons réalisé ceci de la manière suivante:
procedure TForm1.MN_FullWindowClick(Sender: TObject);
begin
if MN_FullWindow.Checked then
begin
MM_Editeur.Width := Form1.Width - 50;
MM_Editeur.Height := Form1.Height - 50;
Label1.Hide();
ZT_NomFichier.Hide();
end
else
begin
MM_Editeur.Width := LargeurMemo;
MM_Editeur.Height := HauteurMemo;
Label1.Show();
ZT_NomFichier.Show();
end;
end;
Ici, nous avons besoin de savoir si l'entrée du menu est cochée ou non, car il ne suffit pas comme dans l'entrée WordWrap, d'inverser la valeur d'un booléen.
Si l'entrée FullWindow est cochée (MN_FullWindow.Checked), les dimensions du mémo (propriétés Width et Height) sont redéfinies comme celles du formulaire moins 50 pixels. Puis on fait disparaitre l'étiquette et la zone de texte en leur appliquant la méthode Hide.
Si l'entrée FullWindow n'est pas cochée, les dimensions du mémo sont restaurées et l'on fait réapparaitre la zone de texte et l'étiquette on leur appliquant la méthode Show.
Remarquez que pour pouvoir retrouver les dimensions d'origines du mémo, nous les avons sauvegardées dans les variables LargeurMemo et HauteurMemo au démarrage de l'application:
procedure TForm1.FormCreate(Sender: TObject); begin LargeurMemo := MM_Editeur.Width; HauteurMemo := MM_Editeur.Height; end;
Remarque: lorsque l'on affecte une nouvelle valeur à l'attribut width (largeur) ou height (hauteur) d'un composant, ce composant est immédiatement réaffiché avec les nouvelles dimensions. Comment, une simple affectation peut elle provoquer ce résultat ? Nous avons déjà rencontré ce phénomène dans la modification de la propriété text d'une zone de texte, qui provoque immédiatement l'affichage de sa nouvelle valeur. Nous reviendrons là dessus dans le deuxième cours sur la programmation objet.