Initiation à Delphi 7

Initiation à Delphi 7 cours approfondi pour débutant

...

4 PROGRAMMATION ORIENTEE OBJET

4.1 PRESENTATION

Sans le savoir, vous utilisez des objets dans votre ordinateur. Par exemple, vous désirez changer la carte graphique. C'est un objet: vous ne connaissez pas exactement son fonctionnement interne mais vous désirez des résultats. Vous pouvez interchanger facilement cet objet puisque l'interface est standard (connecteurs). Vous n'avez donc pas besoin de changer toute l'unité centrale ou de faire des études poussées en électronique pour ce faire. Il suffit d'échanger la carte par une autre plus performante.

L'avantage de cette notion d'objet est la possibilité de partager les composants avec d'autres utilisateurs. Vous pouvez donner votre ancienne carte vidéo à l'un de vos collaborateurs. D'autre part, il n'est pas nécessaire de connaître le détail du fonctionnement de l'objet pour l'utiliser. La maintenance est facilitée, il suffit d'échanger l'objet sans toucher au reste de l'application.

4.2 CONCEPTS DE BASE

4.2.1 Propriétés

Ce sont les composants de l'objet. Sa taille, sa couleur, son nom, ... sont des propriétés. Les propriétés sont initialisées à la création de l'objet et certaines peuvent être modifiées par programmation. Delphi possède un éditeur de propriétés qui permet de les modifier en phase de conception de projet.

4.2.2 Méthodes

Les méthodes relèvent du comportement de l'objet: elles recensent ce que l'objet "sait" faire. S'il sait par exemple faire une multiplication, le nom du module de programme concerné est appelé méthode.

4.2.2.1 Fonctions

Les fonctions sont des modules (ou sous-programmes) qui retournent une seule valeur ou résultat après acceptation d'un certain nombre d'arguments (0 à n).

4.2.2.2 Procédures simples

