Composant détectant l'insertion d'une clé USB

**petitprince** · 06/01/2008, 13h47

Franciser !!!!! ça va pas non ?

Moi par principe je développe toujours en anglais ...... Mais c'est ma méthode, après chacun est libre .......

Et désolé pour le "tsoGigabyte, tsoTeraByte"... Messieurs je ne veux pas créer de conflit !

**ero-sennin** · 06/01/2008, 13h51

Envoyé par petitprince

Franciser !!!!! ça va pas non ?

Moi par principe je développe toujours en anglais ...... Mais c'est ma méthode, après chacun est libre .......

Et désolé pour le "tsoGigabyte, tsoTeraByte"... Messieurs je ne veux pas créer de conflit !

Mdrr, je ne parlais pas de francisé au point de vue du programme (j'essaie de programmer également en anglais ...) C'est franciser dans le sens pouvoir expliquer comment ça fonctionne ... Et je vais surement renommer quelques variables ...

Merci pour ce coup de main

Je suis très content de ce compo (pour un premier compo, c'est pas mal

)

Encore Merci

**petitprince** · 06/01/2008, 14h03

Ce fut un plaisir de t'aider....
Je me réserve le droit d'inclure ce composant dans ma future librairie open source....... enfin si vous me l'autorisez..

**ero-sennin** · 06/01/2008, 14h10

Je n'y vois pas d'inconvénient du tout

Par contre, tu as fais une petite faute concernant les conversions ... Je remets la correction entière :

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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
unit UMedia;
 
interface
 
uses Windows, Messages, SysUtils, Classes, Forms, Dialogs,Math;
 
const
  DBT_DEVICEARRIVAL          = $8000;          // system detected a new device
  DBT_DEVICEREMOVECOMPLETE   = $8004;          // device is gone
  DBT_DEVTYP_VOLUME          = $00000002;      // device volume class
 
 
type
  PDevBroadcastHdr  = ^DEV_BROADCAST_HDR;
  PDevBroadcastHeader  = PDevBroadcastHdr;
  DEV_BROADCAST_HDR = packed record
    dbch_size: DWORD;
    dbch_devicetype: DWORD;
    dbch_reserved: DWORD;
  end;
 
  PDevBroadcastVolume =  ^DEV_BROADCAST_VOLUME;
  DEV_BROADCAST_VOLUME  =  packed record
     dbch_size: DWORD;
     dbch_devicetype: DWORD;
     dbch_reserved: DWORD;
     dbcv_unitmask: DWORD;
     dbcv_flags: WORD;
  end;
 
type
  TTypeSizeOf = (tsoByte, tsoKiloByte, tsoMegaByte, tsoGigabyte, tsoTeraByte);
 
  TMediaConnected = class(TComponent)
  private
    FDeviceLetter: Char;
    FVolName: Array[0..Max_Path]Of Char;
    FileSysName : Array[0..Max_Path]Of Char;
    FVolSerial   : DWord;
    FileMaxLen  : DWord;
    FileFlags   : DWord;
    FFreeSpace : double;
    FSize : double;
    FBusySpace: double;
    FWindowHandle: HWND;
    FOnUSBArrival: TNotifyEvent;
    FOnUSBRemove: TNotifyEvent;
    procedure WndProc(var Msg: TMessage);
  protected
    procedure WMDeviceChange(var Msg: TMessage); dynamic;
  public
    function GetSerialVolume: Cardinal;
    function GetNameVolume: String;
    function GetFreeSpace(TypeSizeReturn: TTypeSizeOf = tsoByte): Double;
    function GetBusySpace(TypeSizeReturn: TTypeSizeOf = tsoByte): Double;
    function GetSize(TypeSizeReturn: TTypeSizeOf = tsoByte): Double;
    function GetLetterMedia: Char;
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
  published
    property OnUSBArrival: TNotifyEvent read FOnUSBArrival write FOnUSBArrival;
    property OnUSBRemove: TNotifyEvent read FOnUSBRemove write FOnUSBRemove;
  end;
 
procedure Register;
 
implementation
 
procedure Register;
begin
  RegisterComponents('CompoPerso',[TMediaConnected]);
end;
 
{==============================================================================}
{                                TMediaConnected                               }
{==============================================================================}
function FormatSize(Value: Double; TypeSizeReturn: TTypeSizeOf): Double;
begin
  case TypeSizeReturn of
    tsoByte:      Result := Value;
    tsoKiloByte:  Result := Value / 1024;
    tsoMegaByte:  Result := Value / Power(1024,2);
    tsoGigabyte:  Result := Value / Power(1024,3);
    tsoTeraByte:  Result := Value / Power(1024,4);
    else
      Result := Value;
  end;
end;
//------------------------------------------------------------------------------
constructor TMediaConnected.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);
  FWindowHandle := AllocateHWnd(WndProc);
end;
//------------------------------------------------------------------------------
destructor TMediaConnected.Destroy;
begin
  DeallocateHWnd(FWindowHandle);
  inherited Destroy;
end;
//------------------------------------------------------------------------------
procedure TMediaConnected.WndProc(var Msg: TMessage);
begin
  if (Msg.Msg = WM_DEVICECHANGE) then 
  begin
    try
      WMDeviceChange(Msg);
    except
      Application.HandleException(Self);
    end;
  end
  else
    Msg.Result := DefWindowProc(FWindowHandle, Msg.Msg, Msg.wParam, Msg.lParam);
end;
//------------------------------------------------------------------------------
procedure TMediaConnected.WMDeviceChange(var Msg: TMessage);
var
  PHeader : PDevBroadcastHeader;
  PData : PDevBroadcastVolume;
  Index : Integer;
