Discussion :

[ero-sennin]

Bon, ba je crois que là c'est tout, j'ai fait les modifs laissant le choix pour la précision jusque 8 chiffres après la virgule ...

Je joinds au code une petite démo histoire de voir le fonctionnement (bien que ça ne soit pas compliqué).

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
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
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;
    FSizeTypeOf:TTypeSizeOf;
    procedure WndProc(var Msg: TMessage);
    function FormatSize(Value: Double; TypeSizeReturn: TTypeSizeOf; Precision:integer): string;
    function FormatSizeF(Value: Double; TypeSizeReturn: TTypeSizeOf; Precision:integer): Double;
  protected
    procedure WMDeviceChange(var Msg: TMessage); dynamic;
  public
    function GetFreeSpaceF(TypeSizeReturn: TTypeSizeOf = tsoKiloByte; Precision:integer=2): Double;
    function GetBusySpaceF(TypeSizeReturn: TTypeSizeOf = tsoKiloByte; Precision:integer=2): Double;
    function GetSizeF(TypeSizeReturn: TTypeSizeOf = tsoKiloByte; Precision:integer=2): Double;
    function GetFreeSpace(TypeSizeReturn: TTypeSizeOf = tsoKiloByte; Precision:integer=2): string;
    function GetBusySpace(TypeSizeReturn: TTypeSizeOf = tsoKiloByte; Precision:integer=2): string;
    function GetSize(TypeSizeReturn: TTypeSizeOf = tsoKiloByte; Precision:integer=2): string;
    function VolumeName:String;
    function FileSystem:String;
    property SizeType: TTypeSizeOf read FSizeTypeOf;
    property SerialVolume: Cardinal read FVolSerial;
    property LetterDevice: Char read FDeviceLetter;
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
  published
    property MediaType:TMediaType read FMediaTypeSelected write FMediaTypeSelected;
    property ShowSizeType:boolean read FShowSizeType write FShowSizeType;
    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; Precision:integer): Double;
begin
  FFreeSpace:=DiskFree(Ord(FDeviceLetter)-64);
  FSize:=DiskSize(Ord(FDeviceLetter)-64);
  FBusySpace:= FSize - FFreeSpace;
  if Precision > 8 then
    Precision := 8
  else
  begin
    if Precision < 0 then
      Precision := 0
  end;
  case TypeSizeReturn of
    tsoAutomatic:
    begin
      if ((value > 1024) and (value < Power(1024,2))) then
      begin
        Result:= RoundTo((Value / 1024),-Precision);
        FSizeTypeOf:=tsoKiloByte;
      end
      else
      begin
        if ((value > Power(1024,2)) and (value < Power(1024,3))) then
        begin
          Result := RoundTo((Value / Power(1024,2)),-Precision);
          FSizeTypeOf:=tsoMegaByte;
        end
        else
        begin
          if ((value > Power(1024,3)) and (value < Power(1024,4))) then
          begin
            Result := RoundTo((Value / Power(1024,3)),-Precision);
            FSizeTypeOf:=tsoGigabyte;
          end
          else
          begin
            if (value > Power(1024,4)) then
            begin
              Result := RoundTo((Value / Power(1024,4)),-Precision);
              FSizeTypeOf:=tsoTeraByte;
            end
            else
            begin
              Result := RoundTo(Value,-Precision);
              FSizeTypeOf:=tsoByte;
            end;
          end;
        end;
      end;
    end;
 
    tsoByte:
    begin
      Result := RoundTo(Value,-Precision);
      FSizeTypeOf:=tsoByte;
    end;
 
    tsoKiloByte:
    begin
      Result := RoundTo((Value / 1024),-Precision);
      FSizeTypeOf:=tsoKiloByte;
    end;
 
    tsoMegaByte:
    begin
      Result := RoundTo((Value / Power(1024,2)),-Precision);
      FSizeTypeOf:=tsoMegaByte;
    end;
 
    tsoGigabyte:
    begin
      Result := RoundTo((Value / Power(1024,3)),-Precision);
      FSizeTypeOf:=tsoGigabyte;
    end
    else
    begin
      Result := RoundTo((Value / Power(1024,4)),-Precision);
      FSizeTypeOf:=tsoTeraByte;
    end;
  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; Precision:integer): string;
