comment un label s'arrete de clignoter

Si tu clique sur le bord d'une ligne tu peut mettre ce qu'on appelle un point d'arrêt, en fait ton code s'exécute, et s'arrête dès que tu passe sur ce point d'arrêt. A ce moment la, tu peut voir ce que contiennent tes variables, voir si leur contenu est donc correcte, si il passe correctement dans les if, dans les boucle, ...
Pour mettre un point d'arrêt tu peut faire aussi un clique droit sur la ligne de code et puis cliquer sur "basculer le point d'arrêt".
Après il faut faire attention au fait que les point d'arret ne son actif que sur certaine ligne de code.

Bonjour,

De ce que j'ai compris, le label clignotant est sur ta fom3 et la variable compteur est sur ta form2.
Tu devrais créer la variable sur la form3 quitte à la créer en public pour pouvoir l'initialiser dans form2.

Je pense qu'il y a une erreur a ce niveau.

Bon courage :)

Une autre solution (qui me semble être la bonne) c'est de créer un nouveau projet avec simplement un label clignotant.

Ça te prendra 5 à 10 minutes, et ça te permettra de bien comprendre le fonctionnement.

Ensuite il te sera plus facile de l'incorporer à ton projet puisque tu aura exactement compris comment faire.

Parce que comme le dis Poilou, si ton projet est déjà conséquent l'erreur peut venir de plein d'endroit différents.

Une autre conseil : Renomme tes composants !!!!! C'est fondamentale si tu veux t'y retrouver. Parce que ce balader avec des Form1, Form3, Label1, Label38, c'est juste indigeste. C'est important d'avoir un code clair et facilement compréhensible.

Salut !

Sans doute que l'on aurait aussi gagné en simplicité si on avait développé une classe dérivée de TLabel dotée de son propre timer et assurant tout le mécanisme.
Certes, cela représente du code supplémentaire... mais développer peut aussi être de l'amusement !
Voici, ce qui n'est qu'un exemple et qui malheureusement fonctionne :

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
 
class jLabel : public TLabel
{
private :
TTimer *Timer;
int FInterval;
int FCount;
int Counter;
 
protected:
    void __fastcall SetInterval(int Value);
    void __fastcall SetCount(int Value);
    void __fastcall Blink(TObject *Sender);
 
public :
 
    __fastcall jLabel(TComponent *AOwner);
    __fastcall ~jLabel();
// Pour lancer le processus :
    // - Avec les valeurs en cours
    void __fastcall Start();
    // - En fixant un texte
    void __fastcall Start(AnsiString ACaption);
    // - En modifiant tous les paramètres du processus
    void __fastcall Start(AnsiString ACaption, int AInterval, int ACount);
// Pour arrêter le processus avant terme :
    void __fastcall Stop();
 
// Les propriétés supplémentaires pour le processus
__property int Interval={read=FInterval, write=SetInterval};
__property int Count={read=FCount, write=SetCount};
};

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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
 
__fastcall jLabel::jLabel(TComponent *AOwner)
    : TLabel(AOwner)
{
if(AOwner->InheritsFrom(__classid(TWinControl)))
    {
    Parent = (TWinControl*)AOwner;
    }
 
Timer = new TTimer(this);
Timer->OnTimer = Blink;
Timer->Enabled = false;
Visible = false;
 
FCount = 5;
Timer->Interval = 300;
}
 
__fastcall jLabel::~jLabel()
{
delete Timer;
}
 
void __fastcall jLabel::Start()
{
Visible = true;
Counter = FCount;
Timer->Enabled = true;
}
 
void __fastcall jLabel::Start(AnsiString ACaption)
{
Caption = ACaption;
Start();
}
 
void __fastcall jLabel::Start(AnsiString ACaption, int AInterval, int ACount)
{
Caption = ACaption;
// des valeurs négatives n'auront aucun effet (donc le contenu ne sera pas modifié)
if(AInterval >= 0) Timer->Interval = AInterval;
Count = ACount;
Start();
}
 
void __fastcall jLabel::Stop()
{
Visible = false;
Timer->Enabled = false;
}
 
void __fastcall jLabel::Blink(TObject* Sender)
{
if(Counter >= 0)
    {
    Counter--;
    Visible = !Visible;
    }
else
    {
    Timer->Enabled = false;
    Visible = false;
    }
}
 
 
void __fastcall jLabel::SetInterval(int Value)
{
Timer->Interval = Value;
}
 
void __fastcall jLabel::SetCount(int Value)
{
if(Value > 0) FCount = Value;
}

Cette classe peut être rédigée dans une autre unité dont il suffira d'inclure le header dans l'unité qui en fera usage.
Comme il s'agit ici d'une simple classe (et non d'un composant) on va donc devoir prendre en charge l'instanciation :

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
 
//Ici un pointeur en global.... ou comme propriété d'une form
jLabel *BlinkingLabel;
 
 
//-- Le constructeur de la form
__fastcall TForm1::TForm1(TComponent* Owner)
    : TForm(Owner)
{
//On instancie
BlinkingLabel = new jLabel(this);
//On positionne
BlinkingLabel->SetBounds(20,20,80,23);
//On initialise... quoique anecdotique compte tenu que... 
BlinkingLabel->Caption = "Coucou !";
}
 
//-- Un événement 
void __fastcall TForm1::SpeedButton1Click(TObject *Sender)
{
//...ou quelque part ailleurs dans le code...
BlinkingLabel->Start("Hello World");
}
//--

Bien entendu... chacun fait bien comme il veut...

A plus !

salut .merci je vais essayé