Guide Pascal et Delphi

Créez un projet vierge sous Delphi, puis créez une deuxième fiche au moyen de la commande "Nouveau..." du menu "Fichier" (choisissez "Fiche" parmi la liste des éléments proposés). Votre projet contient maintenant deux fiches, l'une nommée "Form1" associée à une unité "Unit1", et l'autre nommée "Form2" associée à une unité "Unit2". L'exercice consiste à montrer la fiche "Form2" en cliquant sur un bouton de la fiche "Form1", et à pouvoir refermer la fiche "Form2" en cliquant sur un bouton de celle-ci.

1. Commencez par enregistrer le projet : "Modales". L'unité "Unit1" doit être nommée "Principale" et "Unit2" nommée "TestModale". La fiche "Form1" doit être nommée "fmPrinc" et "Form2" nommée "fmTestModale".

2. Placez un bouton nommé "btMontreModale" sur la fiche "fmPrinc" (placez le bouton puis renommez-le). Placez un bouton "btFermeFiche" sur la fiche "fmTestModale". Donnez à tout cela une apparence correcte en vous inspirant de la capture d'écran ci-dessous :

   

3. Il faut maintenant écrire le code qui va faire vivre notre exemple. Il est des plus simple : le bouton de la fiche "fmPrinc" appelera la méthode ShowModal de fmTestModale, tandis que le bouton "btFermeFiche" de fmTestModale se contentera d'assigner une valeur non nulle a la propriété ModalResult de la fiche.
   Avant de faire cela, il va falloir accèder à l'unité "TestModale" depuis l'unité "Principale". Ajoutez donc l'unité "TestModale" au bloc "uses" de l'interface de l'unité "Principale" (nous aurions aussi pû utiliser celui de l'implémentation, savez-vous pourquoi ?).

4. Générez la procédure de réponse à l'événement "OnClick" de "fmPrinc.btMontreModale" (on se permettra désormais cette notation pratique empruntée au langage Pascal Objet). Il nous faut ici appeler la méthode ShowModal de la fiche "fmTestModale". Cette dernière est accessible puisque la variable qui la stocke est dans une unité présente dans le bloc "uses" convenable. On doit pour accèder à la méthode "ShowModal" de "fmTestModale" écrire le nom de la fiche, un point, puis la méthode à appeler, soit la très simple instruction présentée ci-dessous :

    

   Sélectionnez

   procedure TfmPrinc.btMontreModaleClick(Sender: TObject);
   begin
     fmTestModale.ShowModal;
   end;

5. Générez la procédure de réponse à l'événement OnClick du bouton "btFermeFiche". Nous devons ici modifier la propriété "ModalResult" de la fiche "fmTestModale" à laquelle appartient le bouton "btFermeFiche". On peut donc directement s'adresser à la propriété, puisque le bouton et la propriété sont tous deux des éléments de la fiche. Voici le code source, dans lequel nous affectons la valeur mrOK à ModalResult :

    

   Sélectionnez

   procedure TfmTestModale.btFermeFicheClick(Sender: TObject);
   begin
     ModalResult := mrOK;
   end;

6. Lancez alors l'application. Lorsque vous cliquez sur le bouton de la fiche principale, vous faites apparaître la deuxième fiche, qui ne permet pas de revenir à la première tant qu'elle n'est pas fermée. Pour la fermer, un moyen est de cliquer sur le bouton créé à cet effet.

Cet exemple très simple démontre non seulement l'utilisation de plusieurs fiches, mais aussi l'utilisation de fenêtres modales. Vous pouvez modifier cet exemple en remplaçant "ShowModal" par "Show". Dans ce cas, il faudra remplacer l'affectation à ModalResult par un appel à la méthode "Close". Je vous laisse réaliser cette modification simple et l'expérimenter vous-même.

Il est une amélioration que nous allons cependant faire ici. J'ai mentionné auparavant que ShowModal renvoyait la valeur de ModalResult en tant que résultat. En effet, ShowModal est une fonction qui affiche la fiche. Cette fonction se termine lorsque ModalResult devient non nul. Cette valeur est alors renvoyée comme résultat de la fonction. Nous allons tout simplement mémoriser le résultat de l'appel à ShowModal, puis afficher sa valeur. Voici le nouveau code à utiliser dans la procédure de réponse au clic sur le bouton "btMontreModale" :

procedure TfmPrinc.btMontreModaleClick(Sender: TObject);
var
  Rep: TModalResult;
begin
  Rep := fmTestModale.ShowModal;
  ShowMessage(IntToStr(Ord(Rep)));
end;

La première instruction appelle toujours la méthode ShowModal de fmTestModale, mais mémorise en plus le résultat dans une variable Rep de type TModalResult (c'est le type énuméré qui énumère les constantes mrNone, mrOK, ...). La deuxième instruction prend la valeur ordinale de Rep, puis la transforme en chaîne de caractères, et ensuite l'affiche avec ShowMessage. Le résultat du clic sur le bouton lors de l'exécution de l'application est d'afficher d'abord la fiche fmTestModale, puis immédiatement après sa fermeture une boite de message avec marqué "1". 1 est en effet la valeur ordinale de la constante mrOK. Vous pouvez essayer de changer mrOK par d'autres constantes pour voir leur valeur ordinale.

Note : Les habitués de Delphi qui liront ceci sauteront une nouvelle fois au plafond en se demandant : "mais pourquoi diable utilise-t-il la fonction "Ord" ?". La réponse, pour tous, est que dans l'état actuel, transmettre une valeur de type TModalResult à une fonction qui veut une valeur de type Integer est interdit. Pour les non-initiés, sachez que cela est en fait permis, sous certaines conditions. Ceci n'étant pas à l'ordre du jour, nous en reparlerons plus tard.

Avant de passer à autre chose, voici pour ceux qui le souhaitent la possibilité de télécharger le projet fini.

Fiche technique :

Icône
Visibilité	Invisible à la création, visible ensuite.
Conteneur	Non

Ce composant permet de munir la fiche d'une barre de menus déroulants comme vous en utilisez très souvent. Ce composant est non visuel lorsqu'on vient de le poser sur une fiche : au lieu d'un composant visible, l'icône du composant vient se placer sur la fiche. A partir de son pseudo-bouton, vous pouvez accèder via un double-clic à une interface spécifique de création de menus. Cette interface permet de créer directement de façon visuelle les menus en utilisant l'inspecteur d'objets et quelques raccourcis clavier. Cette interface permet en fait d'éditer la propriété "Items" du composant (en sélectionnant la propriété, puis en cliquant sur le bouton qui permet d'éditer des propriétés complexes, vous accèdez à la même chose). Voici une capture d'écran de cet éditeur :

Le fonctionnement de cet éditeur et la création de menus forment un sujet très vaste et passionnant qui est traité de façon très détaillée en Annexe A. Je vous conseille avant de vous lancer dans le sujet de lire ce paragraphe et celui consacré au composant "ImageList".

Les propriétés importantes du composant "MainMenu" sont décrites ci-dessous :

Propriétés :

Fiche technique :

Icône
Visibilité	Invisible à la création, peut être visible à l'éxécution
Conteneur	Non

Ce composant permet de créer un menu contextuel. Les menus contextuels, je le rappelle, sont ceux qui apparaissent lorsqu'on clique avec le bouton droit de la souris. Ce genre de menu doit son nom au fait qu'il semble adapté à la zone sur laquelle on clique. En fait, il faut souvent dans la pratique créer plusieurs menus contextuels et les adapter éventuellement (en activant ou désactivant, ou en cachant ou en montrant certains choix) pendant l'exécution de l'application. La création de ce menu se fait dans le même genre d'interface que les menus principaux ("MainMenu"), vous pouvez d'ailleurs consulter l'Annexe A qui comprend une section décrivant l'usage des menus contextuels.

Propriétés :

Evénements :

Méthodes :

