Developpez.com - C
X

Choisissez d'abord la catégorieensuite la rubrique :



Création d'un composant C++ Builder

Par CGi

Le 11 août 2003


5 - Propriété de type enum :

Nous allons maintenant aborder les propriétés de type enum (énumérations), propriétés couramment utilisées dans les composants C++ Builder. L'avantage des propriétés de type enum est qu'elles ont des noms explicites pour leurs valeurs, qui de plus sont limitées à une liste de constantes symboliques. Autre avantage dans le cas d'une propriété, c'est que cette liste s'affiche dans l'inspecteur d'objet pour la propriété en question.

Pour aborder ce type de propriété, nous allons prendre un exemple simple : Nous allons construire un TAlignEdit composant descendant de TEdit qui aura comme nouvelle propriété d'aligner son contenu à gauche, à droite ou centré. Cette propriété ayant trois possibilités, le type enum lui convient donc parfaitement. Pour parfaire notre exercice, nous ajouterons une deuxième propriété de type enum qui aura comme caractéristique de pouvoir limiter la saisie à des chiffres, à des chiffres plus le séparateur décimal plus le signe moins ou pas de limitation.

Fichier "alignedit.h" :

#ifndef AlignEditH
#define AlignEditH
//---------------------------------------------------------------------------
#include <SysUtils.hpp>
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
//---------------------------------------------------------------------------
enum TAlignement {alGauche, alCentre, alDroite};
enum TNumerique {chNone, chInt, chFloat};

class PACKAGE TAlignEdit : public TEdit
{
private:
        TAlignement FAlign;
        TNumerique FNum;
protected:
        DYNAMIC void __fastcall KeyPress(char &Key);
        DYNAMIC void __fastcall DoEnter();
        virtual void __fastcall SetAlign(TAlignement Value);
        virtual void __fastcall SetNum(TNumerique Value);
        void __fastcall CreateParams(TCreateParams &Params);          
public:
        __fastcall TAlignEdit(TComponent* Owner);
__published:
        __property TAlignement Alignement = {read=FAlign, write=SetAlign, nodefault};
        __property TNumerique Chiffres = {read=FNum, write=SetNum, nodefault};
};
//---------------------------------------------------------------------------
#endif

Dans le fichier entête "alignedit.h" nous déclarons nos deux types enum : TAlignement et TNumerique. Pour TNumerique la valeur chNone correspond à pas de restriction, chInt à chaîne de type int et chFloat chaîne de type float. Pour TAlignement c'est suffisamment explicite. Ensuite dans la section private de la classe TAlignEdit nous déclarons nos deux données membres FAlign de type TAlignement et FNum de type TNumerique.
Dans la section protected nous déclarons les méthodes SetAlign SetNum qui serviront à modifier leur propriété respective. Déclaration des méthodes à redéfinir KeyPress, DoEnter, CreateParams.
Dans la section __published les 2 propriétés de type enum toujours selon le même principe. Notre composant descendant de TEdit où toutes ses propriétés sont déjà visibles, il n'y a donc pas besoin de les redéclarer.


Fichier "alignedit.cpp"

#include <vcl.h>
#pragma hdrstop
#include "AlignEdit.h"
#pragma package(smart_init)
//---------------------------------------------------------------------------
//  ValidCtrCheck est utilisé pour vérifier que les composants créés n'ont
// aucune fonction virtuelle pure.  
static inline void ValidCtrCheck(TAlignEdit *)
{
        new TAlignEdit(NULL);
}
//---------------------------------------------------------------------------
__fastcall TAlignEdit::TAlignEdit(TComponent* Owner)
        : TEdit(Owner)
{
     FAlign = alGauche;
     FNum = chNone;
}
//---------------------------------------------------------------------------
void __fastcall TAlignEdit::DoEnter()
{
     TEdit::DoEnter();
     if(AutoSelect) SelectAll();
}
//---------------------------------------------------------------------------
void __fastcall TAlignEdit::SetAlign(TAlignement Value)
{
     FAlign = Value;
     RecreateWnd();
}
//---------------------------------------------------------------------------
void __fastcall TAlignEdit::SetNum(TNumerique Value)
{
     FNum = Value;
     RecreateWnd();
}
//---------------------------------------------------------------------------
void __fastcall TAlignEdit::CreateParams(TCreateParams& Params)
{
    int ValAlign;
    int ValNum;
    switch (Alignement)
        {
         case alGauche :
                ValAlign = ES_LEFT;
                break;
         case alCentre :
                ValAlign = ES_CENTER;
                break;
         case alDroite :
                ValAlign = ES_RIGHT;
                break;
        }
    if ( Chiffres == chInt ) ValNum = ES_NUMBER;
    else ValNum = 0;
    TEdit::CreateParams(Params);
    Params.Style = Params.Style | ValAlign | ValNum
                                               | ES_MULTILINE ;
}
//---------------------------------------------------------------------------
void __fastcall TAlignEdit::KeyPress(char &Key)
{
     TEdit::KeyPress(Key);
     if (Key == 13) Key = NULL;
     if (Chiffres == chFloat && (Key < '0' || Key >'9') && Key != 8 &&
             (Key != '-' || Text.Length() > 0 && SelLength != Text.Length()) &&
                     (Key != DecimalSeparator || Text.Pos(DecimalSeparator)!=0))
                                                                     Key = NULL;
}
//---------------------------------------------------------------------------
namespace Alignedit
{
        void __fastcall PACKAGE Register()
        {
                 TComponentClass classes[1] = {__classid(TAlignEdit)};
                 RegisterComponents("MesCompo", classes, 0);
        }
}

