Timer en application console

Version imprimable

05/12/2007, 17h57
bubulemaster

Timer en application console
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:

1 2 3 4 Timer2 := TTimer.Create(nil) ; Timer2.Interval := 1000 ; Timer2.OnTimer := Timer.TimerEnd ; Timer2.Enabled := true ;
05/12/2007, 18h15
pitango

Bonjour,

Est ce vraiment une application console ?

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

A+
05/12/2007, 21h21
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.
05/12/2007, 21h41
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.
05/12/2007, 21h45
sjrd

Citation:

Envoyé par 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.

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

J'ai une classe contenant le timer :

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
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:

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:

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.

06/12/2007, 15h30
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.
07/12/2007, 14h22
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:

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.