begin
  inherited;
  PHeader:=PDevBroadcastHeader(Msg.lParam);
  FDeviceLetter:=#0;
  case Msg.WParam of
    DBT_DEVICEARRIVAL :
    begin
      if (PHeader^.dbch_devicetype = DBT_DEVTYP_VOLUME) then
      begin
        PData:=PDevBroadcastVolume(Msg.lParam);
        for Index:=0 to 25 do
        if ((PData^.dbcv_unitmask shr Index) = 1) then
        begin
          FDeviceLetter:=Chr(65+Index);
          break;
        end;
          if GetVolumeInformation(PChar(FDeviceLetter+':\'),FVolName,Max_Path,@FVolSerial, FileMaxLen, FileFlags,FileSysName,Max_Path) then
          begin
            FFreeSpace:=DiskFree(Ord(FDeviceLetter)-64);
            FSize:=DiskSize(Ord(FDeviceLetter)-64);
            FBusySpace:= FSize - FFreeSpace;
          end;
      end;
      if Assigned(FOnUSBArrival) then
          FOnUSBArrival(Self);
    end;
 
    DBT_DEVICEREMOVECOMPLETE:
    begin
      if (PHeader^.dbch_devicetype = DBT_DEVTYP_VOLUME) then
      begin
        PData:=PDevBroadcastVolume(Msg.lParam);
        for Index:=0 to 25 do
        if ((PData^.dbcv_unitmask shr Index) = 1) then
        begin
          FDeviceLetter:=Chr(65+Index);
          break;
        end;
      end;
      if Assigned(FOnUSBRemove) then
          FOnUSBRemove(Self);
    end;
  end;
end;
//------------------------------------------------------------------------------
function TMediaConnected.GetSerialVolume:cardinal;
begin
  Result:=FVolSerial;
end;
//------------------------------------------------------------------------------
function TMediaConnected.GetNameVolume:string;
begin
  Result:=FVolName;
end;
//------------------------------------------------------------------------------
function TMediaConnected.GetLetterMedia:char;
begin
  Result:=FDeviceLetter;
end;
//------------------------------------------------------------------------------
function TMediaConnected.GetFreeSpace(TypeSizeReturn: TTypeSizeOf = tsoByte): Double;
begin
  result := FormatSize(FFreeSpace, TypeSizeReturn);
end;
//------------------------------------------------------------------------------
function TMediaConnected.GetBusySpace(TypeSizeReturn: TTypeSizeOf = tsoByte): Double;
begin
  result := FormatSize(FBusySpace, TypeSizeReturn);
end;
//------------------------------------------------------------------------------
function TMediaConnected.GetSize(TypeSizeReturn: TTypeSizeOf = tsoByte): Double;
begin
  result := FormatSize(FSize, TypeSizeReturn);
end;
 
end.

A+

[EDIT]

Ce serait intéressant de le proposer dans la catégorie "les sources" du forum ... Ca peut servir

**Cl@udius** · 06/01/2008, 14h27

Une petite constatation en passant...

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
unit UMedia;
type
  TTypeSizeOf = (tsoByte, tsoKiloByte, tsoMegaByte, tsoGigabyte, tsoTeraByte);
  // ... 
 
implementation
 
function FormatSize(Value: Double; TypeSizeReturn: TTypeSizeOf): Double;
begin
  case TypeSizeReturn of
    tsoByte:      Result := Value;
    tsoKiloByte:  Result := Value / 1024;
    tsoMegaByte:  Result := Value / Power(1024,2);
    tsoGigabyte:  Result := Value / Power(1024,3);
    tsoTeraByte:  Result := Value / Power(1024,4);
{  else
      Result := Value;} // Ne se produira jamais !
  end;
end;
//...

@+

**ero-sennin** · 06/01/2008, 14h30

Envoyé par Cl@udius

Une petite constatation en passant...

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
unit UMedia;
type
  TTypeSizeOf = (tsoByte, tsoKiloByte, tsoMegaByte, tsoGigabyte, tsoTeraByte);
  // ... 
 
implementation
 
function FormatSize(Value: Double; TypeSizeReturn: TTypeSizeOf): Double;
begin
  case TypeSizeReturn of
    tsoByte:      Result := Value;
    tsoKiloByte:  Result := Value / 1024;
    tsoMegaByte:  Result := Value / Power(1024,2);
    tsoGigabyte:  Result := Value / Power(1024,3);
    tsoTeraByte:  Result := Value / Power(1024,4);
{  else
      Result := Value;} // Ne se produira jamais !
  end;
end;
//...

@+

Bien vu

Merci pour cette correction

[EDIT]

On est "obligé" de mettre le else, sinon on a un avertissement du compilo disant que la valeur de retour peut être indéfini

**ero-sennin** · 06/01/2008, 16h17

Re,

J'ai ajouté la possibilité de tester si c'est un CD/DVD ou une clé de stockage (genre clé usb).

Je vous met le code ci dessous ...

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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
unit UMedia;
 
interface
 
uses Windows, Messages, SysUtils, Classes, Forms, Dialogs,Math;
 
const
  DBT_DEVICEARRIVAL          = $8000;          // system detected a new device
  DBT_DEVICEREMOVECOMPLETE   = $8004;          // device is gone
  DBT_DEVTYP_VOLUME          = $00000002;      // device volume class
 
 
type
  PDevBroadcastHdr  = ^DEV_BROADCAST_HDR;
  PDevBroadcastHeader  = PDevBroadcastHdr;
  DEV_BROADCAST_HDR = packed record
    dbch_size: DWORD;
    dbch_devicetype: DWORD;
    dbch_reserved: DWORD;
  end;
 
  PDevBroadcastVolume =  ^DEV_BROADCAST_VOLUME;
  DEV_BROADCAST_VOLUME  =  packed record
     dbch_size: DWORD;
     dbch_devicetype: DWORD;
     dbch_reserved: DWORD;
     dbcv_unitmask: DWORD;
     dbcv_flags: WORD;
  end;
 
type
  TTypeSizeOf = (tsoByte, tsoKiloByte, tsoMegaByte, tsoGigabyte, tsoTeraByte);
  TMediaType = (mtFlashDisk,mtCDandDVD,mtAll);
 
  TMediaConnected = class(TComponent)
  private
    FDeviceLetter: Char;
    FVolName: Array[0..Max_Path]Of Char;
    FileSysName : Array[0..Max_Path]Of Char;
    FVolSerial   : DWord;
    FileMaxLen  : DWord;
    FileFlags   : DWord;
    FFreeSpace : double;
    FSize : double;
    FBusySpace: double;
    FWindowHandle: HWND;
    FOnUSBArrival: TNotifyEvent;
    FOnUSBRemove: TNotifyEvent;
    MediaTypeSelected:TMediaType;
    procedure WndProc(var Msg: TMessage);
  protected
    procedure WMDeviceChange(var Msg: TMessage); dynamic;
  public
    function GetSerialVolume: Cardinal;
    function GetNameVolume: String;
    function GetFreeSpace(TypeSizeReturn: TTypeSizeOf = tsoByte): Double;
    function GetBusySpace(TypeSizeReturn: TTypeSizeOf = tsoByte): Double;
    function GetSize(TypeSizeReturn: TTypeSizeOf = tsoByte): Double;
    function GetLetterMedia: Char;
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
    procedure SetMediaType(Value:TMediaType);
  published
    property MediaType:TMediaType read MediaTypeSelected write SetMediaType;
    property OnUSBArrival: TNotifyEvent read FOnUSBArrival write FOnUSBArrival;
    property OnUSBRemove: TNotifyEvent read FOnUSBRemove write FOnUSBRemove;
  end;
 
procedure Register;
 
implementation
 
procedure Register;
begin
  RegisterComponents('CompoPerso',[TMediaConnected]);
end;
 
{==============================================================================}
{                                TMediaConnected                               }
{==============================================================================}
function FormatSize(Value: Double; TypeSizeReturn: TTypeSizeOf): Double;
begin
  case TypeSizeReturn of
    tsoByte:      Result := Value;
    tsoKiloByte:  Result := Value / 1024;
    tsoMegaByte:  Result := Value / Power(1024,2);
    tsoGigabyte:  Result := Value / Power(1024,3);
    tsoTeraByte:  Result := Value / Power(1024,4);
    else
      Result:=Value;
  end;
end;
 
procedure TMediaConnected.SetMediaType(value : TMediaType);
begin
  MediaTypeSelected:=Value;
end;
//------------------------------------------------------------------------------
constructor TMediaConnected.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);
  FWindowHandle := AllocateHWnd(WndProc);
end;
//------------------------------------------------------------------------------
destructor TMediaConnected.Destroy;
begin
  DeallocateHWnd(FWindowHandle);
  inherited Destroy;
end;
//------------------------------------------------------------------------------
procedure TMediaConnected.WndProc(var Msg: TMessage);
begin
  if (Msg.Msg = WM_DEVICECHANGE) then 
  begin
    try
      WMDeviceChange(Msg);
    except
      Application.HandleException(Self);
    end;
  end
  else
    Msg.Result := DefWindowProc(FWindowHandle, Msg.Msg, Msg.wParam, Msg.lParam);
end;
//------------------------------------------------------------------------------
procedure TMediaConnected.WMDeviceChange(var Msg: TMessage);
var
  PHeader : PDevBroadcastHeader;
  PData : PDevBroadcastVolume;
 
procedure DeviceConnected;
var
Index : Integer;
begin
  PData:=PDevBroadcastVolume(Msg.lParam);
  for Index:=0 to 25 do
  if ((PData^.dbcv_unitmask shr Index) = 1) then
  begin
    FDeviceLetter:=Chr(65+Index);
    break;
  end;
 
  if GetVolumeInformation(PChar(FDeviceLetter+':\'),FVolName,Max_Path,@FVolSerial, FileMaxLen, FileFlags,FileSysName,Max_Path) then
  begin
    FFreeSpace:=DiskFree(Ord(FDeviceLetter)-64);
    FSize:=DiskSize(Ord(FDeviceLetter)-64);
    FBusySpace:= FSize - FFreeSpace;
  end;
  if Assigned(FOnUSBArrival) then
  FOnUSBArrival(Self);
end;
procedure DeviceDisconnected;
var
Index: Integer;
begin
  PData:=PDevBroadcastVolume(Msg.lParam);
  for Index:=0 to 25 do
  if ((PData^.dbcv_unitmask shr Index) = 1) then
  begin
    FDeviceLetter:=Chr(65+Index);
    break;
  end;
  if Assigned(FOnUSBRemove) then
    FOnUSBRemove(Self);
end;
begin
  inherited;
  PHeader:=PDevBroadcastHeader(Msg.lParam);
  FDeviceLetter:=#0;
  case Msg.WParam of
    DBT_DEVICEARRIVAL :
    begin
      if (PHeader^.dbch_devicetype = DBT_DEVTYP_VOLUME) then
      begin
        case MediaTypeSelected of
          mtFlashDisk:
          begin
            if (PDevBroadcastVolume( Msg.LParam )^.dbcv_flags = 0) then
              DeviceConnected;
          end;
 
          mtCDandDVD:
          begin
            if (PDevBroadcastVolume( Msg.LParam )^.dbcv_flags = 1) then
              DeviceConnected;
          end;
 
           mtAll:DeviceConnected;
        end;
      end;
    end;
 
    DBT_DEVICEREMOVECOMPLETE:
    begin
      if (PHeader^.dbch_devicetype = DBT_DEVTYP_VOLUME) then
      begin
       case MediaTypeSelected of
          mtFlashDisk:
          begin
            if (PDevBroadcastVolume( Msg.LParam )^.dbcv_flags = 0) then
              DeviceDisconnected;
          end;
 
          mtCDandDVD:
          begin
            if (PDevBroadcastVolume( Msg.LParam )^.dbcv_flags = 1) then
              DeviceDisconnected;
          end;
 
           mtAll:DeviceDisconnected;
        end;
      end;
    end;
  end;
end;
//------------------------------------------------------------------------------
function TMediaConnected.GetSerialVolume:cardinal;
begin
  Result:=FVolSerial;
end;
//------------------------------------------------------------------------------
function TMediaConnected.GetNameVolume:string;
begin
  Result:=FVolName;
end;
//------------------------------------------------------------------------------
function TMediaConnected.GetLetterMedia:char;
begin
  Result:=FDeviceLetter;
end;
//------------------------------------------------------------------------------
function TMediaConnected.GetFreeSpace(TypeSizeReturn: TTypeSizeOf = tsoByte): Double;
begin
  result := FormatSize(FFreeSpace, TypeSizeReturn);
end;
//------------------------------------------------------------------------------
function TMediaConnected.GetBusySpace(TypeSizeReturn: TTypeSizeOf = tsoByte): Double;
begin
  result := FormatSize(FBusySpace, TypeSizeReturn);
end;
//------------------------------------------------------------------------------
function TMediaConnected.GetSize(TypeSizeReturn: TTypeSizeOf = tsoByte): Double;
begin
  result := FormatSize(FSize, TypeSizeReturn);
end;
 
end.

Si ça intéresse certains

**petitprince** · 06/01/2008, 16h23

Nikel !!
Et le code marche aussi avec les disques durs IEEE 1394...... par contre je ne sais pas si on peut les différencer des USB.....
Bravo ero-sennin !

P.S.: La procédure SetMediaType doit être privé, et prend le réflexe de mettre un "F" devant les champs (F comme Field

)

**ero-sennin** · 06/01/2008, 16h57

Envoyé par petitprince

Nikel !!
Et le code marche aussi avec les disques durs IEEE 1394...... par contre je ne sais pas si on peut les différencer des USB.....
Bravo ero-sennin !

P.S.: La procédure SetMediaType doit être privé, et prend le réflexe de mettre un "F" devant les champs (F comme Field

)

Merci

Pour la différenciation, je ne sais pas ... Désolé

Sinon, merci pour la correction, c'est une erreur d'inattention de ma part

[EDIT]

J'ai remis à jour le code, et peut être que j'ai un peut simplifier par rapport au post précédent ...

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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
unit UMedia;
 
interface
 
uses Windows, Messages, SysUtils, Classes, Forms, Dialogs,Math;
 
const
  DBT_DEVICEARRIVAL          = $8000;          // system detected a new device
  DBT_DEVICEREMOVECOMPLETE   = $8004;          // device is gone
  DBT_DEVTYP_VOLUME          = $00000002;      // device volume class
 
 
type
  PDevBroadcastHdr  = ^DEV_BROADCAST_HDR;
  PDevBroadcastHeader  = PDevBroadcastHdr;
  DEV_BROADCAST_HDR = packed record
    dbch_size: DWORD;
    dbch_devicetype: DWORD;
    dbch_reserved: DWORD;
  end;
 
  PDevBroadcastVolume =  ^DEV_BROADCAST_VOLUME;
  DEV_BROADCAST_VOLUME  =  packed record
     dbch_size: DWORD;
     dbch_devicetype: DWORD;
     dbch_reserved: DWORD;
     dbcv_unitmask: DWORD;
     dbcv_flags: WORD;
  end;
 
type
  TTypeSizeOf = (tsoByte, tsoKiloByte, tsoMegaByte, tsoGigabyte, tsoTeraByte);
  TMediaType = (mtAll,mtCDandDVD,mtFlashDisk);
 
  TMediaConnected = class(TComponent)
  private
    FDeviceLetter: Char;
    FVolName: Array[0..Max_Path]Of Char;
    FileSysName : Array[0..Max_Path]Of Char;
    FVolSerial   : DWord;
    FileMaxLen  : DWord;
    FileFlags   : DWord;
    FFreeSpace : double;
    FSize : double;
    FBusySpace: double;
    FWindowHandle: HWND;
    FOnUSBArrival: TNotifyEvent;
    FOnUSBRemove: TNotifyEvent;
    FMediaTypeSelected:TMediaType;
    procedure WndProc(var Msg: TMessage);
    procedure SetMediaType(Value:TMediaType);
  protected
    procedure WMDeviceChange(var Msg: TMessage); dynamic;
  public
    function GetSerialVolume: Cardinal;
    function GetNameVolume: String;
    function GetFreeSpace(TypeSizeReturn: TTypeSizeOf = tsoKiloByte): Double;
    function GetBusySpace(TypeSizeReturn: TTypeSizeOf = tsoKiloByte): Double;
    function GetSize(TypeSizeReturn: TTypeSizeOf = tsoKiloByte): Double;
    function GetLetterMedia: Char;
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
  published
    property MediaType:TMediaType read FMediaTypeSelected write SetMediaType;
    property OnUSBArrival: TNotifyEvent read FOnUSBArrival write FOnUSBArrival;
    property OnUSBRemove: TNotifyEvent read FOnUSBRemove write FOnUSBRemove;
  end;
 
procedure Register;
 
implementation
 
procedure Register;
begin
  RegisterComponents('CompoPerso',[TMediaConnected]);
end;
 
{==============================================================================}
{                                TMediaConnected                               }
{==============================================================================}
function FormatSize(Value: Double; TypeSizeReturn: TTypeSizeOf): Double;
begin
  case TypeSizeReturn of
    tsoByte:      Result := Value;
    tsoKiloByte:  Result := Value / 1024;
    tsoMegaByte:  Result := Value / Power(1024,2);
    tsoGigabyte:  Result := Value / Power(1024,3)
    else
      Result := Value / Power(1024,4);
  end;
end;
 
procedure TMediaConnected.SetMediaType(value : TMediaType);
begin
  FMediaTypeSelected:=Value;
end;
//------------------------------------------------------------------------------
constructor TMediaConnected.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);
  FWindowHandle := Classes.AllocateHWnd(WndProc);
end;
//------------------------------------------------------------------------------
destructor TMediaConnected.Destroy;
begin
  Classes.DeallocateHWnd(FWindowHandle);
  inherited Destroy;
end;
//------------------------------------------------------------------------------
procedure TMediaConnected.WndProc(var Msg: TMessage);
begin
  if (Msg.Msg = WM_DEVICECHANGE) then 
  begin
    try
      WMDeviceChange(Msg);
    except
      Application.HandleException(Self);
    end;
  end
  else
    Msg.Result := DefWindowProc(FWindowHandle, Msg.Msg, Msg.wParam, Msg.lParam);
end;
//------------------------------------------------------------------------------
procedure TMediaConnected.WMDeviceChange(var Msg: TMessage);
var
  PHeader : PDevBroadcastHeader;
  PData : PDevBroadcastVolume;
  Index : Integer;
begin
  inherited;
  PHeader:=PDevBroadcastHeader(Msg.lParam);
  FDeviceLetter:=#0;
  case Msg.WParam of
    DBT_DEVICEARRIVAL :
    begin
      if (PHeader^.dbch_devicetype = DBT_DEVTYP_VOLUME) then
      begin
        if (((FMediaTypeSelected = mtFlashDisk) and (PDevBroadcastVolume( Msg.LParam )^.dbcv_flags = 0))
        or ((FMediaTypeSelected = mtCDAndDVD) and (PDevBroadcastVolume( Msg.LParam )^.dbcv_flags = 1))
        or (FMediaTypeSelected = mtAll)) then
        begin
          PData:=PDevBroadcastVolume(Msg.lParam);
          for Index:=0 to 25 do
          if ((PData^.dbcv_unitmask shr Index) = 1) then
          begin
            FDeviceLetter:=Chr(65+Index);
            break;
          end;
 
          if GetVolumeInformation(PChar(FDeviceLetter+':\'),FVolName,Max_Path,@FVolSerial, FileMaxLen, FileFlags,FileSysName,Max_Path) then
          begin
            FFreeSpace:=DiskFree(Ord(FDeviceLetter)-64);
            FSize:=DiskSize(Ord(FDeviceLetter)-64);
            FBusySpace:= FSize - FFreeSpace;
          end;
          if Assigned(FOnUSBArrival) then
            FOnUSBArrival(Self);
        end;
      end;
    end;
 
    DBT_DEVICEREMOVECOMPLETE:
    begin
      if (PHeader^.dbch_devicetype = DBT_DEVTYP_VOLUME) then
      begin
        if (PHeader^.dbch_devicetype = DBT_DEVTYP_VOLUME) then
        begin
          if (((FMediaTypeSelected = mtFlashDisk) and (PDevBroadcastVolume( Msg.LParam )^.dbcv_flags = 0))
          or ((FMediaTypeSelected = mtCDAndDVD) and (PDevBroadcastVolume( Msg.LParam )^.dbcv_flags = 1))
          or (FMediaTypeSelected = mtAll)) then
          begin
            PData:=PDevBroadcastVolume(Msg.lParam);
            for Index:=0 to 25 do
            if ((PData^.dbcv_unitmask shr Index) = 1) then
            begin
              FDeviceLetter:=Chr(65+Index);
              break;
            end;
            if Assigned(FOnUSBRemove) then
              FOnUSBRemove(Self);
          end;
        end;
      end;
    end;
  end;
end;
//------------------------------------------------------------------------------
function TMediaConnected.GetSerialVolume:cardinal;
begin
  Result:=FVolSerial;
end;
//------------------------------------------------------------------------------
function TMediaConnected.GetNameVolume:string;
begin
  Result:=FVolName;
end;
//------------------------------------------------------------------------------
function TMediaConnected.GetLetterMedia:char;
begin
  Result:=FDeviceLetter;
end;
//------------------------------------------------------------------------------
function TMediaConnected.GetFreeSpace(TypeSizeReturn: TTypeSizeOf = tsoKiloByte): Double;
begin
  result := FormatSize(FFreeSpace, TypeSizeReturn);
end;
//------------------------------------------------------------------------------
function TMediaConnected.GetBusySpace(TypeSizeReturn: TTypeSizeOf = tsoKiloByte): Double;
begin
  result := FormatSize(FBusySpace, TypeSizeReturn);
end;
//------------------------------------------------------------------------------
function TMediaConnected.GetSize(TypeSizeReturn: TTypeSizeOf = tsoKiloByte): Double;
begin
  result := FormatSize(FSize, TypeSizeReturn);
end;
 
end.

**Cl@udius** · 06/01/2008, 18h31

Envoyé par ero-sennin

On est "obligé" de mettre le else, sinon on a un avertissement du compilo disant que la valeur de retour peut être indéfini

Je n'avais pas vu ton edit.
Dans ce cas je ferais comme ceci qui me parait plus 'propre':

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
function FormatSize(Value: Double; TypeSizeReturn: TTypeSizeOf): Double;
begin
  case TypeSizeReturn of
    tsoByte:      Result := Value;
    tsoKiloByte:  Result := Value / 1024;
    tsoMegaByte:  Result := Value / Power(1024,2);
    tsoGigabyte:  Result := Value / Power(1024,3);
    else          Result := Value / Power(1024,4);
  end;
end;

[edit]
Il serait peut-être plus judicieux de faire choisir par la fonction le format renvoyé en fonction du paramètre Value.

@+

**ero-sennin** · 06/01/2008, 18h49

Envoyé par Cl@udius

Je n'avais pas vu ton edit.
Dans ce cas je ferais comme ceci qui me parait plus 'propre':

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
function FormatSize(Value: Double; TypeSizeReturn: TTypeSizeOf): Double;
begin
  case TypeSizeReturn of
    tsoByte:      Result := Value;
    tsoKiloByte:  Result := Value / 1024;
    tsoMegaByte:  Result := Value / Power(1024,2);
    tsoGigabyte:  Result := Value / Power(1024,3);
    else          Result := Value / Power(1024,4);
  end;
end;

[edit]
Il serait peut-être plus judicieux de faire choisir par la fonction le format renvoyé en fonction du paramètre Value.

@+

J'ai modifié le code du post précédent comme tu me l'as indiqué... Au passage, j'ai pris comme format de base les Kilo-Octets par contre, je ne vois pas pourquoi tu voudrais laisser la fonction faire la chose selon le paramètre value ... On perdrait alors le contrôle de la convertion non? Et tu veux faire le choix selon la longueur du paramètre Value si tu veux utiliser ta méthode ?

Merci

**Cl@udius** · 06/01/2008, 18h52

Envoyé par ero-sennin

Et tu veux faire le choix selon la longueur du paramètre Value si tu veux utiliser ta méthode ?

Oui c'est l'idée était de coller au plus près, histoire de ne pas avoir un résulat du genre: 1 245 345.65 Ko

Mais si tu veux garder le contrôle de sortie, no soucy. C'est ton compo.

@+

**ero-sennin** · 06/01/2008, 18h58

Envoyé par Cl@udius

Oui c'est l'idée était de coller au plus près, histoire de ne pas avoir un résulat du genre: 1 245 345.65 Ko

Mais si tu veux garder le contrôle de sortie, no soucy. C'est ton compo.

@+

Mouarf, je laisse tel quel, ça peut servir d'avoir un résultat dans divers format, par contre, j'implémenterai surement une autre fonction et justement mettre le choix de la taille en manuelle ou automatique, ça serait surement plus judicieux

A+

**Jipété** · 06/01/2008, 21h43

Yep !

Bien joué, tout le monde !

Et pour ne pas être embêté par 2 messages du compilateur ("symbole (De)AllocateHwnd non autorisé"), on pourra faire (source) :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
constructor TMediaConnected.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);
  FWindowHandle := Classes.AllocateHWnd(WndProc);
end;
//------------------------------------------------------------------------------
destructor TMediaConnected.Destroy;
begin
  Classes.DeallocateHWnd(FWindowHandle);
  inherited Destroy;
end;

--
jp

**ero-sennin** · 06/01/2008, 22h19

Envoyé par Jipété

Yep !

Bien joué, tout le monde !

Et pour ne pas être embêté par 2 messages du compilateur ("symbole (De)AllocateHwnd non autorisé"), on pourra faire (source) :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
constructor TMediaConnected.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);
  FWindowHandle := Classes.AllocateHWnd(WndProc);
end;
//------------------------------------------------------------------------------
destructor TMediaConnected.Destroy;
begin
  Classes.DeallocateHWnd(FWindowHandle);
  inherited Destroy;
end;

--
jp

Merci Jipété

C'est noté

**bubulemaster** · 07/01/2008, 14h04

C'est à mettre dans les sources Developpez.com (http://delphi.developpez.com/sources/).
Très intéressant.

**ero-sennin** · 07/01/2008, 14h10

Merci, ça fait plaisir

Ce soir je mettrai une version modifier pour qu'on est le choix entre tsoAutomatic, tsoByte, tso KiloByte, tsoMegaByte, tsoGigaByte, tsoTeraByte (il y a donc uniquement l'ajout de tsoAutomatic qui choisira la meilleure valeur façon de formater le retour

)

Si d'autres idées me passe (ou vous passe) par la tête, je modifierai le code en conséquence (selon mes compétences

)

A+

**Jipété** · 07/01/2008, 21h53

Yep !

Résolu, mais jamais fini,

J'ai rajouté 2 bricoles, et du coup, plus besoin de cliquer sur le bouton (attention, j'ai renommé OnUSBRemove en OnUSBRemoved, comme ça l'alignement vertical avec OnUSBArrival est tip top) :

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
type
  TForm1 = class(TForm)
    procedure FormCreate(Sender: TObject);
    procedure FormClose(Sender: TObject; var Action: TCloseAction);
  private
    { Déclarations privées }
    procedure AppareilIns(Sender: TObject); // new !
    procedure AppareilOut(Sender: TObject); // new !
 
...
procedure TForm1.FormCreate(Sender: TObject);
begin
  // Crétion de mon Objet
  MonAppareilUSB := TMediaConnected.Create(Self);
  MonAppareilUSB.OnUSBArrival := AppareilIns; // new !
  MonAppareilUSB.OnUSBRemoved := AppareilOut; // new !
end;
 
procedure TForm1.AppareilIns(Sender: TObject);
begin
  ShowMessage(FloatToStr(MonAppareilUSB.GetFreeSpace(tsoMegaByte)));
end;
 
procedure TForm1.AppareilOut(Sender: TObject);
begin
  // en fonction des besoins...
