Discussion :

[Booster2ooo]

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 :

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

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

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

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

[Paul TOTH]

regarde AllocateHWnd(), ça devrais fonctionner.

[Booster2ooo]

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 :

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

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

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:

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.

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

[Paul TOTH]

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 :

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

[Booster2ooo]

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 :

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
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
A mon humble avis, je m'y prends mal ^^

[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

[Paul TOTH]

c'est ce que je t'explique juste avant

entre ton create et ton ReadLn il manque la boucle

Code :

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

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;

[Booster2ooo]

Ok merci, je suis arriver a ceci, et ca fonctionne:

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