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 :

BTHAUT BITMAP ImgBtH.bmp
BTBAS BITMAP ImgBtB.bmp

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

#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.