end;
 
procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction);
begin
  MonAppareilUSB.Free;
end;

J'ai testé avec 2 clés USB, c'est impec.
--
jp

**ero-sennin** · 07/01/2008, 22h42

Re,

Je remet le code commenté avec de nouvelle fonctionnalité

- ajout du tsoAutomatic qui permet de choisir pour vous le type le mieux approprié
- Choix d'afficher le type de sortie de la taille (o,Ko,Mo,Go,To)

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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
unit UUSBStorage;
 
interface
 
uses Windows, Messages, SysUtils, Classes, Forms, Dialogs,Math;
 
const
  DBT_DEVICEARRIVAL          = $8000;          // le système détecte un nouveau périphérique
  DBT_DEVICEREMOVECOMPLETE   = $8004;          // le périphérique à été retiré
  DBT_DEVTYP_VOLUME          = $00000002;      // type du périphérique
 
 
type
  PDevBroadcastHdr  = ^DEV_BROADCAST_HDR;
  PDevBroadcastHeader  = PDevBroadcastHdr;
  DEV_BROADCAST_HDR = packed record
    dbch_size: DWORD;
    dbch_devicetype: DWORD;
    dbch_reserved: DWORD;
  end;
 
  PDevBroadcastVolume =  ^DEV_BROADCAST_VOLUME;
  DEV_BROADCAST_VOLUME  =  packed record
     dbch_size: DWORD;
     dbch_devicetype: DWORD;
     dbch_reserved: DWORD;
     dbcv_unitmask: DWORD; // Sert à récupérer la lettre du lecteur
     dbcv_flags: WORD;     // 0 = Affectation de la lecteur par le périphérique (clé USB)
                           // 1 = Lettre Changée Automatique (Lecteur de CD-ROM / DVD-ROM)
  end;
 
