Composant graphique : clignotement génant des bmp

Version imprimable

Salut à tous,

J'ai créé un composant graphique pour mon utilisation personnelle à l'aide de ce tuto : http://chgi.developpez.com/compo9/

Ce composant représente un voyant avec trois positions et contient donc 3 images bmp, qui changent en fonction d'une propriété.

Mon souci est que ce composant clignote très rapidement à une intervalle de temps aléatoire, càd pendant quelques millisecondes il disparait puis réapparait, même en mode édition de la form. C'est sûrement dû à un rafraichissement des bmp sur la form.
Ce problème est assez génant quand il y a plusieurs de ce composant sur une form car ces clignotements attirent l'oeil, j'aimerais donc savoir si il n'y a pas une solution pour éviter ca. :roll:

Voici un extrait du code du composant :
le timer sert à éviter d'appeler la méthode "repaint" après avoir changer la propriété "position". Si je ne met pas ce timer le clignotement n'est plus visible
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 __fastcall TLed3Positions::TLed3Positions(TComponent* Owner) : TGraphicControl(Owner) { l_off = new Graphics::TBitmap(); l_off->LoadFromResourceName((int)HInstance, "LED3ETATOFF"); l_on = new Graphics::TBitmap(); l_on->LoadFromResourceName((int)HInstance, "LED3ETATVERT"); l_alarme = new Graphics::TBitmap(); l_alarme->LoadFromResourceName((int)HInstance, "LED3ETATROUGE"); Width = l_off->Width; Height = l_off->Height; l_off->Transparent = false; l_on->Transparent = false; l_alarme->Transparent = false; allume = 0; Timer1 = new TTimer(NULL); Timer1->Interval = 200; Timer1->OnTimer = Tempo; } //--------------------------------------------------------------------------- __fastcall TLed3Positions::~TLed3Positions() { delete l_off; delete l_on; delete l_alarme; delete Timer1; } //--------------------------------------------------------------------------- void __fastcall TLed3Positions::Paint() { allume = Fmode; if(allume==0) Canvas->Draw(0, 0,l_off); else if(allume==1) Canvas->Draw(0, 0,l_on); else Canvas->Draw(0, 0,l_alarme); Canvas->Refresh(); } //--------------------------------------------------------------------------- // Rafraichissement du dessin selon le tempo. void __fastcall TLed3Positions::Tempo(TObject* Sender) { Invalidate(); } //--------------------------------------------------------------------------- namespace Led3positions { void __fastcall PACKAGE Register() { TComponentClass classes[1] = {__classid(TLed3Positions)}; RegisterComponents("Leds", classes, 0); } } //---------------------------------------------------------------------------
Une idée ? Merci
Marcootz

Salut !

A titre perso, j'aurais été un peu plus loin dans le développement en utilisant un tableau :

Code:

1
2
3
4
 
private :
int On; //flip-flop
Graphics::TBitmap *Cycle[2];

Dans le Setter de la propriété qui fixe l'état (froid, normal, chaud) j'aurais fait comme ça :
(Blue, Green ... sont les bitmaps):

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
void __fastcall jLed::SetStatus(int Value)
{
if(FStatus != Value)
    {
    FStatus = Value;
    switch(Value)
        {
        case 0 :
        //Blue ne clignote pas
            Cycle[0] = Blue;
            Cycle[1] = Blue;
        break;
        case 1 :
        //Green clignote lentement
            Cycle[0] = Green;
            Cycle[1] = Lime;
            Timer->Interval = 400;
            break;
        case 2 :
        //Red clignote rapidement
            Cycle[0] = Maroon;
            Cycle[1] = Red;
            Timer->Interval = 200;
            break;
        }
    Repaint();
    }
}

La Paint devient :

Code:

1
2
3
4
5
6
7
8
 
void __fastcall jLed::Paint()
{
if((Cycle[0] != NULL) && (Cycle[1] != NULL))
    {
    Canvas->Draw(0,0, Cycle[On]);
    }
}

La OnTimer devient :

Code:

1
2
3
4
5
6
 
void __fastcall jLed::TimeOut(TObject *Sender)
{
On = On ^ 1; //Flip-flop basique
Repaint();
}

A ce stade, chez moi ça ne scintille pas (et pourtant mon ordi... ) !

A plus !

05/03/2008, 09h34
marcootz

Salut henderson,
Merci pour ta réponse, je vais essayer ta méthode. J'ai juste une petite question : Comment est appelé la méthode "SetStatus" ? Est ce une fonction système ou alors il faut l'appeler dans la timer ??
;)

J'ai souvent eu ce genre de problème avec les composants dérivés de TGraphicControl.

C'est pour cela qu'il faut utiliser un composant dérivé de TCustomControl pour éviter les scintillements :
- DoubleBuffered = true permet d'éviter les scintillements (DoubleBuffered : Détermine si l'image du contrôle est restituée directement dans la fenêtre ou si elle est d'abord dessinée dans un bitmap en mémoire.)
- Utiliser aussi la méthode Invalidate() plutôt que Repaint().

Exemple d'un composant PaintBox qui ne scintille jamais.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class PACKAGE TBufferedPaintBox : public TCustomControl
{
private:
    TNotifyEvent FOnPaint;
protected:
    virtual void __fastcall Paint(void);
public:
    __fastcall TBufferedPaintBox(TComponent* Owner);
__published:
    __property Align;
    __property Canvas;
    __property OnClick;
    __property OnMouseDown;
    __property OnMouseMove;
    __property OnMouseUp;
    __property OnResize;
    __property TNotifyEvent OnPaint =  {read=FOnPaint, write=FOnPaint};
};

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include "BufferedPaintBox.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(TBufferedPaintBox *)
{
    new TBufferedPaintBox(NULL);
}
//---------------------------------------------------------------------------
__fastcall TBufferedPaintBox::TBufferedPaintBox(TComponent* Owner)
    : TCustomControl(Owner)
{
    DoubleBuffered = true;
    ControlStyle = ControlStyle << csAcceptsControls;
}
//---------------------------------------------------------------------------
namespace Bufferedpaintbox
{
    void __fastcall PACKAGE Register()
    {
         TComponentClass classes[1] = {__classid(TBufferedPaintBox)};
         RegisterComponents("MyComponents", classes, 0);
    }
}
//---------------------------------------------------------------------------
void __fastcall TBufferedPaintBox::Paint(void)
{
    if (FOnPaint) FOnPaint(this);
}

05/03/2008, 12h06
marcootz

C'est bon à savoir !
Merci slylafone :D

Salut !

SetStatus est le Setter de la propriété Status, (méthode liée à l'écriture).

Si l'utilisateur écrit :
Code:

1 2 Led->Status = 1;
Après compilation, c'est exécuté comme ceci :
Code:

1 2 Led->SetStatus(1);
Donc dans la classe, on organise de cette manière là :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 private : int FStatus; protected : void __fastcall SetStatus(int Value); public : //... __published : __property int Status={read=FStatus, write=SetStatus};
Comme chez moi cette classe est volante (je n'en ai pas fait un composant pour la palette), cette propriété est seulement public.
De ton coté, elle devrait être published pour la faire apparaître dans l'inspecteur d'objet.

Il faudrait tester dans cette méthode (SetStatus) si Value correspond bien à celles qui sont attendues :
Code:

1 2 3 if((Value >= 0) && (Value < 3) && (Value != FStatus)) ...
On peut aussi utiliser une énumération (enum) mais dans ce cas, il faudrait changer le type de la propriété...

A plus !

05/03/2008, 16h49
marcootz

Merci bcp pour tes précisions henderson, ca marche impec.
Bye

:king: