Transformer une application avec Form en application console

Version imprimable

Salut à tous,
je suis entrain "d'étudier" un petit programme qui interagis avec les memory stick USB. Je me suis basé sur une source en application gui, avec la form visible etc.
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 unit Unit1; interface uses Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs, Shellapi; type PDEV_BROADCAST_HDR = ^TDEV_BROADCAST_HDR; TDEV_BROADCAST_HDR = packed record dbch_size : DWORD; dbch_devicetype : DWORD; dbch_reserved : DWORD; end; PDEV_BROADCAST_VOLUME = ^TDEV_BROADCAST_VOLUME; TDEV_BROADCAST_VOLUME = packed record dbcv_size : DWORD; dbcv_devicetype : DWORD; dbcv_reserved : DWORD; dbcv_unitmask : DWORD; dbcv_flags : WORD; end; type TForm1 = class(TForm) private { Private declarations } procedure WMDeviceChange(var Msg: TMessage); message WM_DEVICECHANGE; public { Public declarations } end; var Form1: TForm1; implementation {$R *.dfm} procedure TForm1.WMDeviceChange(var Msg: TMessage); var dletter: string; begin //CODE end; end.
J'ai ensuite voulu convertir mon code en application console pour 2 raisons: la taille de l'executable et le fait que je puisse le faire tourner en daemon.
Le probleme, c'est que je vois pas comment trouver une équivalence pour TForm1.WMDeviceChange (qui lui "attend" l'activité USB). QQ1 aurait une petite idee ? (J'avais essayer Application.WMDeviceChange mais ca marche pas ^^)

Merci

edit: N'y a t il pas un rapport avec les classes?

Implémente un gestionnaire d'événement Application.OnMessage (tu peux associer à une méthode de classe) et d'attendre le Message WM_DEVICECHANGE ... genre
Code:

1 2 3 4 5 6 7 8 9 10 11 12 class procedure TApplicationRunTimeTool.MessageEventHandler(var Msg: TMsg; var Handled: Boolean); var Message: TMessage; begin if Msg.Message = WM_DEVICECHANGE then begin Message.Msg := Msg; Message.WParam := WParam; Message.LParam := LParam; Handled := ClasseToto.WMDeviceChange(Message); end; end;
Sinon, tu peux très bien mettre la fenêtre en "notify" à la place d'une fenêtre normale ...

25/03/2008, 16h32
Paul TOTH

regarde AllocateHWnd(), ça devrais fonctionner.

Citation:
Envoyé par ShaiLeTroll
Implémente un gestionnaire d'événement Application.OnMessage (tu peux associer à une méthode de classe) et d'attendre le Message WM_DEVICECHANGE ... genre
Code:

1 2 3 4 5 6 7 8 9 10 11 12 class procedure TApplicationRunTimeTool.MessageEventHandler(var Msg: TMsg; var Handled: Boolean); var Message: TMessage; begin if Msg.Message = WM_DEVICECHANGE then begin Message.Msg := Msg; Message.WParam := WParam; Message.LParam := LParam; Handled := ClasseToto.WMDeviceChange(Message); end; end;
Sinon, tu peux très bien mettre la fenêtre en "notify" à la place d'une fenêtre normale ...
Citation:

Envoyé par Paul TOTH

regarde AllocateHWnd(), ça devrais fonctionner.

Si c'etait possible d'expliciter un peu, je suis débutant donc je comprends pas tres bien.

@ShaiLeTroll>Pourquoi class devant la proc ? Et quesqui va appeler cette procedure ? D'ou vont sortir les paramettre pour cette derniere ?

@Paul TOTH> J'ai lu l'aide pour AllocateHWnd() mais j'ai pas tres bien compris l'utilisation.
(Pour ceux qui lirons ce thread plus tard et dans le meme cas que moi:

Citation:

Creates a window that implements a specified window procedure.

Unit

Classes

Category

Windows controls utilities

Delphi syntax:

function AllocateHWnd(Method: TWndMethod): HWND;

C++ syntax:

extern PACKAGE HWND __fastcall AllocateHWnd(Controls::TWndMethod Method);

Description

Call AllocateHWnd to create a window that is not associated with a windowed control. Typically, this method is used to create non-visual windows that respond to messages but that do not appear in the user interface. For example, the TTimer component uses this method to create a window that responds to timer messages from Windows.

The Method parameter specifies the window procedure that the generated window uses to respond to messages.

AllocateHWnd returns the handle of the newly created window.

Note: Use the DeallocateHWnd procedure to free windows that are created using AllocateHWnd.

Citation:

Unit

Classes

Delphi syntax:

type TWndMethod = procedure(var Message: TMessage) of object;

C++ syntax:

typedef void __fastcall (__closure *TWndMethod)(Messages::TMessage &Message);

Description

Each Window has a message procedure that responds to calls from Windows. These calls can originate from Windows (such as paint messages), from user actions (such as mouse messages), or from your messages that you send in your own code.

TWndMethod is the type for VCL-based message procedures. Message procedures of this type can be assigned to controls using the WindowProc method. In addition, a window that implements this procedure but which is not associated with a control can be created using the AllocateHWnd function.

The Message parameter encapsulates the message to which the procedure responds. It contains fields for the incoming message parameters and a result field that holds the return value.

En tous cas, merci pour vos réponses, en attendant de plus amples info, je vais continuer mes recherches

bon je ne te fais pas un copier/coller de l'aide en ligne Delphi 6 version française...mais je vais te donner un petit peu plus d'explication :)

AllocateHWnd est une fonction de l'unité Classes qui alloue automatiquement une fenêtre Windows (HWnd) à laquelle il associe un gestionnaire de message qui se charge d'invoquer la méthode donnée en paramètre lors de la réception d'un message (ouf !)

donc :
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 uses Classes; type TMonObjet=class private fHWnd:THandle; procedure OnMessage(var Message:TMessage); public constructor Create; Destructor Destroy; override; end; constructor TMonObjet.Create; begin inherited; fHWnd:=AllocateHWnd(OnMessage); end; destructor TMonObjet.Destroy; begin DesallocateHWnd(fHWnd); inherited; end; procedure TMonObjet.OnMessage(var Message:TMessage); begin with Message do begin case Msg of ... // gestion des messages ... // réponse (Message.Result) par défaut else Result := DefWindowProc(fHWnd, Msg, wParam, lParam); end; end;
dans ton cas c'est un case WM_DEVICECHANGE...

MAIS, car il y a un mais :) les messages en sont traités QUE lorsque l'application le demande...Application.ProcessMessages dans le cas d'une application graphique...c'est fait automatiquement par Application.Run qui est le coeur d'une application GUI...tout ce que l'on code sous Delphi n'intervient que dans le cas d'un message justement :)

ceci dit, il arrive bien un moment où ton appli "console" n'a plus rien à faire non ? et bien à ce moment là il va falloir boucler sur la gestion de messages...ou partir dans la notion multithread.

finalement...tu as peut-être intéret de faire une application GUI avec une fenêtre non visible ^^

J'etait a peu pres dans c eaux la aussi mais bon, c du copier/coller de site, et je capte vraiment pas grand chose ^^

Voila mon code en gros:

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
program usb;
 
{$APPTYPE CONSOLE}
 
uses
  Windows,
  Messages,
  SysUtils,
  Classes,
  Shellapi;
 
type
 
 PDEV_BROADCAST_HDR = ^TDEV_BROADCAST_HDR;
 TDEV_BROADCAST_HDR = packed record
   dbch_size : DWORD;
   dbch_devicetype : DWORD;
   dbch_reserved : DWORD;
  end;
 
  PDEV_BROADCAST_VOLUME = ^TDEV_BROADCAST_VOLUME;
  TDEV_BROADCAST_VOLUME = packed record
   dbcv_size : DWORD;
   dbcv_devicetype : DWORD;
   dbcv_reserved : DWORD;
   dbcv_unitmask : DWORD;
   dbcv_flags : WORD;
  end;
 
type
  TMyClass = class(TComponent)
  private
    fHWnd: HWND;
  protected
    procedure WMDeviceChange(var Msg: TMessage);
  public
    constructor Create;
    destructor Destroy; override;