type
  TTypeSizeOf = (tsoAutomatic, tsoByte, tsoKiloByte, tsoMegaByte, tsoGigabyte, tsoTeraByte);
  TMediaType = (mtAll, mtCDandDVD, mtFlashDisk);
 
  TUSBStorage = class(TComponent)
  private
    FDeviceLetter: Char;
    FVolName: Array[0..Max_Path]Of Char;
    FileSysName : Array[0..Max_Path]Of Char;
    FVolSerial   : DWord;
    FileMaxLen  : DWord;
    FileFlags   : DWord;
    FFreeSpace : double;
    FSize : double;
    FBusySpace: double;
    FWindowHandle: HWND;
    FOnUSBConnect: TNotifyEvent;
    FOnUSBDisconnect: TNotifyEvent;
    FMediaTypeSelected:TMediaType;
    FShowSizeType:boolean;
    procedure WndProc(var Msg: TMessage);
    procedure SetMediaType(Value:TMediaType);
    procedure SetShowSizeType(Value:boolean);
    function FormatSize(Value: Double; TypeSizeReturn: TTypeSizeOf): string;
    function FormatSizeF(Value: Double; TypeSizeReturn: TTypeSizeOf): Double;
  protected
    procedure WMDeviceChange(var Msg: TMessage); dynamic;
  public
    function GetSerialVolume: Cardinal;
    function GetNameVolume: String;
    function GetFreeSpaceF(TypeSizeReturn: TTypeSizeOf = tsoKiloByte): Double;
    function GetBusySpaceF(TypeSizeReturn: TTypeSizeOf = tsoKiloByte): Double;
    function GetSizeF(TypeSizeReturn: TTypeSizeOf = tsoKiloByte): Double;
    function GetFreeSpace(TypeSizeReturn: TTypeSizeOf = tsoKiloByte): string;
    function GetBusySpace(TypeSizeReturn: TTypeSizeOf = tsoKiloByte): string;
    function GetSize(TypeSizeReturn: TTypeSizeOf = tsoKiloByte): string;
    function GetLetterMedia: Char;
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
  published
    property MediaType:TMediaType read FMediaTypeSelected write SetMediaType;
    property ShowSizeType:boolean read FShowSizeType write SetShowSizeType;
    property OnUSBConnect: TNotifyEvent read FOnUSBConnect write FOnUSBConnect;
    property OnUSBDisconnect: TNotifyEvent read FOnUSBDisconnect write FOnUSBDisconnect;
  end;
 