Pour utiliser un menu contextuel, il faut (tout est décrit en détail dans l'Annexe A) l'associer à chaque composant qui doit le faire apparaître. Ceci est fait en sélectionnant le menu dans la propriété "PopupMenu" (propriété de type référence) des composants (une très grande majorité le propose).

Fiche technique :

Icône
Visibilité	Visible
Conteneur	Non

Un composant "Label" permet d'inclure facilement du texte sur une fiche. Ce texte n'est pas éditable par l'utilisateur et c'est donc un composant que l'on utilise souvent comme étiquette pour d'autres contrôles. Bien que l'on puisse modifier la police utilisée pour l'écriture du texte, il faut toujours freiner ses ardeurs. Ces composants sont en général en grand nombre sur les fiches importantes, mais cela ne pose pas de problème car ils ne prennent presque pas de mémoire.

Note : (aux programmeurs avertis) :

Les composants "Label" ne sont pas des vrais objets au sens de Windows : ils ne possèdent pas de Handle. Ces composants sont en effet directement dessinés sur le canevas de la fiche. Pour utiliser un Label avec un Handle (utile avec ActiveX), il faut utiliser le composant "StaticText".

Un composant "Label" peut contenir jusqu'à 255 caractères, ce qui le limite à des textes très courts. Les propriétés "AutoSize" et "WordWrap" permettent d'obtenir une bande de texte à largeur fixe sur plusieurs lignes, ce qui sert souvent pour donner des descriptions plus étoffées que de simples étiquettes. Les composants "Label" sont très souvent utilisés et le seront donc dans les manipulations futures.

Propriétés :

Fiche technique :

Icône
Visibilité	Visible
Conteneur	Non

Les composants "Edit" permettent de proposer des zones d'édition. Ces zones très souvent utilisées sous Windows ne contiennent qu'une ligne de texte, dont la police peut être règlée, toujours avec la même parcimonie. Ce composant permet à l'utilisateur d'entrer une information quelconque tapée au clavier. Le texte entré dans le composant est accessible via une propriété "Text". Il est possible de fixer une limite à la longueur du texte entré, de masquer les caractères (utile pour les mots de passe), de désactiver la zone ou d'interdire toute modification du texte.

Propriétés :

Evénements :

Une manipulation fera intervenir ce composant à la fin du § X-B-7 Composant "CheckBox".

Fiche technique :

Icône
Visibilité	Visible
Conteneur	Non

Le composant "Memo" permet l'édition de texte sur plusieurs lignes. Une utilisation célèbre de ce composant est faite par le bloc-notes de Windows. Ce composant ne traite pas la mise en forme des caractères comme dans WordPad (pour cela, un autre composant, "RichEdit", est tout indiqué). Le composant "Memo", placé sur une fiche, permet donc lors de l'exécution, d'écrire du texte, d'ajouter des lignes en appuyant sur Entrée, d'éditer facilement ce texte (les fonctionnalités de copier-coller ne sont cependant pas automatiques et vous devrez apprendre à les programmer, j'essaierai de traiter un exemple d'utilisation du presse-papier dans un futur chapitre, il est encore un peu tôt pour cela).

Concrètement, un mémo stocke le texte sous formes de lignes : chaque ligne est une chaîne de caractères. La propriété objet "Lines" des composants "Memo" permet l'accès aux lignes du mémo et leur manipulation. L'interface de Delphi permet même d'écrire directement dans le mémo en éditant la propriété "Lines".

Propriétés :

Evénements :

Une manipulation fera intervenir ce composant à la fin du § X-B-7 Composant "CheckBox".

Fiche technique :

Icône
Visibilité	Visible
Conteneur	Non

Pas vraiment besoin de présenter longuement ici le composant Button : vous vous en servez depuis un bon moment si vous suivez ce guide depuis le début. Ce composant sert en général à proposer à l'utilisateur une action. Cette action lui est expliquée par un texte très court sur le bouton, du style "OK" ou "Annuler". Lorsque l'utilisateur clique sur le bouton, ou appuie sur Espace ou Entree lorsque celui-ci est sélectionné (ce qui revient à le cliquer), l'événement OnClick se produit, qui offre une possibilité de réaction. C'est en général dans la procédure de réponse à cet événement qu'on effectue l'action proposée à l'utilisateur, comme afficher ou fermer une fiche par exemple pour citer des exemples récents.

Les boutons ont une fonctionnalité en rapport avec les fenêtres modales : ils ont une propriété ModalResult. Cette propriété ne fonctionne pas du tout comme celle des fiches. Elle est constante (fixée par vous), et est recopiée dans la propriété ModalResult de la fiche lors d'un clic sur le bouton. Ceci a comme effet de pouvoir créer un bouton "OK" rapidement en lui donnant "mrOK" comme ModalResult. Lors d'un clic sur ce bouton, la propriété ModalResult de la fiche devient mrOK et la fiche se ferme donc, sans aucune ligne de code source écrite par nous. Nous utiliserons cette possibilité dans de futurs exemples.

Propriétés :

Evénements :

Méthodes :

Une manipulation fera intervenir ce composant à la fin du § X-B-7 Composant "CheckBox".

Fiche technique :

Icône
Visibilité	Visible
Conteneur	Non

Un composant CheckBox permet de donner à l'utilisateur un choix de type "Oui/Non". S'il coche la case, la réponse est "Oui", sinon, c'est "Non". Au niveau du code, une propriété de type booléen stocke cette réponse : Checked. Il est possible de donner un texte explicatif de la case à cocher dans la propriété Caption. Ce texte apparait à coté de la case. Une modification de l'état de la case déclenche un événement OnClick, que cette modification provienne effectivement d'un clic ou d'une pression sur la touche Espace. La modification depuis le code source de la propriété Checked ne déclenche pas cet événement.

Propriétés :

Evénements :

X-B-7-a. Manipulation guidée▲

L'objectif de cette manipulation est de vous faire manipuler les composants Edit, Memo, Button et CheckBox. Placez un composant de chaque sorte sur la seule fiche d'un projet vierge, et obtenez l'interface ci-dessous en modifiant les propriétés nécessaires décrites dans les paragraphes précédents (pour effacer le texte présent dans le mémo, éditez la propriété Lines et effacez le texte présent dans l'éditeur). Les noms des composants ont été rajoutés en rouge (ces annotations ne doivent pas apparaître dans votre interface !) :