Les procédures sont des modules qui effectuent des actions. Elles acceptent également des arguments. Elles peuvent retourner des arguments modifiés (s'ils sont déclarés en donnée-résultat).

4.2.2.3 Procédures événementielles

Elles conditionnent les réactions de l'objet vis-à-vis des actions extérieures (clavier, souris, ...). Ce sont des procédures appelées par un déclencheur. Windows recense un grand nombre d'événements dont la nature est précisée par un système de messages internes. Par exemple, le fait d'appuyer sur une touche du clavier ou de déplacer la souris provoque l'émission d'un message interne à Windows qui pourra être traité par la procédure événementielle.

4.2.3 Programmation structurée

Contrairement au premiers langages (basic) qui utilisaient des étiquettes avec des instructions de saut de type "goto" où l'on risquait un enchevêtrement dans le déroulement du programme, la POO demande une programmation modulaire et le langage Pascal est particulièrement adapté. L'écriture d'un programme se fait sous forme de blocs hiérarchisés, ce qui permet une meilleure compréhension. L'indentation des modules donne une lecture proche du développement algorithmique.

4.2.4 L'encapsulation

C'est le concept de base de la POO. L'idée est de rassembler les données et les modules de programme dans une seule et même structure appelée objet. Les données sont appelées "propriétés" et les modules sont les "méthodes". On peut utiliser des méthodes de l'objet sans connaître le détail de l'implémentation de chacune d'elle. L'encapsulation protège les données contre leur utilisation par d'autres modules extérieurs.

4.2.5 L'héritage

Les objets sont capables d'être dérivés à partir d'objets préexistants. Les objets "fils" héritent les propriétés et méthodes de leur parent de façon automatique. Il suffit alors de rajouter des propriétés et méthodes spécifiques: ce procédé est appelé programmation par exception. De plus, tous les changements effectués dans l'objet "parent" sont répercutés automatiquement sur les objets "descendants" sans manipulation supplémentaire.

4.2.6 Le polymorphisme

Le nom d'une méthode existante peut être réutilisé dans un objet "fils" en déclarant une implémentation différente. Le polymorphisme est la capacité de désigner des méthodes différentes (bien que portant le même nom) en fonction de l'objet concerné. Par exemple le signe "+" peut servir à l'addition, à la concaténation ou à l'incrémentation d'une date.

Dans le cas de redéfinition(OVERRIDE) d'une méthode, il est possible de réutiliser le code hérité (INHERITED) et d'ajouter simplement quelques lignes (qui pourront par exemple redéfinir certaines propriétés).

4.2.7 Développeur ou utilisateur?

On distingue deux catégories de personnes. Les développeurs qui connaissent bien la POO et qui créent des objets et les utilisateurs qui construisent leurs applications à partir de ces objets préfabriqués.

4.3 LEXIQUE

La source principale de confusion pour les débutants en POO est le grand nombre de nouveaux termes techniques

4.3.1 Classe (CLASS)

C'est l'ensemble des définitions, propriétés et méthodes qui serviront à créer l'objet. Elle définit la structure de l'objet et quelles en seront les propriétés. Ses modifications seront répercutées sur les classes descendantes.

4.3.2 Objet (OBJECT)

C'est une instance de la classe. Il a une existence physique et occupe de la place en mémoire. Il est créé à partir d'une classe. Toutes les modifications effectuées en exécution n'affectent en rien les descendants de sa classe.

4.3.3 Instanciation

C'est le processus qui crée en mémoire un objet basé sur une classe.

4.3.4 Constructeur (CONSTRUCTOR)

C'est le module de la classe qui dit au système comment effectuer l'instanciation de celle-ci. Il réserve de la place mémoire et initialise certaines propriétés. Delphi appelle cette méthode "Create".

4.3.5 Destructeur (DESTRUCTOR)

C'est l'inverse du constructeur. Ce module est chargé de libérer la mémoire occupée par l'objet. ("Destroy" en Delphi).

4.3.6 Classe ancêtre

C'est une classe à partir de laquelle sont héritées les propriétés et les méthodes. Ce n'est pas obligatoirement la classe parente immédiate, mais elle peut être plus élevée hiérarchiquement.

4.3.7 Classe parent

C'est la classe immédiatement supérieure au niveau hiérarchique

4.3.8 Classe enfant

C'est la classe immédiatement inférieure au niveau hiérarchique

4.3.9 Classe descendante

Son niveau hiérarchique est inférieur à la classe considérée. Ce n'est pas obligatoirement la classe enfant qui est située directement au niveau inférieur suivant.

4.3.10 Propriétaire(OWNER)

Une application est propriétaire des fenêtres qu'elle manipule. Une fenêtre est propriétaire des objets quelle contient. Un panneau, comme la barre d'outils, est propriétaire de ses turbo-boutons...

4.3.11 Héritage

Une classe hérite automatiquement des propriétés et méthodes de ses ancêtres.

...

6 L'écran de Delphi

On voit la barre de titre, la barre des menus, la barre d'outils (à gauche), la palette des composants, la fenêtre principale, l'éditeur de code (en dessous) et l'éditeur de propriétés (et la vue arborescente des objets). Une fiche est créée d'office, c'est la fenêtre principale de l'application (modifiable).

Touches de fonction importantes:

¨ F12: bascule entre l'affichage de la fiche et son code

¨ F11: fait apparaître l'inspecteur d'objets.

6.1 La barre d'outils (paramétrable):

Des infos-bulle donnent la signification des boutons. Le paramétrage peut se faire en appelant le menu contextuel (clic-droit).

Il est intéressant de placer les boutons suivants:

• Nouvelle application, tout enregistrer
• Défaire et refaire
• Couper, copier, coller
• Vérifier la syntaxe
• Exécuter, pas à pas
• Voir une fiche
• Voir la palette d'alignement
• Rubriques d'aide
• Aide sur les API Windows

6.2 La palette des composants

C'est une barre d'outils de type particulier: on y trouve les objets qui existent déjà dans Delphi. Les onglets correspondent aux catégories de composants: cliquer sur l'onglet pour changer de palette. Pour placer un composant dans la fiche, on peut cliquer sur un composant puis cliquer dans la fiche (cliquer-glisser pour redimensionner de suite). Il est également possible de double-cliquer sur un composant: il se mettra automatiquement au centre de la fiche en cours. Pour placer plusieurs composants identiques, sélectionner le type avec maj¬clic.

Il existe divers types de composants:

• visuels: ils sont visibles à l'exécution (sauf indication contraire); certains d'entre eux peuvent prendre le "focus", c'est à dire être sélectionnés par l'utilisateur
• non-visuels: ne sont visibles qu'en phase de création; ils disparaissent à l'exécution.

Les composants peuvent se reproduire avec copier-coller.

Voici les composants les plus utilisés dans une application standard.

6.2.1 Les composants de la page Standard

Les composants de la page Standard de la palette des composants permettent d'utiliser dans une application Delphi les contrôles standard de Windows :

 Composant Utilisation

Cadre Composant cadre (nouveau): sert de conteneur de composants

MainMenu Menu principal

PopupMenu Menu surgissant

Label Texte en lecture seule pour l'utilisateur (ex: titre)

Edit Texte en lecture-écriture modifiable par l'utilisateur (zone de saisie)

Memo Mémo: comme le composant précédent, mais possibilité d'utiliser plusieurs lignes de texte

Button Bouton d'action: c'est le composant le plus utilisé

CheckBox Case à cocher. Propose une option que l'utilisateur peut faire passer de Oui à Non ou de Vrai à Faux. Les cases à cocher peuvent servir à afficher un groupe de choix qui ne sont pas mutuellement exclusifs. Les utilisateurs peuvent sélectionner plusieurs cases à cocher dans un groupe.

RadioButton Bouton radio. Propose une option que l'utilisateur peut faire passer de Oui à Non ou de Vrai à Faux. Les boutons radio peuvent servir à afficher un groupe de choix qui sont mutuellement exclusifs. Les utilisateurs ne peuvent sélectionner qu'un seul bouton radio par groupe.

ListBox Boîte liste. Affiche une liste déroulante de choix.

ComboBox Boîte à options. Affiche une liste de choix en combinant une boîte liste et une boîte de saisie. Les utilisateurs peuvent saisir des données dans la boîte de saisie ou sélectionner un élément dans la zone boîte liste.

ScrollBar Barre de défilement. Propose un moyen de modifier la zone visualisée d'une liste ou d'une fiche. Une barre de défilement peut également être utilisée pour se déplacer par incréments dans un intervalle de valeurs.

GroupBox Boîte groupe. Sert de conteneur à des options associées dans une fiche.

RadioGroup Groupe de boutons radio. Crée une boîte groupe qui contient des boutons radio sur une fiche.

Panel Volet. Crée dans une fiche des volets pouvant contenir d'autres composants. Les volets peuvent servir à créer des barres d'outils ou des lignes d'état.

ActionList Composant permettant la centralisation du code événementiel

6.2.2 Les composants de la page Supplément

Les composants de la page "Supplément" de la palette des composants permettent d'utiliser dans une application Delphi des contrôles Windows spécialisés :

Composant Utilisation

BitBtn Bouton bitmap. Crée un composant bouton pouvant afficher une image.

SpeedButton TurboBouton. Propose un bouton pouvant afficher une image mais pas un libellé. Les TurboBoutons sont fréquemment regroupés dans un volet afin de créer une barre d'outils.

MaskEdit Comme le composant "Edit" mais permet une saisie formatée

StringGrid Grille de chaînes. Crée une grille pouvant être utilisée pour afficher des données chaînes de caractères en lignes et en colonnes comme dans un tableur.

DrawGrid Grille d'affichage. Crée une grille permettant d'afficher des données en lignes et en colonnes. Plus difficile à utiliser que le composant précédent.

Image Image, gère maintenant également les jpeg

Shape Forme. Dessine des formes géométriques : cercle ou ellipse, carré ou rectangle (arrondi ou non).

Bevel Biseau. Crée des lignes ou des boîtes avec un aspect tridimensionnel ciselé.

ScrollBox Boîte de défilement. Crée un conteneur redimensionnable affichant automatiquement des barres de défilement lorsque c'est nécessaire.

CheckListBox Boîte liste de cases à cocher. Affiche une liste déroulante semblable à une boîte liste, mais avec une case à cocher à côté de chaque élément.

Splitter Diviseur. Placé sur une fiche entre deux contrôles alignés, il permet aux utilisateurs de redimensionner les contrôles, à l'exécution, en faisant glisser la ligne de division.

StaticText Texte statique. Un composant texte non modifiable, comme le composant Label, mais contenant un handle de fenêtre, ce qui est utile quand la touche raccourci du composant doit appartenir à un contrôle fenêtré. Utilisez le composant StaticText pour donner à l'utilisateur des informations sur l'état en cours de l'application.

ControlBar Composant utilisé pour contenir des barres d'outils

Application Events Contrôle des événements au niveau application (nouveau)

Value List Editor Gère des couples: clé, valeur

Labeled Edit Zone de saisie avec étiquette

ColorBox Liste de couleurs pour choix

Chart Graphique

ActionManager Composant centralisateur de procédures événementielles

ActionMainMenu Bar Barre de menu d'ActionManager

ActionToolBar Barre d'outils d'ActionManager

CustomizeDlg Boîte de dialogue permettant à l'utilisateur de configurer les 2 composants précédents

6.2.3 Les composants de la page Win32

 Les composants de la page Win32 de la palette des composants permettent d'utiliser dans une application Delphi des contrôles d'interface utilisateur standard de Windows 32 bits (Windows 95, 98 ou NT).

Composant Utilisation

TabControl Onglets: permet d'accéder à des pages d'informations

PageControl Pages: comme le contrôle précédent, mais il y a de la place pour placer des composants

ImageList Liste d'images: sert souvent à stocker les images des boutons des barres d'outils modernes

RichEdit Editeur de texte formaté: créer un logiciel de traitement de textes devient facile avec ce composant

TrackBar Glissière de réglage: permet à l'utilisateur de définir une valeur analogique

ProgressBar Barre de progression: sert souvent à indiquer la proportion d'achèvement du travail

HotKey Raccourci-clavier qui peut être défini par l'utilisateur

Animate Clip vidéo muet

DateTimePicker Boîte liste permettant la saisie de dates ou d'heures.

MonthCalendar Calendrier: l'utilisateur peut sélectionner une date ou une plage de dates

TreeView Vue arborescence

ListView Affichage mode liste

HeaderControl Entête de colonne

StatusBar Barre d'état

ToolBar Barre d'outils nouvelle génération

CoolBar Barres d'outils multiples style "internet explorer'

PageScroller Zone d'affichage pouvant servir aux barres d'outils

ComboBoxEx Liste déroulante avec images

6.2.4 Les composants de la page Système

 Grâce aux composants de la page Système de la palette des composants, il est possible d'utiliser dans une application Delphi des contrôles spécialisés du système.

Composant Utilisation

Timer Minuterie: permet de déclencher des événements à intervalles réguliers

PaintBox Boîte à peindre. Spécifie une zone rectangulaire de la fiche constituant la délimitation des dessins de l'application.

MediaPlayer Multimédia. Affiche un contrôle de style télécommande pour lire ou enregistrer des fichiers multimédias son ou vidéo.

OleContainer Conteneur OLE. Crée dans une fiche une zone client OLE (Incorporation et Liaison d'Objet).

DdeClientConv Conversation client DDE. Établit une connexion client avec une

application serveur DDE (Échange Dynamique de Données).

DdeClientItem Élément client DDE. Spécifie les données du client DDE (Échange Dynamique de Données) à transférer lors d'une conversation DDE.

DdeServerConv Conversation serveur DDE. Établit une connexion serveur avec une application client DDE (Échange Dynamique de Données).

DdeServerItem Élément serveur DDE. Spécifie les données du serveur DDE (Échange Dynamique de Données) à transférer lors d'une conversation DDE.

6.2.5 Les composants de la page Dialogues

Les composants de la page Dialogues de la palette des composants permettent d'utiliser dans une application Delphi les boîtes de dialogues communes de Windows. Grâce à ces boîtes de dialogue, il est possible de proposer une interface homogène pour des opérations relatives aux fichiers (comme l'enregistrement, l'ouverture ou l'impression).

Une boîte de dialogue commune est ouverte lors de l'exécution de sa méthode "Execute". Celle-ci renvoie l'une des valeurs booléennes suivantes :

• "True", si l'utilisateur choisit OK et valide la boîte de dialogue
• "False", si l'utilisateur choisit Annuler ou quitte la boîte de dialogue sans enregistrer aucune modification.

Chaque composant Boîte de dialogue commune (sauf le composant "PrinterSetup") a un ensemble de propriétés regroupées sous l'intitulé Options dans l'inspecteur d'objets. Les propriétés Options interviennent sur l'aspect et le comportement des boîtes de dialogue communes. Pour afficher les propriétés Options, double-cliquez sur "Options" dans l'inspecteur d'objets.

Pour fermer par programmation une boîte de dialogue, utilisez la méthode "CloseDialog". Pour modifier la position d'une boîte de dialogue à l'exécution, utilisez les propriétés Handle, Left, Top et Position.

Composant Utilisation

OpenDialog Boîte de dialogue d'ouverture.

SaveDialog Boîte de dialogue d'enregistrement.

OpenPictureDialog Boîte de dialogue d'ouverture d'image avec prévisualisation

SavePictureDialog Boîte de dialogue d'enregistrement d'image avec prévisualisation

FontDialog Boîte de dialogue des polices

ColorDialog Boîte de dialogue des couleurs

PrintDialog Boîte de dialogue d'impression

PrinterSetupDialog Boîte de dialogue de configuration d'impression.

FindDialog Boîte de dialogue de recherche

ReplaceDialog Boîte de dialogue de remplacement

...

6.3 L'inspecteur d'objets

L'inspecteur d'objets de Delphi est la passerelle entre l'aspect visuel de votre application et le code qui lui permet de fonctionner.

L'inspecteur d'objets vous permet de :

• définir en mode conception les propriétés des composants que vous placez sur une fiche (ou de la fiche elle-même),
• créer les gestionnaires d'événements.

Le sélecteur d'objet en haut de l'inspecteur affiche est une liste déroulante contenant tous les composants de la fiche active, ainsi que leur type. Vous pouvez ainsi sélectionner rapidement différents composants de la fiche active.

Vous pouvez modifier la largeur des colonnes de l'Inspecteur d'objets en faisant glisser la ligne de séparation vers une nouvelle position.

L'inspecteur d'objets comporte deux pages : 6.4 Page Propriétés

La page Propriétés de l'Inspecteur d'objets vous permet, en mode conception, de définir les propriétés des composants de votre fiche, mais aussi celles de la fiche. Vous pouvez définir des propriétés d'exécution en écrivant directement du code source dans les gestionnaires d'événements. La page Propriétés n'affiche que les propriétés du composant sélectionné dans la fiche. Définir les propriétés d'un composant en mode conception revient à définir son état initial.

Des propriétés peuvent être imbriquées: dans ce cas, elle sont précédées par une flèche. Pour développer l'arborescence, double-cliquez.

La présence de 3 points de suspension (...) indique la présence d'un éditeur de propriétés particulier. On trouve également des listes déroulantes.

6.5 Page Evénements

La page Evénements de l'Inspecteur d'objets vous permet d'associer des événements aux objets de votre projet. Trois utilisations sont possibles:

UTILISATION EFFET

double-clic à coté de l'événement création automatique d'un entête de procédure par défaut introduction d'un nom de procédure création automatique d'un entête de procédure avec le nom choisi ouverture d'une liste déroulante (s'il y a déjà des procédures compatibles) choix d'une procédure commune à plusieurs événements

 6.6 L'éditeur de code