begin
  if Precision > 8 then
    Precision := 8
  else
  begin
    if Precision < 0 then
      Precision := 0
  end;
  case TypeSizeReturn of
    tsoAutomatic:
    begin
      if ((value > 1024) and (value < Power(1024,2))) then
      begin
        Result:= FloatToStr(RoundTo((Value / 1024),-Precision));
        if FShowSizeType then
          Result:= Result + ' Ko';
        FSizeTypeOf:=tsoKiloByte;
      end
      else
      begin
        if ((value > Power(1024,2)) and (value < Power(1024,3))) then
        begin
          Result := FloatToStr(RoundTo((Value / Power(1024,2)),-Precision));
          if FShowSizeType then
            Result:= Result + ' Mo';
          FSizeTypeOf:=tsoMegaByte;
        end
        else
        begin
          if ((value > Power(1024,3)) and (value < Power(1024,4))) then
          begin
            Result := FloatToStr(RoundTo((Value / Power(1024,3)),-Precision));
            if FShowSizeType then
              Result:= Result + ' Go';
            FSizeTypeOf:=tsoGigabyte;
          end
          else
          begin
            if (value > Power(1024,4)) then
            begin
              Result := FloatToStr(RoundTo((Value / Power(1024,4)),-Precision));
              if FShowSizeType then
                Result:= Result + ' To';
              FSizeTypeOf:=tsoTeraByte;
            end
            else
            begin
              Result := FloatToStr(RoundTo(Value,-Precision));
              if FShowSizeType then
                Result:= Result + ' o';
              FSizeTypeOf:=tsoByte;
            end;
          end;
        end;
      end;
    end;
 
    tsoByte:
    begin
      Result := FloatToStr(RoundTo(Value,-Precision));
      if FShowSizeType then
        Result:=Result+ ' o';
      FSizeTypeOf:=tsoByte;
    end;
 
    tsoKiloByte:
    begin
     Result := FloatToStr(RoundTo((Value / 1024),-Precision));
     if FShowSizeType then
       Result:= Result + ' Ko';
     FSizeTypeOf:=tsoKiloByte;
    end;
 
    tsoMegaByte:
    begin
     Result := FloatToStr(RoundTo((Value / Power(1024,2)),-Precision));
     if FShowSizeType then
       Result:= Result + ' Mo';
     FSizeTypeOf:=tsoMegaByte;
    end;
 
    tsoGigabyte:
    begin
      Result := FloatToStr(RoundTo((Value / Power(1024,3)),-Precision));
      if FShowSizeType then
       Result:= Result + ' Go';
      FSizeTypeOf:=tsoGigabyte;
    end;
    else
    begin
      Result := FloatToStr(RoundTo((Value / Power(1024,4)),-Precision));
      if FShowSizeType then
       Result:= Result + ' To';
      FSizeTypeOf:=tsoTeraByte;
    end;
  end;
end;
//------------------------------------------------------------------------------
 
function TUSBStorage.VolumeName:string;
begin
  Result:=FVolName;
end;
 
function TUSBStorage.FileSystem:string;
begin
  Result:=FileSysName;
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;
 
            if Assigned(FOnUSBDisconnect) then
              FOnUSBDisconnect(Self);
          end;
        end;
      end;
    end;
  end;
end;
//------------------------------------------------------------------------------
 