procedure Register;
 
implementation
 
procedure Register;
begin
  RegisterComponents('JlnCompo',[TUSBStorage]);
end;
 
{==============================================================================}
{                                TMediaConnected                               }
{==============================================================================}
 
{------------------------------------------------------------------------------}
 
{*************************************************************************}
{ Fonction qui formate la taille                                          }
{ - tsoAutomatic : Choix automatique du format de sortie (o,Ko,Mo,Go,To)  }
{ - tsoByte : Retour de la taille en Byte                                 }
{ - tsoKiloByte : Retour de la taille en KiloByte                         }
{ - tsoMegaByte : Retour de la taille en MegaByte                         }
{ - tsoGigaByte : Retour de la taille en GigaByte                         }
{ - tsoTeraByte : Retour de la taille en TeraByte                         }
{*************************************************************************}
function TUSBStorage.FormatSizeF(Value: Double; TypeSizeReturn: TTypeSizeOf): Double;
begin
  case TypeSizeReturn of
    tsoAutomatic:
    begin
      if ((value > 1024) and (value < Power(1024,2))) then
        Result:= RoundTo((Value / 1024),-2)
      else
      begin
        if ((value > Power(1024,2)) and (value < Power(1024,3))) then
          Result := RoundTo((Value / Power(1024,2)),-2)
        else
        begin
          if ((value > Power(1024,3)) and (value < Power(1024,4))) then
            Result := RoundTo((Value / Power(1024,3)),-2)
          else
          begin
            if (value > Power(1024,4)) then
              Result := RoundTo((Value / Power(1024,4)),-2)
            else
              Result := RoundTo(Value,-2);
          end;
        end;
      end;
    end;
    tsoByte:      Result := RoundTo(Value,-2);
    tsoKiloByte:  Result := RoundTo((Value / 1024),-2);
    tsoMegaByte:  Result := RoundTo((Value / Power(1024,2)),-2);
    tsoGigabyte:  Result := RoundTo((Value / Power(1024,3)),-2);
    else
      Result := RoundTo((Value / Power(1024,4)),-2);
  end;