Dans certains cas, on voit dans la partie de gauche l'explorateur de code. Il facilite la navigation dans vos fichiers. La fenêtre de l'explorateur de code contient une arborescence qui montre tous les types, classes, propriétés, méthodes, variables globales et routines globales définis dans votre unité. Il montre également les autres unités listées dans la clause uses

L'éditeur de code est un éditeur complet. Il vous permet d'accéder au code (source) des modules de votre projet. De nombreuses commandes sont disponibles dans le menu contextuel de l'éditeur de code. Pour personnaliser l'éditeur de code, utilisez la boîte de dialogue "Outils" - "Options d'environnement". Pour obtenir de l'aide sur un élément dans l'éditeur de code, placez le pointeur de souris sur le terme qui vous intéresse et appuyez sur F1.

Lors de la compilation, si vous recevez un message d'erreur, Delphi :

• affiche l'erreur dans la boîte de message de l'éditeur de code
• met en surbrillance la ligne de code qui pose problème.

7 Premier projet

7.1 Notions élémentaires

Un projet est un l'ensemble des fichiers nécessaires au fonctionnement de l'application. Quand on charge Delphi, un projet de base est créé. Il comporte une fenêtre prête à recevoir différents objets.

 On remarque la barre de titre, la case système comportant une icône et des boutons pour agrandir, réduire ou fermer la fenêtre.