Le but de cette petite application est assez simple : le contenu de la zone d'édition est ajouté au mémo lorsqu'on clique sur le bouton "Ajout". Cet ajout se fait sur une nouvelle ligne quand l'option correspondante est cochée, et sur la dernière ligne sinon. Si le mémo ne contient pas encore de texte, une première ligne est créée. Cet exemple va nous permettre d'utiliser de nombreuses propriétés abordées dans les paragraphes ci-dessus.

L'interface de l'application est déjà faite, il ne nous reste plus qu'à écrire un peu de code. Le seul "moment" où il se passe quelque chose dans notre application est lorsqu'on clique sur le bouton : c'est à ce moment que l'ajout a lieu. Générez donc la procédure de réponse à l'événement OnClick de ce bouton.

Il y a différents cas à traiter. Un premier cas simple est lorsqu'une nouvelle ligne est à ajouter. L'autre cas, qui consiste à ajouter à la fin de la dernière ligne, dépend de l'existence de cette dernière ligne. Il faudra donc encore distinguer deux cas, ce qui en fait en tout trois. Pour distinguer ces cas, un bloc "if" est tout indiqué (c'est même notre seul choix possible !). Le cas où l'on ajoute une ligne est réalisé lorsque la case est cochée, c'est-à-dire lorsque la propriété Checked de cbNouvLigne est vraie. Voici alors le début du bloc "if" :

 

Sélectionnez

if cbNouvLigne.Checked then
  ...

Le deuxième cas (pas de dernière ligne, il faut donc en créer une) est réalisé lorsque le nombre de lignes du mémo vaut 0. Le nombre de lignes du mémo est indiqué par la propriété Count de la propriété objet Lines de meAjout. Voici la suite de notre boucle "if" :

 

Sélectionnez

if cbNouvLigne.Checked then
  ...
else if meAjout.Lines.Count = 0 then
  ...

