Discussion :

[bubulemaster]

Bonjour,

je souhaite utiliser les timer dans une application console. J'ai lu qu'il fallait utiliser SetTimer et KillTimer.
On ne peut vraiment pas utiliser le composant TTimer ?
Cela m'étonne car si je n'affecte pas de parent à timer dans une application fenêtre, ça fonctionne :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
    Timer2 := TTimer.Create(nil) ;
    Timer2.Interval := 1000 ;
    Timer2.OnTimer := Timer.TimerEnd ;
    Timer2.Enabled := true ;

[pitango]

Bonjour,

Est ce vraiment une application console ?

Où est ce simplement une application "cachée" ?


A+

[sjrd]

Je ne vois pas ce qui pourrais t'empêcher d'utiliser un TTimer comme tu le proposes, en le créant avec nil en proprio.

[bubulemaster]

C'est bien une application console et moi non plus je ne vois pas ce qui empêche d'utiliser TTimer pourtant ça ne fonctionne pas. Etrange.

[sjrd]

C'est bien une application console et moi non plus je ne vois pas ce qui empêche d'utiliser TTimer pourtant ça ne fonctionne pas. Etrange.

Peux-tu montrer un peu le code de contexte, qu'on puisse trouver ce qui ne va pas

[bubulemaster]

J'ai une classe contenant le timer :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
unit MaxExecutiontimer;
 
interface
 
uses
  Classes, Functions, ExtCtrls, UnitMessages ;
 
type
  TMaxExecutiontimer = class
  private
    { Déclarations privées }
    Timer : TTimer ;
  protected
    { Déclarations protégées }
  public
    { Déclarations publiques }
    procedure TimerEnd(Sender: TObject);    
    procedure Enable(state : Boolean) ;
    constructor Create(TimeOfTheTime : Integer) ;
    destructor Free ;    
  published
    { Déclarations publiées }
  end;
 
implementation
 
{*******************************************************************************
 * Fonction appelée lorsque le timer est écoulé
 ******************************************************************************}
procedure TMaxExecutiontimer.TimerEnd(Sender: TObject);
begin
    Timer.Enabled := False ;
    ErrorMsg(sTimeIsEnd) ;
    FinishProgramm ;
    Halt ;
end ;
 
{******************************************************************************
 * Consructeur
 ******************************************************************************}
constructor TMaxExecutiontimer.Create(TimeOfTheTime : Integer) ;
begin
    inherited Create();
 
    Timer := TTimer.Create(nil) ;
    Timer.Interval := TimeOfTheTime ;
    Timer.OnTimer := TimerEnd ;
    Timer.Enabled := False ;
end ;
 
{******************************************************************************
 * Destructeur
 ******************************************************************************}
destructor TMaxExecutiontimer.Free ;
begin
    Timer.Free ;
end ;
 
procedure TMaxExecutiontimer.Enable(state : Boolean) ;
begin
    Timer.Enabled := State
 end ;
 
end.

et le code dans l'application :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
MaxExecutiontimerVar := TMaxExecutiontimer.Create(ElapseTime * 1000) ;
MaxExecutiontimerVar.Enable(ElapseTime > 0) ;

Je viens de modifier la classe pour utiliser SetTimer et KillTimer mais ça ne fonctionne pas :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
76
77
78
79
80
81
82
83
84
85
86
unit MaxExecutiontimer;
 
interface
 
uses
  Classes, Functions, ExtCtrls, UnitMessages, UnitOS, Windows, SysUtils ;
 
type
  TMaxExecutiontimer = class
  private
    { Déclarations privées }
    //Timer : TTimer ;
    Intervale : Cardinal ;
    Timer : Cardinal ;
  protected
    { Déclarations protégées }
  public
    { Déclarations publiques }
    procedure TimerEnd ;    
    procedure Enable(state : Boolean) ;
    constructor Create(TimeOfTheTime : Cardinal) ;
    destructor Free ;    
  published
    { Déclarations publiées }
  end;
 
  procedure TimerProc(hWnd: HWND; uMsg: UINT; idEvent: UINT; dwTime: DWORD); stdcall;
 
implementation
 
Const NumTimer = 1 ;
 
{*******************************************************************************
 * Fonction appelée lorsque le timer est écoulé
 ******************************************************************************}
procedure TMaxExecutiontimer.TimerEnd ;
begin
    OsKillTimer(timer) ;
    //Timer.Enabled := False ;
    ErrorMsg(sTimeIsEnd) ;
    FinishProgramm ;
    Halt ;
end ;
 
procedure TimerProc(hWnd: HWND; uMsg: UINT; idEvent: UINT; dwTime: DWORD); stdcall;
begin
    KillTimer(NumTimer) ;
    writeln('erotyeoryot') ;
end;
 
{******************************************************************************
 * Consructeur
 ******************************************************************************}
constructor TMaxExecutiontimer.Create(TimeOfTheTime : Cardinal) ;
begin
    inherited Create();
    Intervale := TimeOfTheTime ;
    Timer := NumTimer ;
    {
    Timer := TTimer.Create(nil) ;
    Timer.Interval := TimeOfTheTime ;
    Timer.OnTimer := TimerEnd ;
    Timer.Enabled := False ;
    }
end ;
 
{******************************************************************************
 * Destructeur
 ******************************************************************************}
destructor TMaxExecutiontimer.Free ;
begin
    //Timer.Free ;
    KillTimer(timer)
end ;
 
procedure TMaxExecutiontimer.Enable(state : Boolean) ;
begin
    //Timer.Enabled := State
    if state = true
    then
        SetTimer(0, timer, Intervale, @TimerProc) //TimerEnd)
    else
        KillTimer(0, timer) ;
end ;
 
end.

A prioris il faut absolument un Handle.

[J-P-B]

Salut

La gestion des timer est basée sur des messages que windows va envoyer à un handle (le WM_TIMER en l'occurrence).
Dans une application console, tu n'as pas de fenêtre, ni de TApplication, donc pas de handle, et pas de pompe à message (c'est la boucle infinie qui traite les messages en attente du handle, et donc le WM_TIMER)

Tu peux utiliser le TApplication : tu fais application.initialize, ensuite tu lances application.run pour amorcer la pompe. Elle se terminera avec un application.terminate.

[sjrd]

Ah oui, c'était ça qui manquait : le traitement des messages WM_TIMER

Alors il vaut peut-être mieux utiliser un thread qui va uniquement faire Sleep(Interval); TimerEnd;

Au fait, le destructeur ne s'appelle pas Free ! C'est Destroy, et il se déclare comme suit :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
destructor Destroy; override;
 
destructor TMaClasse.Destroy;
begin
  ...
  inherited;
end;

Et il ne faut surtout pas oublier le inherited.

En revanche, on utilise bien Free pour demander la destruction d'un objet. Free appelle Destroy, pour autant que celui-ci soit bien override.