Passons maintenant à la définition de nos méthodes :
Dans le constructeur initialisation de nos deux données membres FAlign et FNum.
Dans la méthode DoEnter on sélectionne le texte quand le contrôle prend le focus. Les méthodes SetAlign et SetNum Comme à l'habitude assignent leur donnée membre respective, puis appelle la méthode RecreateWnd qui force le contrôle à se reconstruire. (Certaine propriétés de contrôles Windows ne peuvent être modifiées que de cette façon).
La méthode redéfinie CreateParams est appelée automatiquement avant la reconstruction du contrôle, c'est donc ici que nous initialiserons les paramètres de notre contrôle. On y retrouve d'ailleurs les énumérations Alignement et Chiffres que l'on teste pour l'initialisation de ces paramètres.
Dans la méthode KeyPress nous invalidons la touche entrée car c'est un contrôle multiligne et cela aurait pour effet de créer une seconde ligne ce qui n'est pas notre but. (Le contrôle EDIT de Windows ne peut avoir un alignement à droite ou centrée que s'il est multiligne). Dans cette méthode nous faisons aussi la sélection des caractères pour la saisie numérique de type float.
Pour que notre composant puisse traiter les événements correspondant aux méthodes DoEnter et KeyPress, il faut appeller la méthode correspondante de la classe ancêtre. par exemple pour DoEnter() il faut appeller Edit::DoEnter().

Vous avez pu constater que le type enum est très facile à mettre en oeuvre dans un composant. Vous avez aussi dû remarquer que de nombreux composants utilisent ce type de donnée pour leurs propriétés. Il rend l'utilisation des composants beaucoup plus intuitive. Des propriétés avec des valeurs explicites sont beaucoup plus simples d'utilisation, donc à utiliser sans modération dans vos composants.


CGi

Avec la contribution d'Alacazam pour la relecture.

Télécharger les sources.





Sommaire

1 - Création d'un composant pas à pas.
2 - Création d'un composant graphique.
3 - Propriété de type TStrings.
4 - Propriété de type TBitmap et contrôle du Owner.
5 - Propriété de type enum.
6 - Contrôle fenêtré.
7 - Evénement personnalisé et sous-propriétés.
8 - Composant pouvant interagir avec ses semblables.
9 - Ressources dans un composant.
10 - Boîte de dialogue dans un composant.
11 - Composant conteneur.
12 - Les éditeurs de composants. Nouveau



C/C++
  Les pointeurs du C/C++.   Les listes chaînées.             Liste simple.             Liste triée.             Liste double.   Les arbres.   Les tas.   Le C orienté objets ?

  1 - La fenêtre principale.   2 - Contrôles et messages.   3 - Les commandes.   4 - Dialogue std.   5 - Contexte de périph.   6 - Dessiner.   7 - Les ressources.   8 - Dialogue perso.   9 - Dialogue comm.   10 - Les accélérateurs.

Assembleur
  Assembleur sous Visual C++.

C++ BUILDER
  Trucs et astuces.   Composant.   TRichEdit.   TDrawGrid.   Application MDI.   TThread.   wxWidgets.   Style Win XP.

  Première application.   Construire un menu.   Dessiner.   Sisers, Timers...   Dialogues standards.   Dialogues perso.

DotNet
  Composant C# Builder.   Contrôle WinForm.   Application MDI.

Java
  Applet java.





Copyright 2002-2016 CGi - Tous droits réservés CGi. Toutes reproduction, utilisation ou diffusion de ce document par quelque moyen que ce soit autre que pour un usage personnel doit faire l'objet d'une autorisation écrite de la part de l'auteur, propriétaire des droits intellectuels.
Les codes sources de ce document sont fournis en l'état. L'utilisateur les utilise à ses risques et périls, sans garantie d'aucune sorte de la part de l'auteur. L'auteur n'est responsable d'aucun dommage subi par l'utilisateur pouvant résulter de l'utilisation ou de la distribution des codes sources de ce document.
De la même façon, l'auteur n'est en aucun cas responsable d'une quelconque perte de revenus ou de profits, ou de données, ou de tous dommages directs ou indirects, susceptibles de survenir du fait de l'utilisation des codes sources de ce document, quand bien même l'auteur aurait été averti de la possibilité de tels dommages. L'utilisation des codes sources de ce document vaut acceptation par l'utilisateur des termes de la licence ci-dessus.

Contacter le responsable de la rubrique C