PlanCompos

Les composants Delphi
du CD-ROM

Retour au chapitre 7

Comment installer les composants

Les composants Delphi présents dans le CD ROM, associés au chapitre "Construire des outils" du livre :

Les composants sont classés en trois catégories de développement . Le classement est essentiellement effectué à partir de la classe initiale dont il dérive. Nous avons choisi trois classes de départ (d'abstractions différentes) correspondant à trois types généraux de composants que l'on peut dévélopper rapidement. Il est possible d'ouvrir encore plus la classe mère mais nous pensons que cela obligerait le lecteur à rentrer dans la complexité technique du produit. Ces trois catégories devraient suffire à faire comprendre le mécanisme de construction. Elles fournissent en outre un nombre important de nouveaux outils.

Les 3 catégories explorées, un composant est construit par :

Dérivation d'un composant visuel déjà présent dans la palette. On obtient un composant visuel.

Association de composants visuels déjà présents dans la palette. On obtient aussi un composant visuel.

Dérivation de la classe des composants TComponent pour réutiliser une classe déjà existante. On obtient un composant non visuel.

Composant construit à partir de composants visuels déjà présents dans la palette avec un affichage de l'heure seconde par seconde (même pendant pendant la conception du programme). On obtient ainsi un composant visuel d'affichage.

Variations sur un composant de visualisation de structure d'arbre :

Delphi.Composants
                 |__ Propriete.Tree
                 |__ Methode.Tree
                 |__ Evenement.Tree
                 |__ Retailler.Tree
                                                                                                    Remonter

Trois composants visuels construits par association d'autres composants visuels :

Delphi.Composants
                 |__ Compos.TwinArbre
                 |__ Compos.exprarit
                 |__ Compos.ListeNonVisu\DebugListe
                                                                                                      Remonter

Un composant non visuel de Liste de chaînes :

Delphi.Composants
                 |__ Compos.ListeNonVisu
                 |__ Liste4Visuellecompos.Dlfi (version visuelle du précédent)
                                                                                                    Remonter

Un composant visuel d'affichage de l'heure :

Delphi.Composants
|__ Compos.temps
Remonter

Composant : Retailler.Tree (dérivation d'un composant visuel)

Un composant d'arbre dont on peut modifier la taille à la conception.
On reprend le principe de construction du composant Evenement.Tree en y ajoutant une méthode privée permettant d'intercepter pendant la conception le message système WM_SIZE (changement de la taille du contrôle).

Par rapport au contenu de la Unit du composant Evenement.Tree, nous n'avons fait qu'ajouter la méthode "procedure WMSize" dont le rôle est d'intercepter le message de modification de la taille du contrôle pendant la conception.

interface

TTree4 = class(TCustomControl){strictement identique à l'étape 1}
private
Fniveau:integer;
Arbre:Toutline;
procedure WMSize(var Message:TWMsize);message WM_SIZE;
.........

implementation

// méthode "WMSize" de modification de la taille:

procedure TTree4.WMSize(var Message:TWMsize);
{permet de modifier la taille du customcontrol lors de la conception.
Elle est exécutée à chaque fois que, lors de la conception, vous essayez
de modifier la taille du CustomControl. Le Toutline ajuste sa hauteur
(height) et sa largeur (width) à celle du CustomControl.}
begin
inherited;
Arbre.setbounds(0,0,width,height);
end;

Le code source du composant complet se trouve sur le CD-ROM dans : Delphi.Composants\Retailler.Tree\Utree4.pas

Composant : Compos.TwinArbre (association de composants visuels)

Ce composant est un exemple d'association de plusieurs composants:
Un Toutline est associé à deux autres composants visuels TTrackBar et TEdit, afin de ne plus former qu'un seul composant. En outre pour son fonctionnement sur la partie arborescente (Toutline) il est construit comme une combinaison des 4 variations sur le Toutline ( Methode.Tree, Propriete.Tree, Evenement.Tree, Retailler.Tree). Il est donc conseillé de bien étudier séparément ces 4 composants distincts, puis de considérer le composant TWinArbre comme récapitulant en une seule classe toutes les modifications apportées au Toutline. Enfin, il vous est possible d'ajouter au TWinArbre vous même, de nouvelles propriétés ou de nouvelles réaction à certains évènements en suivant la démarche conseillée dans le développement pas à pas de chacun des 4 exemples.

aspect visuel ducomposant TWinArbre:

Voici à titre indicatif la classe du composant TwinArbre :

TwinArbre = class(TCustomControl)
private
    { les 3 objets visuels assemblés}
    FPotentiometre: TTrackBar;
    FEdit1: TEdit;
    FTree:Toutline;
    OldColor:TColor;
    procedure WMSize(var Message:TWMsize);message WM_SIZE;
    function Getmaxniveau:integer;
    function GetProfondeur:integer;
    function GetEnabled:boolean;
    procedure SetEnabled(x:boolean);
    function GetLignes:Tstrings;
    procedure SetLignes(x:Tstrings);
    function GetCouleur:TColor;
    procedure SetCouleur(x:TColor);
    function GetAscenceur:TScrollStyle;
    procedure SetAscenceur(x:TScrollStyle);
    procedure affiche_un_niveau(le_niveau:integer);
    procedure affiche_racine;
    procedure lire_un_niveau(indice:integer;niveau:integer);
    procedure CalCulChemin(Noeud:ToutLineNode;Liste:TStringList);
    procedure ArbreMouseDown(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
    procedure PotentiometreChange(Sender: TObject);
public
    Liste: TStringList;
    constructor Create(Aowner:Tcomponent);override;
    property Potentiometre: TTrackBar read FPotentiometre;
    property Tree: Toutline read FTree write FTree;
    property Profondeur:integer read GetProfondeur;
published // ce qui apparaît dans l'inspecteur d'objet lors de la conception
    property Enabled:boolean read Getenabled write Setenabled;
    property Lignes: Tstrings read GetLignes write SetLignes;
    property Couleur: TColor read GetCouleur write SetCouleur;
    property Ascenceur: TScrollStyle read GetAscenceur write SetAscenceur;
end;

Le code source du composant complet se trouve sur le CD-ROM dans : Delphi.Composants\Compos.TwinArbre\UWinArbre.pas

Composant : Compos.exprarit (association de composants visuels)

Ce composant TExpraritm permet la saisie d'expressions arithmétiques par filtrage. Il est composé d'un assemblage visuel constitué de deux TEdit, un TListBox et une table de TBitBtn (créée dynamiquement lors de la conception). Ces objets visuels sont associés à un analyseur descendant récursif (pour grammaire LL(1) des expressions arithmétiques) qui est fourni et qui sert à assurer le filtrage des expressions saisies par l'utilisateur. Ce composant recouvre les parties du cours concernant la construction de composant pour une interface de saisie et le filtrage par analyse d'une grammaire LL(1).

Afin d'aider le lecteur la construction de ce composant a été decomposée selon la procédure des trois étapes successives (un programme, une classe, le composant) et se trouve sur le CD :

code source dans :
Delphi.Composants\Compos.exprarit\Exprarithm00.dev (un programme)
Delphi.Composants\Compos.exprarit\Exprarithm01.dev (une classe)
Delphi.Composants\Compos.exprarit\Exprarithm02.dev (le composant)

aspect visuel du composant TExpraritm:

Voici à titre indicatif la classe du composant TExpraritm :

type
TypBouton=(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,TTest,Tback,Tclear,Tplus,
Tmoins,Tmult,Tpuiss,Tparferm,Tdiv,Tdivint,Tmod,Tparouvr,
Tvar,Tleave,TFin);
TableBouton=array[TypBouton]of TBitBtn;
enscar=set of char;

TExpraritm=class(TCustomControl)
private
    Edit1: TEdit;
    Edit2: TEdit;
    ListBoxvar: TListBox;
    UnBouton:TableBouton;
    numcar: integer;
    carlu: char;
    LesFollow,LesInit:enscar;
    Chiffres,Lettres:enscar;
    edit_expr,expr_loc,expr_err:string; {expressions dans l'éditeur}
    erreur_expr:boolean;{erreur dans l'expression}
    procedure ListBoxClick(Sender: TObject);
    procedure BitBtnClick(Sender: TObject);
    procedure BitBtnTestClick(Sender: TObject);
    procedure BitBtnbackClick(Sender: TObject);
    procedure BitBtnclearClick(Sender: TObject);
    procedure BitBtnvarClick(Sender: TObject);
    procedure BitBtnleaveClick(Sender: TObject);
    procedure BitBtnfinClick(Sender: TObject);
    procedure expr;
    procedure init;
    procedure carsuiv;
    procedure err(n:integer);
    function GetLignes:Tstrings;
    procedure SetLignes(x:Tstrings);
public
     Expression:string;
     Reconnue:boolean;
     constructor create(Aowner:Tcomponent);override;
published
     property Lignes:TStrings read GetLignes write SetLignes;
end;

Composant : Compos.TEditListe (association de composants visuels)

Ce composant est proposé à titre pédadgogique afin d'être modifié et enrichi par des nouvelles fonctionnalités. Il sert de panneau visuel de deboggage au composant non visuel de liste (classe Tliste dans "UListeCompos " ), il utilise un champ FListe de type Tliste, le code source vous indique comment réutiliser pratiquement un de vos composant déjà construit, dans un nouveau composant.

Le code source du composant complet se trouve sur le CD-ROM dans : Delphi.Composants\Compos.ListeNonVisu\DebugListe\UEditListeCompos.pas

Un exemple d'utilisation de ce composant se trouve ur le CD-ROM dans :
Delphi.Composants\Compos.ListeNonVisu\DebugListe\PoidsListedebug.Dlfi

aspect visuel du composant TEditListe:

Voici à titre indicatif la classe du composant TEditListe :
unit UEditListeCompos;

interface
Uses UListeCompos,
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
Buttons,StdCtrls,ExtCtrls, Grids,ComCtrls;

type
TEditListe=class(TCustomControl)
private
    FBevel:TBevel; FEditRang: TEdit;FEditElement: TEdit; FEditrangpos: TEdit;
    FEditposition: TEdit; FEditajouter: TEdit; FEditinserer: TEdit;
    FEditmodifier: TEdit; FEditsupprimer: TEdit;
    FListBox1: TListBox;
    FBitBtnCharger: TBitBtn;FBitBtnElement: TBitBtn; FBitBtnPosition: TBitBtn;
    FBitBtnAjouter: TBitBtn;FBitBtnInserer: TBitBtn; FBitBtnModifier: TBitBtn;
    FBitBtnSupprimer: TBitBtn; FBitBtnSauver: TBitBtn;
    FBitBtnEffacer: TBitBtn; FBitBtnFermer: TBitBtn;
    FLabel1: TLabel; FLabelCount: TLabel;
    FListe:TListe; //composant personnel non visuel de liste de chaînes
    procedure BitBtnSauverClick(Sender: TObject);
    procedure BitBtnChargerClick(Sender: TObject);
    procedure BitBtnEffacerClick(Sender: TObject);
    procedure BitBtnElementClick(Sender: TObject);
    procedure BitBtnPositionClick(Sender: TObject);
    procedure BitBtnAjouterClick(Sender: TObject);
    procedure BitBtnInsererClick(Sender: TObject);
    procedure BitBtnModifierClick(Sender: TObject);
    procedure BitBtnSupprimerClick(Sender: TObject);
    procedure BitBtnFermerClick(Sender: TObject);
    procedure ListBox1Click(Sender: TObject);
    procedure Voir;
public
     constructor create(Aowner:Tcomponent);override;
     destructor Liberer;
     procedure EditerListe(var L:TListe);
published
     {property à rajouter si vous le souhaitez}
end;

Composant : Compos.ListeNonVisu (un composant non visuel)

Ce composant (TListe dans UListecompos.pas) est proposé à titre pédadgogique. Il montre comment encapsuler la classe TStringList dans un composant : nous construisons ce composant de liste de chaînes non visuelle héritant de Tcomponent (ancêtre abstrait le plus haut pour tout composant) avec un seul champ de type TStringList, ses opérateurs étant une encapsulation des opérateurs du TStringList. Nous avons construit une méthode (procedure VersListBox (LBox:TListBox); ) qui permet la recopie du contenu de la liste dans un TlistBox, le programmeur pourra donc visualiser rapidement le contenu de sa liste interne en utilisant cette méthode publique.

Le code source du composant complet se trouve sur le CD-ROM dans : Delphi.Composants\Composant\UListecompos.pas

Aspect de l'icône du composant dans la palette :

TListe = class(TComponent)
private
   FListGeneric:TstringList;
   function Getcount:integer;
   function GetDuplic:boolean;
   procedure SetDuplic(x:boolean);
   function Getsorted:boolean;
   procedure Setsorted(x:boolean);
public
   constructor create(Aowner:Tcomponent);override;
   destructor Liberer;
   {opérateurs de manipulation de la liste}
   procedure Effacer;
   function Element(rang:integer):string;
   function Position(element:string):integer;
   procedure Ajouter(ch:string);
   procedure Inserer(element:string;rang:integer);
   procedure Modifier(rang:integer;element:string);
   procedure Supprimer(rang:integer);

   {opérateurs de recopie d'une liste}
   procedure EstUneCopiede(T:TListe);
   procedure VersListBox(LBox:TListBox);

   {opérateurs d'entrée/sortie dans une liste}
   procedure Charger;
   procedure Sauver;

   // ajoutez ici vos propres opérateurs publiques de liste
   {propriétés publiques, uniquement consultables}
    property Quantite:integer read Getcount ;
    property ListGeneric:TstringList read FListGeneric;

published
    property Dupliquee:boolean read GetDuplic write SetDuplic;
    property Triee:boolean read Getsorted write Setsorted;
   // ajoutez ici vos propres propriétés publiées
end;

Une version de composant de liste de chaînes visuelle héritant du TListBox se trouve sur le CD-ROM dans :
Delphi.Composants\Liste4Visuellecompos.Dlfi

type
T0 = string;
liste =class(TListBox)
         public
          constructor create(Aowner:Tcomponent);override;
          procedure init_liste;
          function longueur : integer;
          procedure supprimer (k: integer);
          procedure inserer (k: integer; x: T0);
          function kieme (n: integer): T0;
          function Test (x: T0): boolean;
          procedure Rechercher (x: T0; var place: integer);
          procedure creationListe(Box:TListBox);
          procedure Ajouter(x:T0);
          procedure effacer;
         private
          function Est_vide:boolean;
        end;

Composant : Compos.temps(un composant associé, visuel avec Timer)

Ce composant Ttemps est proposé à titre pédadgogique afin d'être observé, modifié et enrichi par de nouvelles fonctionnalités. Il est composé par association d'un TEdit, d'un TLabel, de trois TBitBtn et d'un TTimer. Il fournit en temps réel l'heure machine, mise à jour toutes les secondes.

La construction de ce composant a été decomposée selon la procédure des trois étapes successives (un programme, une classe, le composant) et se trouve sur le CD :

code source du composant complet dans : Delphi.Composants\Compos.temps\Dateheure00.dev (un programme)
Delphi.Composants\Compos.temps\Dateheure01.dev (une classe)
Delphi.Composants\Compos.temps\Dateheure02.dev (le composant)

aspect visuel du composant Ttemps:

Ttemps = class(TCustomControl)
   private
    Timer1: TTimer;
    LabelHeure: TLabel;
    Edit1: TEdit;
    BitBtndate: TBitBtn;
    BitBtnjour: TBitBtn;
    BitBtnNow: TBitBtn;
    LesJours:array[1..7]of string;
    FHeure,FDate,FJour:string;
    FFondcolor,FClockcolor:Tcolor;
    procedure Timer1Timer(Sender: TObject);
    procedure BitBtndateClick(Sender: TObject);
    procedure BitBtnjourClick(Sender: TObject);
    procedure BitBtnNowClick(Sender: TObject);
    procedure SetFondcolor(x:Tcolor);
    procedure SetClockcolor(x:Tcolor);
    procedure RetaillerWMSize(var Message:TWMsize);message WM_SIZE;
public
    constructor create(x:Tcomponent);override;
published
    property L_Heure:string read FHeure write FHeure;
    property LaDate:string read FDate write FDate;
    property LeJour:string read FJour write FJour;
    property CouleurFond:Tcolor read FFondcolor write SetFondcolor;
    property CouleurClock:Tcolor read FClockcolor write SetClockcolor;
end;