end;
//------------------------------------------------------------------------------
 
{*****************************************************************************************}
{ Fonction qui formate la taille : Si FIsTrue alors affichage en plus du format de sortie }
{ - tsoAutomatic : Choix automatique du format de sortie (o,Ko,Mo,Go,To)                  }
{ - tsoByte : Retour de la taille en Byte                                                 }
{ - tsoKiloByte : Retour de la taille en KiloByte                                         }
{ - tsoMegaByte : Retour de la taille en MegaByte                                         }
{ - tsoGigaByte : Retour de la taille en GigaByte                                         }
{ - tsoTeraByte : Retour de la taille en TeraByte                                         }
{*****************************************************************************************}
function TUSBStorage.FormatSize(Value: Double; TypeSizeReturn: TTypeSizeOf): string;
begin
  case TypeSizeReturn of
    tsoAutomatic:
    begin
      if ((value > 1024) and (value < Power(1024,2))) then
      begin
        Result:= FloatToStr(RoundTo((Value / 1024),-2));
        if FShowSizeType then
          Result:= Result + ' Ko';
      end
      else
      begin
        if ((value > Power(1024,2)) and (value < Power(1024,3))) then
        begin
          Result := FloatToStr(RoundTo((Value / Power(1024,2)),-2));
          if FShowSizeType then
            Result:= Result + ' Mo';
        end
        else
        begin
          if ((value > Power(1024,3)) and (value < Power(1024,4))) then
          begin
            Result := FloatToStr(RoundTo((Value / Power(1024,3)),-2));
            if FShowSizeType then
              Result:= Result + ' Go';
          end
          else
          begin
            if (value > Power(1024,4)) then
            begin
              Result := FloatToStr(RoundTo((Value / Power(1024,4)),-2));
              if FShowSizeType then
                Result:= Result + ' To';
            end
            else
            begin
              Result := FloatToStr(RoundTo(Value,-2));
              if FShowSizeType then
                Result:= Result + ' o';
            end;
          end;
        end;
      end;
    end;
 
    tsoByte:
    begin
      Result := FloatToStr(RoundTo(Value,-2));
      if FShowSizeType then
        Result:=Result+ ' o';
    end;
 
    tsoKiloByte:
    begin
     Result := FloatToStr(RoundTo((Value / 1024),-2));
     if FShowSizeType then
       Result:= Result + ' Ko';
    end;
 
    tsoMegaByte:
    begin
     Result := FloatToStr(RoundTo((Value / Power(1024,2)),-2));
     if FShowSizeType then
       Result:= Result + ' Mo';
    end;
 
    tsoGigabyte:
    begin
      Result := FloatToStr(RoundTo((Value / Power(1024,3)),-2));
      if FShowSizeType then
       Result:= Result + ' Go';
    end;
    else
    begin
      Result := FloatToStr(RoundTo((Value / Power(1024,4)),-2));
      if FShowSizeType then
       Result:= Result + ' To';
    end;
  end;
end;
//------------------------------------------------------------------------------
 
{*******************************************************}
{ Défini si on affiche le format de sortie de la taille }
{*******************************************************}
procedure TUSBStorage.SetShowSizeType(Value:boolean);
begin
  FShowSizeType:=Value;
end;
//------------------------------------------------------------------------------
 
{******************************************************************}
{ Défini quel type on doit détecter : Tout / USBFlask / CD-DVD ROM }
{******************************************************************}
procedure TUSBStorage.SetMediaType(value : TMediaType);
begin
  FMediaTypeSelected:=Value;
end;
//------------------------------------------------------------------------------
 
{**************}
{ Constructeur }
{**************}
constructor TUSBStorage.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);
  FWindowHandle := Classes.AllocateHWnd(WndProc);
end;
//------------------------------------------------------------------------------
 
{*************}
{ Destructeur }
{*************}
destructor TUSBStorage.Destroy;
begin
  Classes.DeallocateHWnd(FWindowHandle);
  inherited Destroy;
end;
//------------------------------------------------------------------------------
 
 
procedure TUSBStorage.WndProc(var Msg: TMessage);
begin
  if (Msg.Msg = WM_DEVICECHANGE) then 
  begin
    try
      WMDeviceChange(Msg);
    except
      Application.HandleException(Self);
    end;
  end
  else
    Msg.Result := DefWindowProc(FWindowHandle, Msg.Msg, Msg.wParam, Msg.lParam);
end;
//------------------------------------------------------------------------------
 
