Developpez.com

Plus de 14 000 cours et tutoriels en informatique professionnelle à consulter, à télécharger ou à visionner en vidéo.

Developpez.com - C
X

Choisissez d'abord la catégorieensuite la rubrique :



Création d'un composant C++ Builder

Par CGi

Le 10 avril 2004


10 - Boîte de dialogue dans un composant :

Introduction :

Nous allons voir comment intégrer une boîte de dialogue (TForm) à un composant, à l'aide d'un exemple.

Ce composant sera un descendant de TShape et lui sera semblable en tout point, si ce n'est que l'on pourra changer sa couleur à l'exécution par l'appel d'une boîte de dialogue prévue à cet effet. Boîte de dialogue qui sera elle même intégrée au composant et que l'on pourra appeler par un click droit sur ce même composant. On aurait aussi pu faire un composant non visuel et appeler la boîte de dialogue par une méthode comme "execute".

Création de la boîte de dialogue :

Rien de bien compliqué, la procédure est semblable à celle de n'importe quelle autre fiche, comme vous avez l'habitude de le faire dans vos applications.




Fermer toute application, puis ouvrir une nouvelle Fiche. J'ai bien dit Fiche et non pas Application. On va changer immédiatement sa propriété Name en "DlgColor1" et BorderStyle en bsDialog.
Nous allons y déposer comme la copie d'écran ci-dessus un TShape (Shape1), 3 ScrollBars (ScrollBar1, ScrollBar2, ScrollBar2) avec leur propriété Position à 255, un bouton avec sa propriété Caption à "Ok", Default à true et ModalResult à mrOk, puis un second bouton avec sa propriété Caption à "Annuler", Cancel à true et ModalResult à mrCancel.
Nous allons maintenant traiter l'événement OnChange des ScrollBars. Pour simplifier le code nous créons une méthode unique pour les 3 ScrollBars que nous nommerons ScrollBarChange. (Donc dans l'éditeur de propriétés l'événement OnChange de chaque ScrollBar doit référencer cette unique méthode.)


Fichier "DlgColor.cpp" :

#include <vcl.h>
#pragma hdrstop

#include "DlgColor.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TDlgColor1 *DlgColor1;
//---------------------------------------------------------------------------
__fastcall TDlgColor1::TDlgColor1(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TDlgColor1::ScrollBarChange(TObject *Sender)
{
      Shape1->Brush->Color = (TColor)RGB(ScrollBar1->Position,
                                   ScrollBar2->Position, ScrollBar3->Position);
}

Comme on peut le voir dans le code ci-dessus la couleur du Shape (Shape1) de contrôle change dés que l'une des ScrollBars change de position.
Le fichier entête "DlgColor.h" n'a rien de particulier. Nous n'avons plus qu'à sauver notre fiche sous le nom de "DlgColor.cpp" et dans le dossier où ce trouvera le futur composant.
Vous devez donc y trouver comme fichiers : "DlgColor.cpp", "DlgColor.h" et "DlgColor.dfm".

Création du composant :

Abordons maintenant le composant proprement dit. Vous créez le composant selon la procédure habituelle, vous lui donnez comme ancêtre la classe TShape et vous le nommez "TShapeColor". Vous avez maintenant le code minimum du composant. Nous allons y redéfinir la méthode MouseUp afin d'appeler notre boîte de dialogue précédemment créée suite à un click droit sur le composant.

Fichier "ShapeColor.h"

#ifndef ShapeColorH
#define ShapeColorH
//---------------------------------------------------------------------------
#include <SysUtils.hpp>
#include <Classes.hpp>
#include <Controls.hpp>
#include <ExtCtrls.hpp>
//---------------------------------------------------------------------------
class PACKAGE TShapeColor : public TShape
{
private:
DYNAMIC void __fastcall MouseUp(TMouseButton Button,
                                     Classes::TShiftState Shift, int X, int Y);
protected:
public:
        __fastcall TShapeColor(TComponent* Owner);
__published:
};
//---------------------------------------------------------------------------
#endif

Il nous faut donc inclure le fichier entête de la boîte de dialogue "DlgColor.h", mais il faut aussi indiquer au lieur de lier le fichier "DlgColor.obj" après la compilation par la directive : #pragma link "DlgColor.obj".
Dans la méthode MouseUp nous créons la boîte de dialogue. Nous initialisons la couleur de son TShape (DlgColor1->Shape1) avec celle de notre composant. Nous initialisons les positions de ses ScrollBars avec les composantes de la couleur de notre composant. Nous la rendons visible. A sa fermeture nous initialisons la couleur de notre composant avec celle de son TShape (DlgColor1->Shape1) si elle renvoie mrOk, c'est à dire si elle est fermée avec le bouton "Ok" ou par la touche "Entrée". Puis nous détruisons la boîte de dialogue.

Fichier "ShapeColor.cpp"

#include <vcl.h>
#pragma hdrstop

#include "ShapeColor.h"
#include "DlgColor.h" // Fichier entête de la boîte de dialogue
#pragma link "DlgColor.obj" // Fichier obj de la boîte de dialogue
#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(TShapeColor *)
{
        new TShapeColor(NULL);
}
//---------------------------------------------------------------------------
__fastcall TShapeColor::TShapeColor(TComponent* Owner)
        : TShape(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TShapeColor::MouseUp(TMouseButton Button,
                                   Classes::TShiftState Shift, int X, int Y)
{
      if(Button == mbRight)
       {
         DlgColor1 = new TDlgColor1(NULL);
         DlgColor1->Shape1->Brush->Color = Brush->Color;
         DlgColor1->ScrollBar1->Position = GetRValue(Brush->Color);
         DlgColor1->ScrollBar2->Position = GetGValue(Brush->Color);
         DlgColor1->ScrollBar3->Position = GetBValue(Brush->Color);
         if (DlgColor1->ShowModal() == mrOk)
              Brush->Color = DlgColor1->Shape1->Brush->Color;
         delete DlgColor1;
       }
}
//---------------------------------------------------------------------------
namespace Shapecolor
{
        void __fastcall PACKAGE Register()
        {
                 TComponentClass classes[1] = {__classid(TShapeColor)};
                 RegisterComponents("MesCompo", classes, 0);
        }
}

Vous l'ajoutez à un paquet, il faudra aussi ajouter le fichier "DlgColor.cpp" à ce même paquet puis vous compilez le paquet comme pour les précédents composants.

Voilà comme vous avez pu le voir, la liaison d'une boîte de dialogue à un composant n'est pas très compliquée. Cela peut être très utile pour donner la possibilité à l'utilisateur de changer les propriétés de votre composant à l'exécution.

Bon dialogue...

Et à bientôt pour la suite,

CGi

Avec la contribution de Demco pour la relecture.

Télécharger les sources.(BCB6)





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