Notez bien qu'on a imbriqué un second bloc "if" dans le premier pour traiter 3 cas et non pas seulement 2. La dernière condition est simplement réalisée quand aucune des deux autres ne l'est, c'est donc un simple else. Voici le squelette complet de notre structure "if" :

 

Sélectionnez

if cbNouvLigne.Checked then
  ...
else if meAjout.Lines.Count = 0 then
  ...
else
  ...

Etudions maintenant le premier cas. Ce cas ajoute simplement le texte de la zone d'édition dans une nouvelle ligne. Le texte de la zone d'édition est la propriété Text de edTxtAjout. Pour ajouter une ligne à meAjout, il faut appeler la méthode Add de sa propriété objet Lines. On doit transmettre une chaîne à ajouter. La chaîne transmise sera tout simplement le texte de la zone d'édition, de sorte que l'instruction sera :

 

Sélectionnez

meAjout.Lines.Add(edTxtAjout.Text)

L'action à effectuer dans le second cas est en fait identique à celle à effectuer dans le premier cas (ajouter le texte de la zone d'édition dans une nouvelle ligne). Plutôt que de réécrire l'instruction, regroupons plutôt les deux premiers cas du bloc "if". On peut faire cela avec un OU logique : l'instruction sera exécutée lorsque l'une des deux conditions sera réalisée. Voici ce que cela donne actuellement :

 

Sélectionnez

if cbNouvLigne.Checked or (meAjout.Lines.Count = 0) then
  meAjout.Lines.Add(edTxtAjout.Text)
else
  ...

Vous voyez qu'on a mis une des conditions entre parenthèses. la raison en est que sans les parenthèses, la ligne aurait été mal interprétée : le or aurait été considéré entre cbNouvLigne.Checked et meAjout.Lines.Count, ce qui est interdit. Les parenthèses permettent d'isoler des morceaux qui doivent être évaluées avant d'être intégrés au reste du calcul.