{***********************************************}
{ fonction qui retourne l'espace libre du média }
{***********************************************}
function TUSBStorage.GetFreeSpace(TypeSizeReturn: TTypeSizeOf = tsoKiloByte;Precision:integer=2): string;
begin
  result := FormatSize(FFreeSpace, TypeSizeReturn, Precision);
end;
//------------------------------------------------------------------------------
 
{************************************************}
{ fonction qui retourne l'espace occupé du média }
{************************************************}
function TUSBStorage.GetBusySpace(TypeSizeReturn: TTypeSizeOf = tsoKiloByte; Precision:integer=2): string;
begin
  result := FormatSize(FBusySpace, TypeSizeReturn, Precision);
end;
//------------------------------------------------------------------------------
 
{************************************************}
{ fonction qui retourne l'espace disque du média }
{************************************************}
function TUSBStorage.GetSize(TypeSizeReturn: TTypeSizeOf = tsoKiloByte; Precision:integer=2): string;
begin
  result := FormatSize(FSize, TypeSizeReturn, Precision);
end;
//------------------------------------------------------------------------------
 
{***************************************************************************************}
{ fonction qui retourne l'espace libre du média (type de sortie : chaine de caractères) }
{***************************************************************************************}
function TUSBStorage.GetFreeSpaceF(TypeSizeReturn: TTypeSizeOf = tsoKiloByte; Precision:integer=2): Double;
begin
  result := FormatSizeF(FFreeSpace, TypeSizeReturn, Precision);
end;
//------------------------------------------------------------------------------
 
{****************************************************************************************}
{ fonction qui retourne l'espace occupé du média (type de sortie : chaine de caractères) }
{****************************************************************************************}
function TUSBStorage.GetBusySpaceF(TypeSizeReturn: TTypeSizeOf = tsoKiloByte; Precision:integer=2): Double;
begin
  result := FormatSizeF(FBusySpace, TypeSizeReturn, Precision);
end;
//------------------------------------------------------------------------------
 
{****************************************************************************************}
{ fonction qui retourne l'espace disque du média (type de sortie : chaine de caractères) }
{****************************************************************************************}
function TUSBStorage.GetSizeF(TypeSizeReturn: TTypeSizeOf = tsoKiloByte; Precision:integer=2): Double;
begin
  result := FormatSizeF(FSize, TypeSizeReturn, Precision);
end;
 
end.

[Jipété]

Petit oubli ?

Code :

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

1
2
3
4
procedure TForm1.ChechBShowSizeTypeClick(Sender: TObject);
begin
  RechargerInfos;
end;

Pas vu de différence d'affichage, checked ou pas checked,
--
jp

[ero-sennin]

Petit oubli ?

Code :

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

1
2
3
4
procedure TForm1.ChechBShowSizeTypeClick(Sender: TObject);
begin
  RechargerInfos;
end;

Pas vu de différence d'affichage, checked ou pas checked,
--
jp

Merci pour la remarque ...
Le post précédent est désormais corrigé

[JohnSmith]

Très très bon code.. Merci!

Par contre, on dirait qu'il y a un léger bug avec la démo (c'est juste histoire de chipoter )

Si on démarre la démo avec la clef connectée, Media connecté affiche oui quand on déconnecte. Et chez moi, la déconnexion du média ne rafraichit pas les infos.

Bon, j'avoue avoir été fénéant et ne pas avoir regardé pourquoi

Mais je vais de ce pas utiliser le code dans mon appli. Un grand merci!

[ero-sennin]

Très très bon code.. Merci!

Par contre, on dirait qu'il y a un léger bug avec la démo (c'est juste histoire de chipoter )

Si on démarre la démo avec la clef connectée, Media connecté affiche oui quand on déconnecte. Et chez moi, la déconnexion du média ne rafraichit pas les infos.

En effet, en ce qui concerne le média connecté affiché à "OUI" c'était un petit soucis, c'est corrigé ... C'était un renommage de Label qui trainait... Par contre, pour les infos, si tu retires la clé, t'as plus d'infos ... donc je pense que c'est logique ...

Bon, j'avoue avoir été fénéant et ne pas avoir regardé pourquoi

Mais je vais de ce pas utiliser le code dans mon appli. Un grand merci!

Merci bien, ça fait toujours du bien un remerciement

[pitango]

Mais je vais de ce pas utiliser le code dans mon appli.

idem.

Merci ero-sennin, pour ton code.

[JohnSmith]

Quelle réponse rapide

Ce composant est vraiment ce qu'il me fallait. J'ai néanmoins une petite question : comment rafraichir les infos?

Si je modifie des fichiers sur la clef, et que j'appelle

Code :

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

1
2
3
 
  LabFreeSpace.Caption:='Espace Disque Libre '+USBStorage1.GetFreeSpace(tsoMegaByte);
  LabBusySpace.Caption:='Espace Disque Occupé '+USBStorage1.GetBusySpace(tsoMegaByte);

Rien ne change. Je présume que c'est lié au fait que les informations sur le disque sont lues à la connexion du lecteur, mais peut-on forcer un rafraichissement?

Merci d'avance, et encore bravo!

[ero-sennin]

Quelle réponse rapide

Ce composant est vraiment ce qu'il me fallait. J'ai néanmoins une petite question : comment rafraichir les infos?

Si je modifie des fichiers sur la clef, et que j'appelle

Code :

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

1
2
3
 
  LabFreeSpace.Caption:='Espace Disque Libre '+USBStorage1.GetFreeSpace(tsoMegaByte);
  LabBusySpace.Caption:='Espace Disque Occupé '+USBStorage1.GetBusySpace(tsoMegaByte);

Rien ne change. Je présume que c'est lié au fait que les informations sur le disque sont lues à la connexion du lecteur, mais peut-on forcer un rafraichissement?

Merci d'avance, et encore bravo!

Pas de quoi!

Actuellement, on ne peut pas le faire à partir du composant, il faut le faire à la main ... mais ... je ferai la modif intégrale du compo ce soir si j'ai le temps. Logiquement, pour ce soir (au pire demain) la modif sera opérationnelle (en espérant que je ne dise pas de bêtise ^^).

@+

[JohnSmith]

Roh.. Ce serait trop bien.

Si tu oublies, je te relancerai

[ero-sennin]

Erf, ça s'anonce pas très bien ... Je pensais arriver à mes fins juste avec ceci :

Code :

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

1
2
3
4
5
6
7
function TUSBStorage.GetFreeSpace(TypeSizeReturn: TTypeSizeOf = tsoKiloByte;Precision:integer=2): string;
begin
  FFreeSpace:=DiskFree(Ord(FDeviceLetter)-64);
  FSize:=DiskSize(Ord(FDeviceLetter)-64);
  FBusySpace:= FSize - FFreeSpace;
  result := FormatSize(FFreeSpace, TypeSizeReturn, Precision);
end;

Mais rien n'y fait

Pourtant je ne vois pas trop pourquoi ça ne peux pas se faire ...
De plus, je pense que la function pour récupérer la lettre du média ne fonctionne pas correctement ... A voir

[ero-sennin]

Bon ba après pas mal de manip, j'en suis toujours au même point! A croire que je ne peux pas le faire par le compo

Logiquement avec mon code, lors de l'insertion de la clé USB, on récupère la lettre du média. Elle est stocké dans l'attribut FLetterDevice ...

Connaissant la lettre du média, logiquement il nous est possible de récupérer les infos sans soucis non :

Code :

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

1
2
 
GetVolumeInformation(PChar(FDeviceLetter+':\'),@FVolName,Max_Path,FVolSerial, FileMaxLen, FileFlags,FileSysName,Max_Path)

(Revoir mon code dans les posts précédents).

Si quelqu'un peut essayer de voir, m'aider
Merci bien

[Jipété]

Yep !

Le changement de clé USB fonctionne : j'en ai 2, j'ai les bonnes infos, peut-être dû au fait que mes 2 clés ont des lettres différentes...

Mais effectivement le lancement du prog avec une clé déjà insérée merdouille : pas de clé détectée... Doit manquer un évènement.
Faudrait peut-être forcer un appel à WMDeviceChange mais je sais pas trop comment...
Et il est tard,
--
jp

[ero-sennin]

Yep !

Le changement de clé USB fonctionne : j'en ai 2, j'ai les bonnes infos, peut-être dû au fait que mes 2 clés ont des lettres différentes...

Mais effectivement le lancement du prog avec une clé déjà insérée merdouille : pas de clé détectée... Doit manquer un évènement.
Faudrait peut-être forcer un appel à WMDeviceChange mais je sais pas trop comment...
Et il est tard,
--
jp

Salut Jipété,

En fait, le soucis n'est pas vraiment le changement de clé USB car dans ce cas, l'appel à WMDeviceChange se fait.

Je vais expliquer un peu (si j'y arrive) ce que je souhaite faire :

Soit une form avec un bouton GetFreeSpace et bien entendu le compo.
Dans l'événement OnConnect, on récupère bien les infos, ça c'est niquel.
Mais essaie une chose, c'est de placer un autre bouton sur ta form et de rappeler la lettre du Média ... La c'est le drame, il a perdu ce dernier, la lettre du média n'est pas sauvée.
C'est un soucis car du coup, je ne peux pas accéder une seconde fois aux données sur la clé pour refaire les calculs de tailles

J'espère que tu vois ce que je veux dire ...
Merci

[ero-sennin]

Ah, c'est bon ^^ (logiquement)...

Le soucis était de mettre FLetter=#0 en tout début de WMDeviceChange...

Bon, je vais de ce pas mettre à jour ma démo :
Au passage, le code a été remanié pour plus de clarté (Merci Pedro) et j'ai rajouté quelques truc sympa :

• possibilité de rafraichir les infos (correction du soucis donc)
• récupération du format de fichier du média
• possibilité de changer le nom du média

Je remets un lien vers la démo :

[Jipété]

Yep !

Désolé pour mon post précédent, j'ai dû m'embrouilller les neurones, ça arrive, (pourtant, me semblait bien avoir lu un truc comm' ça -- 'fin bon).

À propos des corrections : je lance le prog avec une clé déjà insérée et j'ai beau cliquer partout, ça ne récupère pas les infos,
Serait-ce dû au fait que n'ayant pas envie d'encombrer ma palette de composants je n'ai rien installé et je crée le compo dynamiquement au FormCreate ? J'vois pas trop pourquoi (j'ai pompé dans unit1.dfm)...

Code :

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

1
2
3
4
5
6
7
8
9
10
procedure TForm1.FormCreate(Sender: TObject);
begin
  USBStorage1 := TUSBStorage.Create(Self);
  USBStorage1.MediaType := mtAll;
  USBStorage1.ShowSizeType := False;
  USBStorage1.OnUSBConnect := USBStorage1USBConnect;
  USBStorage1.OnUSBDisConnect := USBStorage1USBDisConnect;
  CbSizeType.ItemIndex := 3;
  CbPrecision.ItemIndex := 2;
end;

Le bouton "Rafraichir les données" m'envoie un ShowMessage vide, le bouton "Montrer le format..." n'affiche rien (!) sauf si je clique d'abord sur "Format de la partition".

Par ailleurs, en fonctionnement "normal", je mets une clé, OK, j'enlève, OK, j'en mets une autre, OK mais j'ai demandé GigaByte dans la combo "Type en sortie" or un clic sur "Montrer le format..." m'affiche "Taille affichée en Mo"...

T'es sûr que c'est tout bon chez toi ?
--
jp

[ero-sennin]

Yep !

Désolé pour mon post précédent, j'ai dû m'embrouilller les neurones, ça arrive, (pourtant, me semblait bien avoir lu un truc comm' ça -- 'fin bon).

Ca arrive à tout le monde! Qui plus est, je me suis certainement pas très bien exprimé ^^

À propos des corrections : je lance le prog avec une clé déjà insérée et j'ai beau cliquer partout, ça ne récupère pas les infos,
Serait-ce dû au fait que n'ayant pas envie d'encombrer ma palette de composants je n'ai rien installé et je crée le compo dynamiquement au FormCreate ? J'vois pas trop pourquoi (j'ai pompé dans unit1.dfm)...

Code :

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

1
2
3
4
5
6
7
8
9
10
procedure TForm1.FormCreate(Sender: TObject);
begin
  USBStorage1 := TUSBStorage.Create(Self);
  USBStorage1.MediaType := mtAll;
  USBStorage1.ShowSizeType := False;
  USBStorage1.OnUSBConnect := USBStorage1USBConnect;
  USBStorage1.OnUSBDisConnect := USBStorage1USBDisConnect;
  CbSizeType.ItemIndex := 3;
  CbPrecision.ItemIndex := 2;
end;

Le bouton "Rafraichir les données" m'envoie un ShowMessage vide, le bouton "Montrer le format..." n'affiche rien (!) sauf si je clique d'abord sur "Format de la partition".

Normal, je compo n'est pas prévu à cet effet, les données sont récupérer lors de l'insertion ... C'est vrai que ton idée est intéressante (j'y avais pensé aussi) mais le coder, heu, je sais pas comment faire ou si, j'ai une idée ... Dès que je peux, je test et si c'est OK, j'en fait pas

Par ailleurs, en fonctionnement "normal", je mets une clé, OK, j'enlève, OK, j'en mets une autre, OK mais j'ai demandé GigaByte dans la combo "Type en sortie" or un clic sur "Montrer le format..." m'affiche "Taille affichée en Mo"...

T'es sûr que c'est tout bon chez toi ?

jp

C'est un soucis de la Démo et non du composant... car dans le OnConnect, j'ai tout simplement dit de mettre Obligatoirement sur tsoMegaByte et je ne me fie pas au Combobox (je te laisse le soin de voir par tout même )

@+ et merci pour tes tests

[Jipété]

C'est un soucis de la Démo et non du composant... car dans le OnConnect, j'ai tout simplement dit de mettre Obligatoirement sur tsoMegaByte et je ne me fie pas au Combobox (je te laisse le soin de voir par tout même )

Vu, je pense :
Dans le composant, je remplace

Code :

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

property SizeType: TTypeSizeOf read FSizeTypeOf;

par

Code :

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

property SizeType: TTypeSizeOf read FSizeTypeOf write FSizeTypeOf;

Ensuite, dans la démo,

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
procedure TForm1.RechargerInfos;
begin
  LabTotalSpaceDisk.Caption:='Espace disque total : ';
  LabFreeSpace.Caption:='Espace disque libre : ';
  LabBusySpace.Caption:='Espace disque occupé : ';
 
  if ChechBShowSizeType.Checked then
    USBStorage1.ShowSizeType := True
  else
    USBStorage1.ShowSizeType := False;
 
  case CbSizeType.ItemIndex of
   0:
   begin
     LabTotalSpaceDisk.Caption:=LabTotalSpaceDisk.Caption + USBStorage1.GetSize(tsoAutomatic,CbPrecision.ItemIndex);
     LabFreeSpace.Caption:=LabFreeSpace.Caption + USBStorage1.GetFreeSpace(tsoAutomatic,CbPrecision.ItemIndex);
     LabBusySpace.Caption:=LabBusySpace.Caption + USBStorage1.GetBusySpace(tsoAutomatic,CbPrecision.ItemIndex);
     USBStorage1.SizeType := tsoAutomatic; // !
   end;
 
   1:
   begin
     LabTotalSpaceDisk.Caption:=LabTotalSpaceDisk.Caption + USBStorage1.GetSize(tsoByte,CbPrecision.ItemIndex);
     LabFreeSpace.Caption:=LabFreeSpace.Caption + USBStorage1.GetFreeSpace(tsoByte,CbPrecision.ItemIndex);
     LabBusySpace.Caption:=LabBusySpace.Caption + USBStorage1.GetBusySpace(tsoByte,CbPrecision.ItemIndex);
     USBStorage1.SizeType := tsoByte; // !
   end;
 
   2:
   begin
     LabTotalSpaceDisk.Caption:=LabTotalSpaceDisk.Caption + USBStorage1.GetSize(tsoKiloByte,CbPrecision.ItemIndex);
     LabFreeSpace.Caption:=LabFreeSpace.Caption + USBStorage1.GetFreeSpace(tsoKiloByte,CbPrecision.ItemIndex);
     LabBusySpace.Caption:=LabBusySpace.Caption + USBStorage1.GetBusySpace(tsoKiloByte,CbPrecision.ItemIndex);
     USBStorage1.SizeType := tsoKiloByte; // !
   end;
 
   3:
   begin
     LabTotalSpaceDisk.Caption:=LabTotalSpaceDisk.Caption + USBStorage1.GetSize(tsoMegaByte,CbPrecision.ItemIndex);
     LabFreeSpace.Caption:=LabFreeSpace.Caption + USBStorage1.GetFreeSpace(tsoMegaByte,CbPrecision.ItemIndex);
     LabBusySpace.Caption:=LabBusySpace.Caption + USBStorage1.GetBusySpace(tsoMegaByte,CbPrecision.ItemIndex);
     USBStorage1.SizeType := tsoMegaByte; // !
   end;
 
   4:
   begin
     LabTotalSpaceDisk.Caption:=LabTotalSpaceDisk.Caption + USBStorage1.GetSize(tsoGigabyte,CbPrecision.ItemIndex);
     LabFreeSpace.Caption:=LabFreeSpace.Caption + USBStorage1.GetFreeSpace(tsoGigabyte,CbPrecision.ItemIndex);
     LabBusySpace.Caption:=LabBusySpace.Caption + USBStorage1.GetBusySpace(tsoGigabyte,CbPrecision.ItemIndex);
     USBStorage1.SizeType := tsoGigabyte; // !
   end;
 
   5:
   begin
     LabTotalSpaceDisk.Caption:=LabTotalSpaceDisk.Caption + USBStorage1.GetSize(tsoTeraByte,CbPrecision.ItemIndex);
     LabFreeSpace.Caption:=LabFreeSpace.Caption + USBStorage1.GetFreeSpace(tsoTeraByte,CbPrecision.ItemIndex);
     LabBusySpace.Caption:=LabBusySpace.Caption + USBStorage1.GetBusySpace(tsoTeraByte,CbPrecision.ItemIndex);
     USBStorage1.SizeType := tsoTeraByte; // !
   end;
  end;
end;
 
procedure TForm1.USBStorage1USBConnect(Sender: TObject);
begin
  RechargerInfos; // !
  LabVolume.Caption := LabVolume.Caption + ' ' + USBStorage1.VolumeName;
  LabSerial.Caption := LabSerial.Caption + ' ' + IntToStr(USBStorage1.SerialVolume);
  LabTotalSpaceDisk.Caption := 'Espace disque total : ' + USBStorage1.GetSize(USBStorage1.SizeType);
  LabFreeSpace.Caption := 'Espace disque libre : '  + USBStorage1.GetFreeSpace(USBStorage1.SizeType);
  LabBusySpace.Caption := 'Espace disque occupé : ' + USBStorage1.GetBusySpace(USBStorage1.SizeType);
  LabLetter.Caption := LabLetter.Caption + ' ' + USBStorage1.LetterDevice;
  LabConnected.Caption := 'Media connecté : OUI';
end;

Sinon, un truc idiot :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
procedure TForm1.USBStorage1USBDisconnect(Sender: TObject);
begin
  LabConnected.Caption:='Media Connecté : NON';
  LabVolume.Caption:='Nom du Volume :';
  LabSerial.Caption:='Numéro de Série du Volume :';
  LabLetter.Caption:='Volume monté sur :';
  LabVolume.Caption:=LabVolume.Caption+' '+USBStorage1.VolumeName;
  LabSerial.Caption:=LabSerial.Caption+' '+IntToStr(USBStorage1.SerialVolume);
  LabTotalSpaceDisk.Caption:='Espace Disque Total '+USBStorage1.GetSize(tsoMegaByte);
  LabFreeSpace.Caption:='Espace Disque Libre '+USBStorage1.GetFreeSpace(tsoMegaByte);
  LabBusySpace.Caption:='Espace Disque Occupé '+USBStorage1.GetBusySpace(tsoMegaByte);
  LabLetter.Caption:=LabLetter.Caption+' '+USBStorage1.LetterDevice;
end;

Puisque le média est déconnecté, pas besoin d'aller chercher des infos inexistantes :

Code :

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

1
2
3
4
5
6
7
8
9
10
procedure TForm1.USBStorage1USBDisconnect(Sender: TObject);
begin
  LabConnected.Caption := 'Media connecté : NON';
  LabLetter.Caption := 'Nom du volume :';
  LabSerial.Caption := 'Numéro de série du volume :';
  LabVolume.Caption := 'Volume monté sur :';
  LabTotalSpaceDisk.Caption := 'Espace disque total : ';
  LabFreeSpace.Caption := 'Espace disque libre : ';
  LabBusySpace.Caption := 'Espace disque occupé : ';
end;

Valà,
--
jp
PS : tu m'excuseras mais préférant la typographie française à l'anglo-saxonne, j'ai viré toutes tes majuscules intermédiaires qui culturellement parlant n'ont rien à faire ici,

[ero-sennin]

Merci pour ces remarques une fois de plus ...

Pour la correction au niveau du compo (récupération d'infos inexistantes), en effet, c'était un rajout car j'avais une erreur j'ai oublié de l'enlever. Par contre, pour le SizeType, pourquoi pas en effet
C'est d'ailleurs plus logique ...

Pour le français - anglais, désolé lol. C'est pas mon habitude pourtant
Bon, pour les médias déjà connecté, j'ai ma petite idée, elle se développe ... Je poste dès que c'est good (ça sera surement pas parfait, mais bon).

A+

[ero-sennin]

Re,

Je viens de finir de petits trucs sympa sur le compos
Voici les améliorations :

• Possibilité de récupérer les infos des médias déjà connectés
• Possibilité de tester le type de média si on se met si mtAll
• Prise en charge uniquement des médias déjà connectés, les autre sont ignorés

Je vous laisse tester

Bien sur, la petite démo est de la partie

Démo

J'attends vos réactions

[Jipété]

Yep !

3 remarques :

1. si je remplace "RechargerInfos" par "USBStorage1USBInsert(Self);" dans FormCreate, ça détecte une clé déjà insérée au lancement de la démo ;
2. il faut rajouter "ViderInfos;" avant "RechargerInfos;" dans Button2Click sinon l'affichage c'est nawak ;
3. il y a une proc Button4Click qui traîne, inutilisée.

Valà,
--
jp