{*******************************************************************}
{ Message qui est envoyé lors d'insertion de média USB / CD-ROM ... }
{*******************************************************************}
procedure TUSBStorage.WMDeviceChange(var Msg: TMessage);
var
  PHeader : PDevBroadcastHeader;
  PData : PDevBroadcastVolume;
  Index : Integer;
begin
  inherited;
  PHeader:=PDevBroadcastHeader(Msg.lParam);
  FDeviceLetter:=#0;
  case Msg.WParam of
    // On a inséré un média
    DBT_DEVICEARRIVAL :
    begin
      // On teste si c'est un volume
      if (PHeader^.dbch_devicetype = DBT_DEVTYP_VOLUME) then
      begin
        if (((FMediaTypeSelected = mtFlashDisk) and (PDevBroadcastVolume( Msg.LParam )^.dbcv_flags = 0))
        or ((FMediaTypeSelected = mtCDAndDVD) and (PDevBroadcastVolume( Msg.LParam )^.dbcv_flags = 1))
        or (FMediaTypeSelected = mtAll)) then
        begin
          PData:=PDevBroadcastVolume(Msg.lParam);
          for Index:=0 to 25 do
          if ((PData^.dbcv_unitmask shr Index) = 1) then
          begin
            FDeviceLetter:=Chr(65+Index);
            break;
          end;
          // Récupération de diverses informations sur le média
          if GetVolumeInformation(PChar(FDeviceLetter+':\'),FVolName,Max_Path,@FVolSerial, FileMaxLen, FileFlags,FileSysName,Max_Path) then
          begin
            FFreeSpace:=DiskFree(Ord(FDeviceLetter)-64);
            FSize:=DiskSize(Ord(FDeviceLetter)-64);
            FBusySpace:= FSize - FFreeSpace;
          end;
          if Assigned(FOnUSBConnect) then
            FOnUSBConnect(Self);
        end;
      end;
    end;
 
    // On a déconnecté un média
    DBT_DEVICEREMOVECOMPLETE:
    begin
      if (PHeader^.dbch_devicetype = DBT_DEVTYP_VOLUME) then
      begin
        if (PHeader^.dbch_devicetype = DBT_DEVTYP_VOLUME) then
        begin
          if (((FMediaTypeSelected = mtFlashDisk) and (PDevBroadcastVolume( Msg.LParam )^.dbcv_flags = 0))
          or ((FMediaTypeSelected = mtCDAndDVD) and (PDevBroadcastVolume( Msg.LParam )^.dbcv_flags = 1))
          or (FMediaTypeSelected = mtAll)) then
          begin
            PData:=PDevBroadcastVolume(Msg.lParam);
            for Index:=0 to 25 do
            if ((PData^.dbcv_unitmask shr Index) = 1) then
            begin
              FDeviceLetter:=Chr(65+Index);
              break;
            end;
            // Récupération de diverses informations sur le média
            if GetVolumeInformation(PChar(FDeviceLetter+':\'),FVolName,Max_Path,@FVolSerial, FileMaxLen, FileFlags,FileSysName,Max_Path) then
            begin
              FFreeSpace:=DiskFree(Ord(FDeviceLetter)-64);
              FSize:=DiskSize(Ord(FDeviceLetter)-64);
              FBusySpace:= FSize - FFreeSpace;
            end;
            if Assigned(FOnUSBDisconnect) then
              FOnUSBDisconnect(Self);
          end;
        end;
      end;
    end;
  end;
end;
//------------------------------------------------------------------------------
 
{****************************************************}
{ fonction qui retourne le numéro de série du volume }
{****************************************************}
function TUSBStorage.GetSerialVolume:cardinal;
begin
  Result:=FVolSerial;
end;
//------------------------------------------------------------------------------
 
{****************************************}
{ fonction qui retourne le nom du volume }
{****************************************}
function TUSBStorage.GetNameVolume:string;
begin
  Result:=FVolName;
end;
//------------------------------------------------------------------------------
 
{******************************************}
{ fonction qui retourne la lettre du média }
{******************************************}
function TUSBStorage.GetLetterMedia:char;
begin
  Result:=FDeviceLetter;
end;
//------------------------------------------------------------------------------
 
{***********************************************}
{ fonction qui retourne l'espace libre du média }
{***********************************************}
function TUSBStorage.GetFreeSpace(TypeSizeReturn: TTypeSizeOf = tsoKiloByte): string;
begin
  result := FormatSize(FFreeSpace, TypeSizeReturn);
end;
//------------------------------------------------------------------------------
 
{************************************************}
{ fonction qui retourne l'espace occupé du média }
{************************************************}
function TUSBStorage.GetBusySpace(TypeSizeReturn: TTypeSizeOf = tsoKiloByte): string;
begin
  result := FormatSize(FBusySpace, TypeSizeReturn);
end;
//------------------------------------------------------------------------------
 
{************************************************}
{ fonction qui retourne l'espace disque du média }
{************************************************}
function TUSBStorage.GetSize(TypeSizeReturn: TTypeSizeOf = tsoKiloByte): string;
begin
  result := FormatSize(FSize, TypeSizeReturn);
end;
//------------------------------------------------------------------------------
 
{***************************************************************************************}
{ fonction qui retourne l'espace libre du média (type de sortie : chaine de caractères) }
{***************************************************************************************}
function TUSBStorage.GetFreeSpaceF(TypeSizeReturn: TTypeSizeOf = tsoKiloByte): Double;
begin
  result := FormatSizeF(FFreeSpace, TypeSizeReturn);
end;
//------------------------------------------------------------------------------
 
{****************************************************************************************}
{ fonction qui retourne l'espace occupé du média (type de sortie : chaine de caractères) }
{****************************************************************************************}
function TUSBStorage.GetBusySpaceF(TypeSizeReturn: TTypeSizeOf = tsoKiloByte): Double;
begin
  result := FormatSizeF(FBusySpace, TypeSizeReturn);
end;
//------------------------------------------------------------------------------
 
{****************************************************************************************}
{ fonction qui retourne l'espace disque du média (type de sortie : chaine de caractères) }
{****************************************************************************************}
function TUSBStorage.GetSizeF(TypeSizeReturn: TTypeSizeOf = tsoKiloByte): Double;
begin
  result := FormatSizeF(FSize, TypeSizeReturn);
end;
 
end.

Par contre Jipété, je ne comprends pas pourquoi c'est nouveau avec ton code puisque mon composant possède les événement OnConnect et OnDisconnect .... Aurai-je loupé une marche ?

Dite moi ce que vous en pensez en ce qui concerne les arrondis, car j'ai mis 2 chiffres après la virgule ... je devrais peut être le laisser comme avant ?

N'hésitez pas à apporter vos critiques

A+

**Jipété** · 08/01/2008, 07h36

Envoyé par ero-sennin

Par contre Jipété, je ne comprends pas pourquoi c'est nouveau avec ton code puisque mon composant possède les événement OnConnect et OnDisconnect .... Aurai-je loupé une marche ?

Yep !
Ah oui, j'ai oublié de préciser que ça concernait la mise en œuvre, le code de l'Unit1, quand tu disais, dans "procedure TForm1.Button1Click(Sender: TObject);"

// Avant de cliquer sur le bouton, j'insère une clé USB

Valà, et bonne journée,
--
jp

Composant détectant l'insertion d'une clé USB

Composants VCL Delphi

Discussions similaires

Partager

Partager