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:

type
  TDriveType = 0..6;
  TDrive = class                 
    DriveChar: Char;
    Caption: String;
    DriveType: TDriveType;
  end;

const
  dtUnknown   = 0;
  dtNoRootDir = 1;
  dtRemovable = 2;
  dtFixed     = 3;
  dtRemote    = 4;
  dtCDROM     = 5;
  dtRAMDisk   = 6;

function ListDrives: TList;
var r: Integer; Drives: array[0..128] of char; pDrive: PChar; Tmp: TDrive;
begin
  Result := TList.Create;
  r := GetLogicalDriveStrings(SizeOf(Drives), Drives);
  if r = 0 then Exit;
  if r > SizeOf(Drives) then
    raise Exception.Create(SysErrorMessage(ERROR_OUTOFMEMORY));
  pDrive := Drives;
  while pDrive^ <> #0 do
  begin
    Tmp := TDrive.Create;
    Tmp.Caption := pDrive;
    Tmp.DriveType := GetDriveType(pDrive);
    Tmp.DriveChar := pDrive[0];
    Inc(pDrive, 4);
    Result.Add(Tmp);
  end;
end;

function GetDriveName(Drive: Char): String;
var Unused: Integer; Buffer: array[0..19] of Char; B1, B2: Boolean;
begin
  case GetDriveType(PChar(Drive+':\')) of
    dtRemovable:
    begin
      if UpperCase(Drive) < 'C' then
      begin
        Result := '3½-Diskette';
        Exit;
      end
      else
        Result := 'Wechseldatenträger';
    end;
    dtFixed:     Result := 'Lokaler Datenträger';
    dtRemote:    Result := 'Netzwerklaufwerk';
    dtCDRom:     Result := 'CD';
    dtRAMDisk:   Result := 'RAM-Laufwerk';
    else         Result := 'Laufwerk';         
  end;
  try
    B1 := GetDriveType(PChar(Drive+':\')) > 1;
    B2 := GetVolumeInformation(PChar(Drive+':\'), @Buffer[0], SizeOf(Buffer), nil,
      Unused, Unused, nil, 0);
    if B1 and B2 and (Buffer <> '') then
      Result := Buffer
    else
      RaiseLastWin32Error;
  except
  end;
end;

function GetDriveState(Drive: Char): String;
var Dw1, Dw2, Dw3, Dw4: DWord; Oem: Integer;
begin
  try
    Oem := SetErrorMode(SEM_FAILCRITICALERRORS);
    if (GetDriveType(PChar(Drive+':\')) = dtRemovable) and
      (UpperCase(Drive) < 'C') then
    begin
      Result := 'Nicht bereit';
      Exit;
    end;
    if GetDiskFreeSpace(PChar(Drive+':\'#0), Dw1, Dw2, Dw3, Dw4) then
      Result := 'Bereit'
    else
      Result := 'Nicht bereit';
    SetErrorMode(Oem) ;
  except
    Result := 'Nicht bereit';
  end;
end;

function ListDrivesInListView(ListView: TListView): Boolean;
var i, j: Integer; N, T, State: String;
  Item: TListItem; Found, Ready: Boolean; C: Char; S: Integer; Drives: TList;
begin
  Result := True;
  try
    Drives := ListDrives;
    for i := 0 to Drives.Count-1 do
    begin
      Found := False;
      C := TDrive(Drives.Items[i]).DriveChar;
      case TDrive(Drives.Items[i]).DriveType of       
        dtRemovable:
          if UpperCase(C) < 'C' then
            S := 1
          else
            S := 3;
        dtCDRom:     S := 2;
        else         S := 0;
      end;
      case TDrive(Drives.Items[i]).DriveType of
        dtRemovable:
          if UpperCase(C) < 'C' then
            T := '3½-Diskette'
          else
            T := 'Wechseldatenträger';
        dtFixed:     T := 'Lokaler Datenträger';
        dtRemote:    T := 'Netzwerklaufwerk';
        dtCDRom:     T := 'CD';
        dtRAMDisk:   T := 'RAM-Laufwerk';
        else         T := 'Laufwerk';
      end;
      N := GetDriveName(C)+' ('+C+')';
      try State := GetDriveState(C); except end;
      for j := 0 to ListView.Items.Count-1 do
        if ListView.Items[j].StateIndex = Ord(C) then
        begin
          Found := True;
          Item := ListView.Items[i];
          if Item.Caption <> N then Item.Caption := N;
          if Item.ImageIndex <> S then Item.ImageIndex := S;
          if Item.SubItems[0] <> T then Item.SubItems[0] := T;
          if Item.SubItems[1] <> State then Item.SubItems[1] := State;
          Break;
        end;
      if not Found then
      begin
        Item := ListView.Items.Add;
        Item.Caption := N;
        Item.ImageIndex := S;
        Item.StateIndex := Ord(C);
        Item.SubItems.Add(T);
        Item.SubItems.Add(State);
      end;
    end;
    Ready := False;
    while not Ready do
    begin
      Ready := True;
      for i := 0 to ListView.Items.Count-1 do
      begin
        Found := False;
        for j := 0 to Drives.Count-1 do
          if ListView.Items[i].StateIndex = Ord(TDrive(Drives.Items[i]).DriveChar) then
            Found := True;
        if not Found then
        begin
          ListView.Items.Delete(i);
          Break;
          Ready := False;
        end;
      end;
    end;
    Drives.Free;
  except
    Result := False;
  end;
end;                    

1:

Memo1.Lines.Assign(DriveComboBox1.Items);