end;
 
constructor TMyClass.Create;
begin
  fHWnd := AllocateHWnd(WMDeviceChange);
end;
 
destructor TMyClass.Destroy;
begin
  DeallocateHWnd(fHWnd);
  inherited Destroy;
end;
 
procedure TMyClass.WMDeviceChange(var Msg: TMessage);
var dletter: string;
begin
  if Msg.Msg = WM_DeviceChange then
  begin
  if Msg.wParam = $8000 then
  begin
  if PDEV_BROADCAST_HDR(Msg.LParam)^.dbch_devicetype = 2 then
  begin
  if PDEV_BROADCAST_VOLUME(Msg.LParam)^.dbcv_flags = 0 then
  begin
    //CODE...
  end;
  end;
  end;
  end;
end;
 
begin
  TMyClass.Create;
  readln;
end.

mais ca fait rien :P
A mon humble avis, je m'y prends mal ^^

25/03/2008, 17h44
Booster2ooo

En tapant {$APPTYPE CONSOLE} AllocateHWnd( sur google, je tombe sur ca:
http://coding.derkeiler.com/Archive/...4-11/1761.html

Je pense que j'ai une partie de réponse

c'est ce que je t'explique juste avant

entre ton create et ton ReadLn il manque la boucle
Code:

1 2 3 4 5 6 7 while PeekMessage(Msg, 0, 0, 0, PM_REMOVE) do begin if Msg.Message = WM_QUIT then break; TranslateMessage(Msg); DispatchMessage(Msg); end;

Ok merci, je suis arriver a ceci, et ca 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
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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
program usb;
 
{$APPTYPE CONSOLE}
 
uses
  Windows,
  Messages,
  SysUtils,
  Classes,
  Shellapi;
 
type
 
 PDEV_BROADCAST_HDR = ^TDEV_BROADCAST_HDR;
 TDEV_BROADCAST_HDR = packed record
   dbch_size : DWORD;
   dbch_devicetype : DWORD;
   dbch_reserved : DWORD;
  end;
 
  PDEV_BROADCAST_VOLUME = ^TDEV_BROADCAST_VOLUME;
  TDEV_BROADCAST_VOLUME = packed record
   dbcv_size : DWORD;
   dbcv_devicetype : DWORD;
   dbcv_reserved : DWORD;
   dbcv_unitmask : DWORD;
   dbcv_flags : WORD;
  end;
 
type
  TMyClass = class(TComponent)
  private
    fHWnd: HWND;
    Closing: boolean;
    procedure WMDeviceChange(var Msg: TMessage);
  public
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
    procedure run;
end;
 
var Application: TMyClass;
 
{ TMyClass }
 
constructor TMyClass.Create;
begin
  inherited;
  Closing := false;
  fHWnd := AllocateHWnd(WMDeviceChange);
end;
 
destructor TMyClass.Destroy;
begin
  DeallocateHWnd(fHWnd);
  inherited;
end;
 
procedure TMyClass.WMDeviceChange(var Msg: TMessage);
var dletter: string;
begin
  if Msg.Msg = WM_Quit then Closing := true else
  if Msg.Msg = WM_DeviceChange then
  begin
  if Msg.wParam = $8000 then
  begin
  if PDEV_BROADCAST_HDR(Msg.LParam)^.dbch_devicetype = 2 then
  begin
  if PDEV_BROADCAST_VOLUME(Msg.LParam)^.dbcv_flags = 0 then
  begin
    //CODE
  end;
  end;
  end;
  end;
end;
 
procedure TMyClass.run;
var
  Msg: TMsg;
begin
  while not (Closing) do
  begin
    if PeekMessage(Msg, 0, 0, 0, pm_Remove) then
    begin
      if Msg.Message = wm_Quit then
        Exit;
      TranslateMessage(Msg);
      DispatchMessage(Msg);
    end
    else
      WaitMessage;
  end;
end;
 
begin
  Application := TMyClass.Create(nil);
  Application.run;
  Application.Free;
  readln;
end.

Merci pour votre aide précieuse :D