]> git.saurik.com Git - wxWidgets.git/blob - src/msw/volume.cpp
formatting
[wxWidgets.git] / src / msw / volume.cpp
1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: src/msw/volume.cpp
3 // Purpose: wxFSVolume - encapsulates system volume information
4 // Author: George Policello
5 // Modified by:
6 // Created: 28 Jan 02
7 // RCS-ID: $Id$
8 // Copyright: (c) 2002 George Policello
9 // Licence: wxWindows licence
10 ///////////////////////////////////////////////////////////////////////////////
11
12 // ============================================================================
13 // declarations
14 // ============================================================================
15
16 // ----------------------------------------------------------------------------
17 // headers
18 // ----------------------------------------------------------------------------
19
20 #include "wx/wxprec.h"
21
22 #ifdef __BORLANDC__
23 #pragma hdrstop
24 #endif
25
26 #if wxUSE_FSVOLUME
27
28 #include "wx/volume.h"
29
30 #ifndef WX_PRECOMP
31 #if wxUSE_GUI
32 #include "wx/icon.h"
33 #endif
34 #include "wx/intl.h"
35 #include "wx/log.h"
36 #include "wx/hashmap.h"
37 #include "wx/filefn.h"
38 #endif // WX_PRECOMP
39
40 #include "wx/dir.h"
41 #include "wx/dynlib.h"
42 #include "wx/arrimpl.cpp"
43
44 // some compilers require including <windows.h> before <shellapi.h> so do it
45 // even if this is not necessary with most of them
46 #include "wx/msw/wrapwin.h"
47 #include <shellapi.h>
48 #include <shlobj.h>
49 #include "wx/msw/missing.h"
50
51 #if wxUSE_BASE
52
53 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
54 // Dynamic library function defs.
55 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
56
57 #if wxUSE_DYNLIB_CLASS
58 static wxDynamicLibrary s_mprLib;
59 #endif
60
61 typedef DWORD (WINAPI* WNetOpenEnumPtr)(DWORD, DWORD, DWORD, LPNETRESOURCE, LPHANDLE);
62 typedef DWORD (WINAPI* WNetEnumResourcePtr)(HANDLE, LPDWORD, LPVOID, LPDWORD);
63 typedef DWORD (WINAPI* WNetCloseEnumPtr)(HANDLE);
64
65 static WNetOpenEnumPtr s_pWNetOpenEnum;
66 static WNetEnumResourcePtr s_pWNetEnumResource;
67 static WNetCloseEnumPtr s_pWNetCloseEnum;
68
69 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
70 // Globals/Statics
71 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
72 static long s_cancelSearch = FALSE;
73
74 struct FileInfo
75 {
76 FileInfo(unsigned flag=0, wxFSVolumeKind type=wxFS_VOL_OTHER) :
77 m_flags(flag), m_type(type) {}
78
79 FileInfo(const FileInfo& other) { *this = other; }
80 FileInfo& operator=(const FileInfo& other)
81 {
82 m_flags = other.m_flags;
83 m_type = other.m_type;
84 return *this;
85 }
86
87 unsigned m_flags;
88 wxFSVolumeKind m_type;
89 };
90 WX_DECLARE_STRING_HASH_MAP(FileInfo, FileInfoMap);
91 // Cygwin bug (?) destructor for global s_fileInfo is called twice...
92 static FileInfoMap& GetFileInfoMap()
93 {
94 static FileInfoMap s_fileInfo(25);
95
96 return s_fileInfo;
97 }
98 #define s_fileInfo (GetFileInfoMap())
99
100 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
101 // Local helper functions.
102 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
103
104 //=============================================================================
105 // Function: GetBasicFlags
106 // Purpose: Set basic flags, primarily wxFS_VOL_REMOTE and wxFS_VOL_REMOVABLE.
107 // Notes: - Local and mapped drives are mounted by definition. We have no
108 // way to determine mounted status of network drives, so assume that
109 // all drives are mounted, and let the caller decide otherwise.
110 // - Other flags are 'best guess' from type of drive. The system will
111 // not report the file attributes with any degree of accuracy.
112 //=============================================================================
113 static unsigned GetBasicFlags(const wxChar* filename)
114 {
115 unsigned flags = wxFS_VOL_MOUNTED;
116
117 //----------------------------------
118 // 'Best Guess' based on drive type.
119 //----------------------------------
120 wxFSVolumeKind type;
121 switch(GetDriveType(filename))
122 {
123 case DRIVE_FIXED:
124 type = wxFS_VOL_DISK;
125 break;
126
127 case DRIVE_REMOVABLE:
128 flags |= wxFS_VOL_REMOVABLE;
129 type = wxFS_VOL_FLOPPY;
130 break;
131
132 case DRIVE_CDROM:
133 flags |= wxFS_VOL_REMOVABLE | wxFS_VOL_READONLY;
134 type = wxFS_VOL_CDROM;
135 break;
136
137 case DRIVE_REMOTE:
138 flags |= wxFS_VOL_REMOTE;
139 type = wxFS_VOL_NETWORK;
140 break;
141
142 case DRIVE_NO_ROOT_DIR:
143 flags &= ~wxFS_VOL_MOUNTED;
144 type = wxFS_VOL_OTHER;
145 break;
146
147 default:
148 type = wxFS_VOL_OTHER;
149 break;
150 }
151
152 //-----------------------------------------------------------------------
153 // The following most likely will not modify anything not set above,
154 // and will not work at all for network shares or empty CD ROM drives.
155 // But it is a good check if the Win API ever gets better about reporting
156 // this information.
157 //-----------------------------------------------------------------------
158 SHFILEINFO fi;
159 long rc = SHGetFileInfo(filename, 0, &fi, sizeof(fi), SHGFI_ATTRIBUTES);
160 if (!rc)
161 {
162 // this error is not fatal, so don't show a message to the user about
163 // it, otherwise it would appear every time a generic directory picker
164 // dialog is used and there is a connected network drive
165 wxLogLastError(wxT("SHGetFileInfo"));
166 }
167 else
168 {
169 if (fi.dwAttributes & SFGAO_READONLY)
170 flags |= wxFS_VOL_READONLY;
171 if (fi.dwAttributes & SFGAO_REMOVABLE)
172 flags |= wxFS_VOL_REMOVABLE;
173 }
174
175 //------------------
176 // Flags are cached.
177 //------------------
178 s_fileInfo[filename] = FileInfo(flags, type);
179
180 return flags;
181 } // GetBasicFlags
182
183 //=============================================================================
184 // Function: FilteredAdd
185 // Purpose: Add a file to the list if it meets the filter requirement.
186 // Notes: - See GetBasicFlags for remarks about the Mounted flag.
187 //=============================================================================
188 static bool FilteredAdd(wxArrayString& list, const wxChar* filename,
189 unsigned flagsSet, unsigned flagsUnset)
190 {
191 bool accept = true;
192 unsigned flags = GetBasicFlags(filename);
193
194 if (flagsSet & wxFS_VOL_MOUNTED && !(flags & wxFS_VOL_MOUNTED))
195 accept = false;
196 else if (flagsUnset & wxFS_VOL_MOUNTED && (flags & wxFS_VOL_MOUNTED))
197 accept = false;
198 else if (flagsSet & wxFS_VOL_REMOVABLE && !(flags & wxFS_VOL_REMOVABLE))
199 accept = false;
200 else if (flagsUnset & wxFS_VOL_REMOVABLE && (flags & wxFS_VOL_REMOVABLE))
201 accept = false;
202 else if (flagsSet & wxFS_VOL_READONLY && !(flags & wxFS_VOL_READONLY))
203 accept = false;
204 else if (flagsUnset & wxFS_VOL_READONLY && (flags & wxFS_VOL_READONLY))
205 accept = false;
206 else if (flagsSet & wxFS_VOL_REMOTE && !(flags & wxFS_VOL_REMOTE))
207 accept = false;
208 else if (flagsUnset & wxFS_VOL_REMOTE && (flags & wxFS_VOL_REMOTE))
209 accept = false;
210
211 // Add to the list if passed the filter.
212 if (accept)
213 list.Add(filename);
214
215 return accept;
216 } // FilteredAdd
217
218 //=============================================================================
219 // Function: BuildListFromNN
220 // Purpose: Append or remove items from the list
221 // Notes: - There is no way to find all disconnected NN items, or even to find
222 // all items while determining which are connected and not. So this
223 // function will find either all items or connected items.
224 //=============================================================================
225 static void BuildListFromNN(wxArrayString& list, NETRESOURCE* pResSrc,
226 unsigned flagsSet, unsigned flagsUnset)
227 {
228 HANDLE hEnum;
229 int rc;
230
231 //-----------------------------------------------
232 // Scope may be all drives or all mounted drives.
233 //-----------------------------------------------
234 unsigned scope = RESOURCE_GLOBALNET;
235 if (flagsSet & wxFS_VOL_MOUNTED)
236 scope = RESOURCE_CONNECTED;
237
238 //----------------------------------------------------------------------
239 // Enumerate all items, adding only non-containers (ie. network shares).
240 // Containers cause a recursive call to this function for their own
241 // enumeration.
242 //----------------------------------------------------------------------
243 if (rc = s_pWNetOpenEnum(scope, RESOURCETYPE_DISK, 0, pResSrc, &hEnum), rc == NO_ERROR)
244 {
245 DWORD count = 1;
246 DWORD size = 256;
247 NETRESOURCE* pRes = (NETRESOURCE*)malloc(size);
248 memset(pRes, 0, sizeof(NETRESOURCE));
249 while (rc = s_pWNetEnumResource(hEnum, &count, pRes, &size), rc == NO_ERROR || rc == ERROR_MORE_DATA)
250 {
251 if (s_cancelSearch)
252 break;
253
254 if (rc == ERROR_MORE_DATA)
255 {
256 pRes = (NETRESOURCE*)realloc(pRes, size);
257 count = 1;
258 }
259 else if (count == 1)
260 {
261 // Enumerate the container.
262 if (pRes->dwUsage & RESOURCEUSAGE_CONTAINER)
263 {
264 BuildListFromNN(list, pRes, flagsSet, flagsUnset);
265 }
266
267 // Add the network share.
268 else
269 {
270 wxString filename(pRes->lpRemoteName);
271
272 // if the drive is unavailable, FilteredAdd() can hang for
273 // a long time and, moreover, its failure appears to be not
274 // cached so this will happen every time we use it, so try
275 // a much quicker wxDirExists() test (which still hangs but
276 // for much shorter time) for locally mapped drives first
277 // to try to avoid this
278 if ( pRes->lpLocalName &&
279 *pRes->lpLocalName &&
280 !wxDirExists(pRes->lpLocalName) )
281 continue;
282
283 if (!filename.empty())
284 {
285 if (filename.Last() != '\\')
286 filename.Append('\\');
287
288 // The filter function will not know mounted from unmounted, and neither do we unless
289 // we are iterating using RESOURCE_CONNECTED, in which case they all are mounted.
290 // Volumes on disconnected servers, however, will correctly show as unmounted.
291 FilteredAdd(list, filename.t_str(), flagsSet, flagsUnset&~wxFS_VOL_MOUNTED);
292 if (scope == RESOURCE_GLOBALNET)
293 s_fileInfo[filename].m_flags &= ~wxFS_VOL_MOUNTED;
294 }
295 }
296 }
297 else if (count == 0)
298 break;
299 }
300 free(pRes);
301 s_pWNetCloseEnum(hEnum);
302 }
303 } // BuildListFromNN
304
305 //=============================================================================
306 // Function: CompareFcn
307 // Purpose: Used to sort the NN list alphabetically, case insensitive.
308 //=============================================================================
309 static int CompareFcn(const wxString& first, const wxString& second)
310 {
311 return wxStricmp(first.c_str(), second.c_str());
312 } // CompareFcn
313
314 //=============================================================================
315 // Function: BuildRemoteList
316 // Purpose: Append Network Neighborhood items to the list.
317 // Notes: - Mounted gets transalated into Connected. FilteredAdd is told
318 // to ignore the Mounted flag since we need to handle it in a weird
319 // way manually.
320 // - The resulting list is sorted alphabetically.
321 //=============================================================================
322 static bool BuildRemoteList(wxArrayString& list, NETRESOURCE* pResSrc,
323 unsigned flagsSet, unsigned flagsUnset)
324 {
325 // NN query depends on dynamically loaded library.
326 if (!s_pWNetOpenEnum || !s_pWNetEnumResource || !s_pWNetCloseEnum)
327 {
328 wxLogError(_("Failed to load mpr.dll."));
329 return false;
330 }
331
332 // Don't waste time doing the work if the flags conflict.
333 if (flagsSet & wxFS_VOL_MOUNTED && flagsUnset & wxFS_VOL_MOUNTED)
334 return false;
335
336 //----------------------------------------------
337 // Generate the list according to the flags set.
338 //----------------------------------------------
339 BuildListFromNN(list, pResSrc, flagsSet, flagsUnset);
340 list.Sort(CompareFcn);
341
342 //-------------------------------------------------------------------------
343 // If mounted only is requested, then we only need one simple pass.
344 // Otherwise, we need to build a list of all NN volumes and then apply the
345 // list of mounted drives to it.
346 //-------------------------------------------------------------------------
347 if (!(flagsSet & wxFS_VOL_MOUNTED))
348 {
349 // generate.
350 wxArrayString mounted;
351 BuildListFromNN(mounted, pResSrc, flagsSet | wxFS_VOL_MOUNTED, flagsUnset & ~wxFS_VOL_MOUNTED);
352 mounted.Sort(CompareFcn);
353
354 // apply list from bottom to top to preserve indexes if removing items.
355 ssize_t iList = list.GetCount()-1;
356 for (ssize_t iMounted = mounted.GetCount()-1; iMounted >= 0 && iList >= 0; iMounted--)
357 {
358 int compare;
359 wxString all(list[iList]);
360 wxString mount(mounted[iMounted]);
361
362 while (compare =
363 wxStricmp(list[iList].c_str(), mounted[iMounted].c_str()),
364 compare > 0 && iList >= 0)
365 {
366 iList--;
367 all = list[iList];
368 }
369
370
371 if (compare == 0)
372 {
373 // Found the element. Remove it or mark it mounted.
374 if (flagsUnset & wxFS_VOL_MOUNTED)
375 list.RemoveAt(iList);
376 else
377 s_fileInfo[list[iList]].m_flags |= wxFS_VOL_MOUNTED;
378
379 }
380
381 iList--;
382 }
383 }
384
385 return true;
386 } // BuildRemoteList
387
388 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
389 // wxFSVolume
390 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
391
392 //=============================================================================
393 // Function: GetVolumes
394 // Purpose: Generate and return a list of all volumes (drives) available.
395 // Notes:
396 //=============================================================================
397 wxArrayString wxFSVolumeBase::GetVolumes(int flagsSet, int flagsUnset)
398 {
399 ::InterlockedExchange(&s_cancelSearch, FALSE); // reset
400
401 #if wxUSE_DYNLIB_CLASS
402 if (!s_mprLib.IsLoaded() && s_mprLib.Load(wxT("mpr.dll")))
403 {
404 #ifdef UNICODE
405 s_pWNetOpenEnum = (WNetOpenEnumPtr)s_mprLib.GetSymbol(wxT("WNetOpenEnumW"));
406 s_pWNetEnumResource = (WNetEnumResourcePtr)s_mprLib.GetSymbol(wxT("WNetEnumResourceW"));
407 #else
408 s_pWNetOpenEnum = (WNetOpenEnumPtr)s_mprLib.GetSymbol(wxT("WNetOpenEnumA"));
409 s_pWNetEnumResource = (WNetEnumResourcePtr)s_mprLib.GetSymbol(wxT("WNetEnumResourceA"));
410 #endif
411 s_pWNetCloseEnum = (WNetCloseEnumPtr)s_mprLib.GetSymbol(wxT("WNetCloseEnum"));
412 }
413 #endif
414
415 wxArrayString list;
416
417 //-------------------------------
418 // Local and mapped drives first.
419 //-------------------------------
420 // Allocate the required space for the API call.
421 const DWORD chars = GetLogicalDriveStrings(0, NULL);
422 TCHAR* buf = new TCHAR[chars+1];
423
424 // Get the list of drives.
425 GetLogicalDriveStrings(chars, buf);
426
427 // Parse the list into an array, applying appropriate filters.
428 TCHAR *pVol;
429 pVol = buf;
430 while (*pVol)
431 {
432 FilteredAdd(list, pVol, flagsSet, flagsUnset);
433 pVol = pVol + wxStrlen(pVol) + 1;
434 }
435
436 // Cleanup.
437 delete[] buf;
438
439 //---------------------------
440 // Network Neighborhood next.
441 //---------------------------
442
443 // not exclude remote and not removable
444 if (!(flagsUnset & wxFS_VOL_REMOTE) &&
445 !(flagsSet & wxFS_VOL_REMOVABLE)
446 )
447 {
448 // The returned list will be sorted alphabetically. We don't pass
449 // our in since we don't want to change to order of the local drives.
450 wxArrayString nn;
451 if (BuildRemoteList(nn, 0, flagsSet, flagsUnset))
452 {
453 for (size_t idx = 0; idx < nn.GetCount(); idx++)
454 list.Add(nn[idx]);
455 }
456 }
457
458 return list;
459 } // GetVolumes
460
461 //=============================================================================
462 // Function: CancelSearch
463 // Purpose: Instruct an active search to stop.
464 // Notes: - This will only sensibly be called by a thread other than the one
465 // performing the search. This is the only thread-safe function
466 // provided by the class.
467 //=============================================================================
468 void wxFSVolumeBase::CancelSearch()
469 {
470 ::InterlockedExchange(&s_cancelSearch, TRUE);
471 } // CancelSearch
472
473 //=============================================================================
474 // Function: constructor
475 // Purpose: default constructor
476 //=============================================================================
477 wxFSVolumeBase::wxFSVolumeBase()
478 {
479 m_isOk = false;
480 } // wxVolume
481
482 //=============================================================================
483 // Function: constructor
484 // Purpose: constructor that calls Create
485 //=============================================================================
486 wxFSVolumeBase::wxFSVolumeBase(const wxString& name)
487 {
488 Create(name);
489 } // wxVolume
490
491 //=============================================================================
492 // Function: Create
493 // Purpose: Finds, logs in, etc. to the request volume.
494 //=============================================================================
495 bool wxFSVolumeBase::Create(const wxString& name)
496 {
497 // assume fail.
498 m_isOk = false;
499
500 // supplied.
501 m_volName = name;
502
503 // Display name.
504 SHFILEINFO fi;
505 long rc = SHGetFileInfo(m_volName.t_str(), 0, &fi, sizeof(fi), SHGFI_DISPLAYNAME);
506 if (!rc)
507 {
508 wxLogError(_("Cannot read typename from '%s'!"), m_volName.c_str());
509 return false;
510 }
511 m_dispName = fi.szDisplayName;
512
513 // all tests passed.
514 m_isOk = true;
515 return true;
516 } // Create
517
518 //=============================================================================
519 // Function: IsOk
520 // Purpose: returns true if the volume is legal.
521 // Notes: For fixed disks, it must exist. For removable disks, it must also
522 // be present. For Network Shares, it must also be logged in, etc.
523 //=============================================================================
524 bool wxFSVolumeBase::IsOk() const
525 {
526 return m_isOk;
527 } // IsOk
528
529 //=============================================================================
530 // Function: GetKind
531 // Purpose: Return the type of the volume.
532 //=============================================================================
533 wxFSVolumeKind wxFSVolumeBase::GetKind() const
534 {
535 if (!m_isOk)
536 return wxFS_VOL_OTHER;
537
538 FileInfoMap::iterator itr = s_fileInfo.find(m_volName);
539 if (itr == s_fileInfo.end())
540 return wxFS_VOL_OTHER;
541
542 return itr->second.m_type;
543 }
544
545 //=============================================================================
546 // Function: GetFlags
547 // Purpose: Return the caches flags for this volume.
548 // Notes: - Returns -1 if no flags were cached.
549 //=============================================================================
550 int wxFSVolumeBase::GetFlags() const
551 {
552 if (!m_isOk)
553 return -1;
554
555 FileInfoMap::iterator itr = s_fileInfo.find(m_volName);
556 if (itr == s_fileInfo.end())
557 return -1;
558
559 return itr->second.m_flags;
560 } // GetFlags
561
562 #endif // wxUSE_BASE
563
564 // ============================================================================
565 // wxFSVolume
566 // ============================================================================
567
568 #if wxUSE_GUI
569
570 void wxFSVolume::InitIcons()
571 {
572 m_icons.Alloc(wxFS_VOL_ICO_MAX);
573 wxIcon null;
574 for (int idx = 0; idx < wxFS_VOL_ICO_MAX; idx++)
575 m_icons.Add(null);
576 }
577
578 //=============================================================================
579 // Function: GetIcon
580 // Purpose: return the requested icon.
581 //=============================================================================
582
583 wxIcon wxFSVolume::GetIcon(wxFSIconType type) const
584 {
585 wxCHECK_MSG( type >= 0 && (size_t)type < m_icons.GetCount(), wxNullIcon,
586 wxT("wxFSIconType::GetIcon(): invalid icon index") );
587
588 #ifdef __WXMSW__
589 // Load on demand.
590 if (m_icons[type].IsNull())
591 {
592 UINT flags = SHGFI_ICON;
593 switch (type)
594 {
595 case wxFS_VOL_ICO_SMALL:
596 flags |= SHGFI_SMALLICON;
597 break;
598
599 case wxFS_VOL_ICO_LARGE:
600 flags |= SHGFI_SHELLICONSIZE;
601 break;
602
603 case wxFS_VOL_ICO_SEL_SMALL:
604 flags |= SHGFI_SMALLICON | SHGFI_OPENICON;
605 break;
606
607 case wxFS_VOL_ICO_SEL_LARGE:
608 flags |= SHGFI_SHELLICONSIZE | SHGFI_OPENICON;
609 break;
610
611 case wxFS_VOL_ICO_MAX:
612 wxFAIL_MSG(wxT("wxFS_VOL_ICO_MAX is not valid icon type"));
613 break;
614 }
615
616 SHFILEINFO fi;
617 long rc = SHGetFileInfo(m_volName.t_str(), 0, &fi, sizeof(fi), flags);
618 m_icons[type].SetHICON((WXHICON)fi.hIcon);
619 if (!rc || !fi.hIcon)
620 {
621 wxLogError(_("Cannot load icon from '%s'."), m_volName.c_str());
622 }
623 }
624
625 return m_icons[type];
626 #else
627 wxFAIL_MSG(wxS("Can't convert HICON to wxIcon in this port."));
628 return wxNullIcon;
629 #endif
630 } // GetIcon
631
632 #endif // wxUSE_GUI
633
634 #endif // wxUSE_FSVOLUME