Le traitement du dernier cas est plus délicat. On doit récupérer la dernière ligne (on sait qu'elle existe dans ce cas), ajouter le texte de edTxtAjout, puis réaffecter le tout à la dernière ligne, ou alors tout faire en une seule opération. Je vous propose de voir d'abord la méthode facile et ensuite la moins facile.

Pour obtenir une ligne, on utilise une propriété tableau par défaut de la propriété objet Lines de meAjout. Vous n'avez pas besoin de connaître le nom de cette propriété, puisqu'il suffit de faire suivre "Lines" de crochets sans le mentionner. Le numéro de la ligne s'obtient par le nombre de lignes. La dernière ligne est le nombre de ligne diminué de 1. La dernière ligne du mémo est donc :

 

Sélectionnez

meAjout.Lines[meAjout.Lines.Count - 1]

La première étape est de concaténer le texte de edTxtAjout à cette ligne, et de stocker le tout dans une variable temporaire "temp" de type string. La seconde étape consiste à affecter cette chaîne temporaire à la dernière ligne. Voici donc les deux instructions :

 

Sélectionnez

temp := meAjout.Lines[meAjout.Lines.Count - 1] + edTxtAjout.Text;
meAjout.Lines[meAjout.Lines.Count - 1] := temp;

Ceci constitue la solution la plus simple, qui exige une variable temporaire. Nous la garderons car elle est plus claire comme cela, mais comme je vous l'ai déjà fait remarquer, l'emploi d'une variable ne se justifie pas lorsqu'elle n'est utilisée qu'une fois en tant que valeur de paramètre. Voici donc la version "moins facile", sans variable temporaire, et tenant en une seule instruction :

 

Sélectionnez

meAjout.Lines[meAjout.Lines.Count - 1] := { suite en dessous }
   meAjout.Lines[meAjout.Lines.Count - 1] + edTxtAjout.Text;

Ci-dessus, la chaîne affectée à temp est directement affectée à la dernière ligne. Voici donc le texte complet de la procédure que nous avions à écrire :

 

Sélectionnez

procedure TfmPrinc.btAjoutClick(Sender: TObject);
var
  temp: string;
begin
  if cbNouvLigne.Checked or (meAjout.Lines.Count = 0) then
    meAjout.Lines.Add(edTxtAjout.Text)
  else
    begin
      temp := meAjout.Lines[meAjout.Lines.Count - 1] + edTxtAjout.Text;
      meAjout.Lines[meAjout.Lines.Count - 1] := temp;
    end;
end;

Je vous encourage enfin à tester votre application. Il va sans dire que vous pouvez entrer ou effacer du texte à votre guise dans le mémo. Je ne propose pas le téléchargement de ce projet assez simple. Si vous veulez malgré tout le code source, contactez-moi.

Fiche technique :

Icône
Visibilité	Visible
Conteneur	Non

Le composant "RadioButton" permet de proposer un choix à l'utilisateur parmi plusieurs possibilités. Chaque possibilité est constituée d'un composant "RadioButton". A l'intérieur d'un composant conteneur ou d'une fiche, l'utilisateur ne peut cocher qu'un seul composant "RadioButton", quel que soit le nombre proposé. Pour créer des groupes de composants séparés, il faut les regrouper dans des contrôles conteneurs comme les "Panel" ou les "GroupBox". Pour savoir quel RadioButton est coché, il faut passer en revue leur propriété Checked.

En ce qui concerne les propriétés et événemnts, un "RadioButton" est assez proche d'un "CheckBox". Voici, comme d'habitude, un résumé des éléments à connaître.

Propriétés :

Evénements :

Nous aurons l'occasion d'utiliser ce composant dans de futurs exemples.

Fiche technique :

Icône
Visibilité	Visible
Conteneur	Non

Ce composant, que vous connaissez pour l'avoir essayé au cours d'un exemple dans ce guide, permet d'afficher une liste d'éléments, parmi lesquels l'utilisateur peut choisir un ou plusieurs éléments (plusieurs choix sont possibles à ce niveau). Chaque élément est présent sur une ligne, un peu à la façon d'un mémo, mais il n'est pas question ici d'éditer les éléments, juste d'en sélectionner. Le composant ListBox n'est pas limité à proposer des éléments à l'utilisateur : il peut aussi servir à afficher une liste des résultats d'une recherche par exemple.

Au niveau du fonctionnement, la propriété objet Items permet la gestion des éléments. Cette propriété dispose d'une propriété tableau par défaut pour accèder aux éléments. Ces éléments sont de type chaîne de caractère. Items dispose en outre d'une méthode "Clear" pour vider la liste, d'une méthode "Add" pour ajouter un élément, et d'une propriété "Count" pour indiquer le nombre d'élément. Les éléments sont numérotés de 0 à Count - 1. Outre la propriété Items, le composant ListBox dispose d'un certain nombre de propriétés permettant de configurer le composant.

Propriétés :

Evénements :

Fiche technique :

Icône
Visibilité	Visible
Conteneur	Non

Le composant "ComboBox" (zone de liste déroulante) permet également la gestion de liste d'éléments, mais à d'autres fins et avec d'autres possibilités. En premier lieu, un composant "ComboBox" ne permet la sélection que d'un élément au plus. Le composant affiche une zone montrant selon les cas l'élément sélectionné ou une zone d'édition (analogue à un "Edit"). Il est possible d'afficher une liste des éléments de la liste en cliquant sur un bouton prévu à cet effet. Il est alors possible de sélectionner un élément dans la liste.

Au niveau du code, ue composant ComboBox fonctionne comme un composant ListBox pour ce qui est de la propriété Items. Un composant ComboBox pouvant contenir une zone d'édition, il dispose de certaines éléments de ces dernières, comme les propriétés Length et Text, et l'événement OnChange. La propriété Style permet de choisir parmi 5 styles différents dont 3 seront décrits ici, les 2 autres autorisant la création d'éléments personnalisés visuellement, ce qui déborde largement du cadre de ce chapitre.

Propriétés :

Evénements :

Fiche technique :

Icône
Visibilité	Visible
Conteneur	Oui

Les composant "GroupBox" ont pour but d'effectuer des regroupements visibles de composants. En effet, ils se présentent sous la forme d'un cadre 3D et d'un texte en haut à gauche. Un composant GroupBox est un conteneur, donc susceptible de contenir d'autres composants (conteneurs ou pas, soit dit en passant). Lorsque l'on veut proposer à l'utilisateur le choix parmi plusieurs options, un composant GroupBox contenant des composants RadioButton est un bon choix. Vous trouverez facilement des exemples en vous promenant dans l'interface de vos logiciels favoris. Si vous comptez vous limiter à des RadioButton placés sur un GroupBox, intéressez-vous au composant RadioGroup non décrit ici mais qui permet de créer rapidement ce genre d'interface.

Au niveau du code, un composant GroupBox n'a pas souvent de rôle particulier à jouer, étant donné que c'est surtout son caractère conteneur qui importe. Aucune propriété, méthode ou événement n'est à signaler ici, cependant, il ne faut pas sous-estimer ce composant qui tient un grand rôle dans l'organisation tant visuelle que logique des interfaces les plus fournies.

Fiche technique :

Icône
Visibilité	Visible
Conteneur	Oui

Les composants "Panel", ou panneaux, sont fréquement employés sous Delphi. Ils ont deux rôles connus, que l'on peut parfois combiner. L'intérêt de ces panneaux, c'est que ce sont des conteneurs, qu'ils possèdent une bordure 3D configurable à volonté, et qu'ils sont alignables. Cette dernière caractéristique, si elle n'évoque probablement pas grand chose pour vous, sera bientôt une aide précieuse dans la conception de vos interfaces. Les panneaux sont donc utilisés soit pour leurs bordures 3D, soit pour créer des alignements.

Au niveau du code, les panneaux sont assez peu manipulés, sauf lorsqu'on a besoin de règler leurs dimensions pour maintenir l'interface d'une application. A la conception, par contre, il est possible de manipuler quelques propriétés agissant sur l'alignement et l'apparence des panneaux.

Propriétés :

Les possibilités d'alignement des panneaux (propriété Align) seront utilisées dans de futurs exemples.

Fiche technique :

Icône
Visibilité	Visible
Conteneur	Non

Le composant Bevel a un but simple : il est décoratif. En effet, ce composant ne sert qu'à créer des effets visuels à l'aide de ses quelques propriétés permettant de créer des bordures 3D. Vous pouvez ainsi créer un cadre, ou seulement l'un des cotés du cadre, et changer l'effet graphique du composant. Ce composant, moins performnt que Panel dans le sens ou il n'est pas un conteneur et offre un peu moins de possibilités de bordures, permet cependant de se passer d'un Panel de temps en temps.

Fiche technique :

Icône
Visibilité	Invisible
Conteneur	Non

Le composant "ImageList" est non visuel. Il permet de stocker une liste d'images de mêmes dimensions. Le composant "ImageList" est ensuite utilisable par d'autres composants pour leur permettre d'accèder directement à la liste d'images. Le principe est d'assigner le composant à une propriété de type référence ImageList. Le composant qui utilise un "ImageList" permet ensuite d'accèder aux images en utilisant directement leur index. Les images sont indexées de 0 à Count - 1 où Count est une propriété du composant ImageList.

Pour créer cette liste d'images, placez un composant ImageList sur une fiche, puis double-cliquez dessus (il n'y a pas de propriété à éditer). vous vous retrouvez dans un éditeur spécialisé qui vous permet d'ajouter des images. Veillez, lorsque vous ajoutez une image (format bmp ou ico), à ce qu'elle soit de la bonne dimension. Fixez également une couleur transparente si une partie de l'image doit être transparente (utile pour créer des barres d'outils).

L'utilisation des composants ImageList est démontrée dans l'Annexe 8-A : Création de menus.

Ceci termine ce chapitre qui n'est qu'une première partie. La deuxième partie, présentée plus tard, sera consacrée à l'étude de composants plus délicats ou complexes à manipuler. Ces composants demandent pour être utilisés des connaissances que vous ne possèdez pas encore.