Developpez.com - C
X

Choisissez d'abord la catégorieensuite la rubrique :



Création d'un composant C++ Builder

Par CGi

Le 15 novembre 2003


9 - Ressources dans un composant :

Introduction :

Nous allons voir à l'aide d'un composant tout simple comment intégrer des ressources à un composant.

Pour cet exemple, nous allons créer un bouton qui sera composé de deux images : une pour sa position normale et l'autre pour sa position enfoncée. Ces deux images seront intégrées dans des ressources qui seront elles-mêmes intégrées au composant. Il n'y aura donc plus besoin de s'en préoccuper à l'utilisation du composant.
L'utilisation de ressources images pour dessiner un bouton à un avantage indéniable, c'est que vous n'êtes limité que par votre talent artistique.



Création du composant :

Avant de coder notre composant, créons tout d'abord les deux images à l'aide du logiciel de notre choix. Elle doivent avoir des dimensions identiques et être sauvegardées au format bmp dans le même dossier que les fichiers sources. Pour l'exemple ce sera : "ImgBtB.bmp" pour la position enfoncée et "ImgBtH.bmp" pour la position normale.
Il va nous falloir aussi créer un fichier ressource, qui sera compilé en même temps que le composant. Pour cela nous créons d'abord un fichier script de ressources que nous nommerons "ImgBt.rc" dont voici le contenu :


Fichier "ImgBt.rc" :
BTHAUT BITMAP ImgBtH.bmp
BTBAS BITMAP ImgBtB.bmp

Avant de passer sur les détails de la compilation, voyons le code de ce composant :

Fichier "ImgBtn.h" :

#ifndef ImgBtnH
#define ImgBtnH
//---------------------------------------------------------------------------
#include <SysUtils.hpp>
#include <Controls.hpp>
#include <Classes.hpp>
#include <Forms.hpp>
//---------------------------------------------------------------------------
class PACKAGE TImgBtn : public TGraphicControl
{
private:
        bool FApp;
        Graphics::TBitmap *BpH, *BpB;
        DYNAMIC void __fastcall MouseDown(TMouseButton Button,
                                                TShiftState Shift,int X, int Y);
        DYNAMIC void __fastcall MouseUp(TMouseButton Button,
                                                TShiftState Shift,int X, int Y);
protected:
        void __fastcall Paint();
public:
        __fastcall TImgBtn(TComponent* Owner);
        virtual __fastcall ~TImgBtn();
__published:
        __property OnClick;
};
//---------------------------------------------------------------------------
#endif

Dans le header, rien de particulier, si ce n'est : la déclaration des deux pointeurs sur nos deux images et une variable booléenne FApp qui nous indiquera si le bouton est enfoncé ou non.




Fichier "ImgBtn.cpp"

#include <vcl.h>
#pragma hdrstop

#include "ImgBtn.h"

#pragma resource "ImgBt.res"
#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(TImgBtn *)
{
        new TImgBtn(NULL);
}
//---------------------------------------------------------------------------
__fastcall TImgBtn::TImgBtn(TComponent* Owner) : TGraphicControl(Owner)
{
        BpH = new Graphics::TBitmap();
        BpH->LoadFromResourceName((int)HInstance, "BTHAUT");
        BpB = new Graphics::TBitmap();
        BpB->LoadFromResourceName((int)HInstance, "BTBAS");
        Width = BpH->Width;
        Height = BpH->Height;
        BpH->Transparent = true;
        BpB->Transparent = true;
}
//---------------------------------------------------------------------------
__fastcall TImgBtn::~TImgBtn()
{
        delete BpH;
        delete BpB;
}
//---------------------------------------------------------------------------
void __fastcall TImgBtn::Paint()
{
        if(FApp==false) Canvas->Draw(0, 0,BpH);
        else   Canvas->Draw(0, 0,BpB);
}
//---------------------------------------------------------------------------
void __fastcall TImgBtn::MouseDown(TMouseButton Button,
                                                TShiftState Shift,int X, int Y)
{
        FApp=true;
        Invalidate();
        TGraphicControl::MouseDown(Button,Shift,X,Y);
}
//---------------------------------------------------------------------------
void __fastcall TImgBtn::MouseUp(TMouseButton Button,
                                                TShiftState Shift,int X, int Y)
{
        FApp=false;
        Invalidate();
        TGraphicControl::MouseUp(Button,Shift,X,Y);
}
//---------------------------------------------------------------------------
namespace Imgbtn
{
        void __fastcall PACKAGE Register()
        {
                 TComponentClass classes[1] = {__classid(TImgBtn)};
                 RegisterComponents("MesCompo", classes, 0);
        }
}

Passons au fichier principal "ImgBtn.cpp" où, comme vous pouvez le remarquer, une grande partie du code qui nous intéresse se trouve dans le constructeur. Nous y créons nos deux images que nous remplissons depuis les ressources à l'aide de la méthode LoadFromResourceName de chaque image. Nous affecterons les dimensions du composant avec les dimensions de l'une des images, (rappelons-nous qu'elles doivent avoir les mêmes dimensions) et nous positionnerons leurs propriétés Transparent à true afin de rendre leurs bords transparents. (Ici c'est la couleur du pixel inférieur gauche de l'image bitmap qui donne la couleur de transparence, voir propriété TransparentMode dans l'aide de BCB.)
Nous redéfinissons les méthodes MouseDown et MouseUp afin de déclencher l'affichage du composant avec la bonne image par l'affectation de FApp avant l'appel de la méthode Invalidate.
Dans la méthode Paint, nous dessinons tout simplement la bonne image en fonction de la valeur de FApp.
Et bien sûr n'oublions pas la destruction des bitmaps dans le destructeur.

Compilation :

Pour compiler ce composant, il faudra bien sûr ajouter son fichier source au paquet comme expliqué au chapitre 1, mais il faudra aussi ajouter le fichier script de ressources "ImgBt.rc" à ce même paquet afin qu'il soit, lui aussi, compilé par le compilateur de ressources. Sa compilation créera un fichier nommé "ImgBt.res", qui lui, devra être liée au composant. Ceci étant demandé par la directive #pragma resource qui se trouve dans le fichier "ImgBtn.cpp".

#pragma resource "ImgBt.res"

Comme vous avez pu le constater, il n'est pas très compliqué d'intégrer des ressources dans un composant C++ Builder.



A bientôt pour la suite,
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