L'inspecteur d'objets permet d'agir sur les propriétés et méthodes événementielles de l'objet.

Il est évident que cette première application n'est pas encore exécutable. Pour ce faire, il est nécessaire de compiler (traduire en binaire). Nous n'avons pas écrit une ligne de programme, le système s'en est chargé. Examinons les lignes de code générées (.PAS).

Lignes de code Explications

unit Unit1; nom du module source correspondant à la fiche "Form1"

ne pas changer ce nom directement, mais au moment de l'enregistrement

interface entête pour désigner la section qui sera "vue" par les

autres modules

uses permet d'inclure d'autres modules

Windows, Messages, SysUtils, nom des modules inclus Classes, Graphics, Controls,

Forms, Dialogs;

type début de la déclaration du type des objets

TForm1 = class(TForm) déclaration d'un nouveau type d'objet de type fenêtre

private

{ Déclarations privées } propriétés et méthodes "privées" du type d'objet

public

{ Déclarations publiques } propriétés et méthodes "publiques" du type d'objet; elles

seront visibles par les autres modules

end; fin de déclaration d'objet

var "achat" de variables globales

Form1: TForm1; instanciation de l'objet: allocation de mémoire vive

implementation dans cette section seront écrites les méthodes des objets

manipulés

{$R *.DFM} directive de compilation permettant d'inclure les

définitions des fenêtres (.DFM)

end. Fin du module

Ce module ne peut fonctionner seul. Un module de projet (.DPR) se charge de fédérer l'ensemble des modules, mais il n'est pas visible en ce moment. Pour le visualiser, ouvrez le menu "Projet" et choisissez "voir le source". Un onglet correspondant apparaît dans l'éditeur de code.

program Project1; nom du programme

uses modules utilisés

Forms,

Unit1 in 'UNIT1.PAS' {Form1}; c'est le module de la fiche "Form1"

{$R *.RES} directive de compilation permettant d'inclure

les fichiers ressources (.RES)

begin début du programme principal

Application.Initialize; initialisation du programme

Application.CreateForm(TForm1, création de la fiche "Form1" de type Tform1

Form1);

Application.Run; exécution de l'application

end. Fin du programme principal

On peut également visualiser le code de la fiche (.DFM), grâce à l'option "voir comme texte" de son menu contextuel.

object Form1: TForm1

Left = 295

Top = 132

Width = 696

Height = 480

Caption = 'Form1'

Color = clBtnFace

Font.Charset = DEFAULT_CHARSET

Font.Color = clWindowText

Font.Height = -13

Font.Name = 'MS Sans Serif'

Font.Style = [J

OldCreateOrder = False

PixelsPerInch = 120

TextHeight = 16

end

Revenir à la fiche avec "voir comme fiche" du menu contextuel.

Pour enregistrer le projet, choisir "enregistrer projet sous" dans le menu fichier. Il faudra donner un nom aux différents modules (.PAS) et au projet (DPR).

7.2 Exécution

On peut vérifier la syntaxe du code, compiler ou exécuter directement le projet. Pour disposer d'un exécutable, il est nécessaire de compiler. En cas d'erreur, la compilation s'arrête et visualise un message d'erreur.

Si l'on désire des renseignements sur l'erreur, il suffit cliquer sur le message d'erreur ou d'avertissement et d'appuyer sur la touche F1 (aide en ligne) et on obtient la fenêtre suivante:

Il suffit de rectifier le code et de relancer une compilation. Ensuite, on peut directement utiliser l'exécutable généré (.EXE). Quitter Delphi et lancer le programme depuis le l'explorateur Windows.

8 Modification du projet

Relancer Delphi et ouvrir le projet précédent. Nous désirons à présent installer un bouton qui change la couleur du fond de la fenêtre en rouge.

8.1 Mise en place du composant

Choisir un bouton ("Tbutton") par un clic dans la palette standard et cliquer dans la fiche. On peut également double-cliquer dans la palette et le bouton se mettra automatiquement au milieu de la fiche. Ce bouton se nomme "Button1" et ne fait rien pour l'instant. Si l'on examine le module source, on trouve sa déclaration dans les types.

Deux propriétés importantes: "caption" qui permet de changer l'affichage du texte sur le bouton et "name" qui est le nom qui servira à adresser l'objet. Changer le nom du bouton (c'est indispensable pour les projets importants) avec quelque chose de plus significatif: BtRouge. On constate que la propriété "caption" est également modifiée. Changer cette propriété pour que le bouton affiche "Colorer en rouge". Le composant peut être redimensionné grâce à ses poignées (visibles quand sélectionné).

8.2 Affectation d'une procédure événementielle

La liste des événements peut s'observer grâce à l'inspecteur d'objets. Pour créer une procédure simple "OnClic", il suffit de double-cliquer sur le bouton.

Le code suivant est généré:

procedure Tform1.BtRougeClick(Sender: Tobject); begin

end;

Cette procédure événementielle est prête à accueillir une ou plusieurs lignes d'instructions entre "begin" et "end". Si l'on désire rajouter des commentaires (et c'est indispensable pour une bonne maintenance), utiliser les méthodes suivantes:

• { commentaires: plusieurs lignes possibles }
• (* commentaires: plusieurs lignes possibles *)
• // commentaires: sur une seule ligne

Si je ne connais pas la façon de colorer la fenêtre, je vais chercher les propriétés de l'objet Tform grâce à l'aide en ligne. Il suffit de sélectionner "Form1" et d'appuyer sur le touche F1. Ensuite, cliquer sur "propriétés". La liste affiche "color": cliquer sur cette propriété. On trouve que "clRed" correspond au rouge.

Je vais donc compléter la procédure pour obtenir le listing suivant:

procedure Tform1.BtRougeClick(Sender: Tobject);

{colore en rouge le fond de la fenêtre}

begin

Form1.color:=ClRed;

end;

Remarques:

• quand je tape "Form1.", l'éditeur de code me propose la liste des propriétés, méthodes et variables de l'objet.
• le séparateur entre objet et méthodes est le point et l'instruction d'affectation est ":=" et non "=" qui est réservé aux tests d'égalité ou à la déclaration des types. Les lignes d'instruction se terminent par le point-virgule.

Enregistrer le projet, et vérifier son exécution.

8.3 Améliorations

Il est dommage de ne pas avoir de bouton pour remettre la couleur d'origine et un autre pour quitter le programme. On pourrait double-cliquer sur la fiche pour rétablir la couleur d'origine.

Sélectionner la fenêtre et double-cliquer à côté de l'événement "OnDblClick" dans l'inspecteur d'objet. Le code suivant est généré:

procedure Tform1.FormDblClick(Sender: Tobject);

begin

end;

L'aide nous dit que "clWindow" pour la couleur de fond courante des fenêtres. La

procédure devient donc:

procedure Tform1.FormDblClick(Sender: Tobject);

begin

Form1.color:=clWindow;

end;

Exécuter et tester.

La palette "suppléments" nous fournit un composant intéressant: TBitBtn. C'est un bouton comportant une image (glyphe) et ayant des fonctions préprogrammées (Kind). Mettre cette propriété "Kind" à "bkClose".

 Delphi 7 (1/3): Initiation

Aligner les deux boutons à gauche grâce à la palette d'alignement (menu "Voir").

 On peut sélectionner plusieurs objets en cliquant-glissant pour tracer un rectangle qui les touche ou les englobe.

Un menu contextuel sur les objets permet également de les rendre de même taille ou de les changer d'échelle:

Présenter les deux boutons de même taille et alignés à droite et à gauche. Enregistrer et exécuter.

Exercice:

Enlever le bouton "rouge" et placer trois curseurs dans des panneaux de couleur pour régler l'intensité des 3 couleurs de base: rouge, vert et bleu. Les intensités varient de 0 à 255. La fonction RGB (voir l'aide en ligne) est utile. Un seul gestionnaire d'événement suffira.