ReactOS  0.4.15-dev-1377-ga59cecd
CDrivesFolder.cpp
Go to the documentation of this file.
1 /*
2  * Virtual Workplace folder
3  *
4  * Copyright 1997 Marcus Meissner
5  * Copyright 1998, 1999, 2002 Juergen Schmied
6  * Copyright 2009 Andrew Hill
7  * Copyright 2017-2019 Katayama Hirofumi MZ
8  *
9  * This library is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * This library is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with this library; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22  */
23 
24 #include <precomp.h>
25 #include <process.h>
26 
28 
29 /*
30 CDrivesFolder should create a CRegFolder to represent the virtual items that exist only in
31 the registry. The CRegFolder is aggregated by the CDrivesFolder.
32 The CDrivesFolderEnum class should enumerate only drives on the system. Since the CRegFolder
33 implementation of IShellFolder::EnumObjects enumerates the virtual items, the
34 CDrivesFolderEnum is only responsible for returning the physical items.
35 
36 2. At least on my XP system, the drive pidls returned are of type PT_DRIVE1, not PT_DRIVE
37 3. The parsing name returned for my computer is incorrect. It should be "My Computer"
38 */
39 
40 static int iDriveIconIds[7] = { IDI_SHELL_DRIVE, /* DRIVE_UNKNOWN */
41  IDI_SHELL_CDROM, /* DRIVE_NO_ROOT_DIR*/
42  IDI_SHELL_3_14_FLOPPY, /* DRIVE_REMOVABLE*/
43  IDI_SHELL_DRIVE, /* DRIVE_FIXED*/
44  IDI_SHELL_NETDRIVE, /* DRIVE_REMOTE*/
45  IDI_SHELL_CDROM, /* DRIVE_CDROM*/
46  IDI_SHELL_RAMDISK /* DRIVE_RAMDISK*/
47  };
48 
49 static int iDriveTypeIds[7] = { IDS_DRIVE_FIXED, /* DRIVE_UNKNOWN */
50  IDS_DRIVE_FIXED, /* DRIVE_NO_ROOT_DIR*/
51  IDS_DRIVE_FLOPPY, /* DRIVE_REMOVABLE*/
52  IDS_DRIVE_FIXED, /* DRIVE_FIXED*/
53  IDS_DRIVE_NETWORK, /* DRIVE_REMOTE*/
54  IDS_DRIVE_CDROM, /* DRIVE_CDROM*/
55  IDS_DRIVE_FIXED /* DRIVE_RAMDISK*/
56  };
57 
58 /***********************************************************************
59 * IShellFolder implementation
60 */
61 
62 #define RETRY_COUNT 3
63 #define RETRY_SLEEP 250
64 static BOOL TryToLockOrUnlockDrive(HANDLE hDrive, BOOL bLock)
65 {
66  DWORD dwError, dwBytesReturned;
67  DWORD dwCode = (bLock ? FSCTL_LOCK_VOLUME : FSCTL_UNLOCK_VOLUME);
68  for (DWORD i = 0; i < RETRY_COUNT; ++i)
69  {
70  if (DeviceIoControl(hDrive, dwCode, NULL, 0, NULL, 0, &dwBytesReturned, NULL))
71  return TRUE;
72 
73  dwError = GetLastError();
74  if (dwError == ERROR_INVALID_FUNCTION)
75  break; /* don't sleep if function is not implemented */
76 
78  }
79  SetLastError(dwError);
80  return FALSE;
81 }
82 
83 // NOTE: See also https://support.microsoft.com/en-us/help/165721/how-to-ejecting-removable-media-in-windows-nt-windows-2000-windows-xp
84 static BOOL DoEjectDrive(const WCHAR *physical, UINT nDriveType, INT *pnStringID)
85 {
86  /* GENERIC_WRITE isn't needed for umount */
87  DWORD dwAccessMode = GENERIC_READ;
88  DWORD dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE;
89 
90  HANDLE hDrive = CreateFile(physical, dwAccessMode, dwShareMode, 0, OPEN_EXISTING, 0, NULL);
91  if (hDrive == INVALID_HANDLE_VALUE)
92  return FALSE;
93 
94  BOOL bResult, bNeedUnlock = FALSE;
95  DWORD dwBytesReturned, dwError = NO_ERROR;
96  PREVENT_MEDIA_REMOVAL removal;
97  do
98  {
99  bResult = TryToLockOrUnlockDrive(hDrive, TRUE);
100  if (!bResult)
101  {
102  dwError = GetLastError();
103  *pnStringID = IDS_CANTLOCKVOLUME; /* Unable to lock volume */
104  break;
105  }
106  bResult = DeviceIoControl(hDrive, FSCTL_DISMOUNT_VOLUME, NULL, 0, NULL, 0, &dwBytesReturned, NULL);
107  if (!bResult)
108  {
109  dwError = GetLastError();
110  *pnStringID = IDS_CANTDISMOUNTVOLUME; /* Unable to dismount volume */
111  bNeedUnlock = TRUE;
112  break;
113  }
114  removal.PreventMediaRemoval = FALSE;
115  bResult = DeviceIoControl(hDrive, IOCTL_STORAGE_MEDIA_REMOVAL, &removal, sizeof(removal), NULL,
116  0, &dwBytesReturned, NULL);
117  if (!bResult)
118  {
119  *pnStringID = IDS_CANTEJECTMEDIA; /* Unable to eject media */
120  dwError = GetLastError();
121  bNeedUnlock = TRUE;
122  break;
123  }
124  bResult = DeviceIoControl(hDrive, IOCTL_STORAGE_EJECT_MEDIA, NULL, 0, NULL, 0, &dwBytesReturned, NULL);
125  if (!bResult)
126  {
127  *pnStringID = IDS_CANTEJECTMEDIA; /* Unable to eject media */
128  dwError = GetLastError();
129  bNeedUnlock = TRUE;
130  break;
131  }
132  } while (0);
133 
134  if (bNeedUnlock)
135  {
136  TryToLockOrUnlockDrive(hDrive, FALSE);
137  }
138 
139  CloseHandle(hDrive);
140 
141  SetLastError(dwError);
142  return bResult;
143 }
144 
145 // A callback function for finding the stub windows.
146 static BOOL CALLBACK
148 {
149  CSimpleArray<HWND> *pStubs = reinterpret_cast<CSimpleArray<HWND> *>(lParam);
150 
151  WCHAR szClass[64];
152  GetClassNameW(hwnd, szClass, _countof(szClass));
153 
154  if (lstrcmpiW(szClass, L"StubWindow32") == 0)
155  {
156  pStubs->Add(hwnd);
157  }
158 
159  return TRUE;
160 }
161 
162 // Another callback function to find the owned window of the stub window.
163 static BOOL CALLBACK
165 {
166  HWND *phwnd = reinterpret_cast<HWND *>(lParam);
167 
168  if (phwnd[0] == GetWindow(hwnd, GW_OWNER))
169  {
170  phwnd[1] = hwnd;
171  return FALSE;
172  }
173 
174  return TRUE;
175 }
176 
177 // Parameters for format_drive_thread function below.
179 {
181 };
182 
183 static unsigned __stdcall format_drive_thread(void *args)
184 {
186  UINT nDriveNumber = params->nDriveNumber;
187  LONG_PTR nProp = nDriveNumber | 0x7F00;
188 
189  // Search the stub windows that already exist.
190  CSimpleArray<HWND> old_stubs;
191  EnumWindows(EnumStubProc, (LPARAM)&old_stubs);
192 
193  for (INT n = 0; n < old_stubs.GetSize(); ++n)
194  {
195  HWND hwndStub = old_stubs[n];
196 
197  // The target stub window has the prop.
198  if (GetPropW(hwndStub, L"DriveNumber") == (HANDLE)nProp)
199  {
200  // Found.
201  HWND ahwnd[2];
202  ahwnd[0] = hwndStub;
203  ahwnd[1] = NULL;
205 
206  // Activate.
207  BringWindowToTop(ahwnd[1]);
208 
209  delete params;
210  return 0;
211  }
212  }
213 
214  // Create a stub window.
218  if (!stub.Create(NULL, NULL, NULL, style, exstyle))
219  {
220  ERR("StubWindow32 creation failed\n");
221  delete params;
222  return 0;
223  }
224 
225  // Add prop to the target stub window.
226  SetPropW(stub, L"DriveNumber", (HANDLE)nProp);
227 
228  // Do format.
229  SHFormatDrive(stub, nDriveNumber, SHFMT_ID_DEFAULT, 0);
230 
231  // Clean up.
232  RemovePropW(stub, L"DriveNumber");
233  stub.DestroyWindow();
234  delete params;
235 
236  return 0;
237 }
238 
239 static HRESULT DoFormatDrive(HWND hwnd, UINT nDriveNumber)
240 {
242  params->nDriveNumber = nDriveNumber;
243 
244  // Create thread to avoid locked.
245  unsigned tid;
247  if (hThread == NULL)
248  {
249  delete params;
250  return E_FAIL;
251  }
252 
254 
255  return S_OK;
256 }
257 
259  HWND hwnd,
260  IDataObject *pdtobj,
261  UINT uMsg,
262  WPARAM wParam,
263  LPARAM lParam)
264 {
265  if (uMsg != DFM_MERGECONTEXTMENU && uMsg != DFM_INVOKECOMMAND)
266  return S_OK;
267 
268  PIDLIST_ABSOLUTE pidlFolder;
269  PUITEMID_CHILD *apidl;
270  UINT cidl;
271  UINT nDriveType;
272  DWORD dwFlags;
273  HRESULT hr = SH_GetApidlFromDataObject(pdtobj, &pidlFolder, &apidl, &cidl);
274  if (FAILED_UNEXPECTEDLY(hr))
275  return hr;
276 
277  char szDrive[8] = {0};
278  if (!_ILGetDrive(apidl[0], szDrive, sizeof(szDrive)))
279  {
280  ERR("pidl is not a drive\n");
281  SHFree(pidlFolder);
282  _ILFreeaPidl(apidl, cidl);
283  return E_FAIL;
284  }
285  nDriveType = GetDriveTypeA(szDrive);
286  GetVolumeInformationA(szDrive, NULL, 0, NULL, NULL, &dwFlags, NULL, 0);
287 
288 // custom command IDs
289 #define CMDID_FORMAT 1
290 #define CMDID_EJECT 2
291 #define CMDID_DISCONNECT 3
292 
293  if (uMsg == DFM_MERGECONTEXTMENU)
294  {
295  QCMINFO *pqcminfo = (QCMINFO *)lParam;
296 
297  UINT idCmdFirst = pqcminfo->idCmdFirst;
298  if (!(dwFlags & FILE_READ_ONLY_VOLUME) && nDriveType != DRIVE_REMOTE)
299  {
300  /* add separator and Format */
301  UINT idCmd = idCmdFirst + CMDID_FORMAT;
302  _InsertMenuItemW(pqcminfo->hmenu, pqcminfo->indexMenu++, TRUE, 0, MFT_SEPARATOR, NULL, 0);
304  }
305  if (nDriveType == DRIVE_REMOVABLE || nDriveType == DRIVE_CDROM)
306  {
307  /* add separator and Eject */
308  UINT idCmd = idCmdFirst + CMDID_EJECT;
309  _InsertMenuItemW(pqcminfo->hmenu, pqcminfo->indexMenu++, TRUE, 0, MFT_SEPARATOR, NULL, 0);
311  }
312  if (nDriveType == DRIVE_REMOTE)
313  {
314  /* add separator and Disconnect */
315  UINT idCmd = idCmdFirst + CMDID_DISCONNECT;
316  _InsertMenuItemW(pqcminfo->hmenu, pqcminfo->indexMenu++, TRUE, 0, MFT_SEPARATOR, NULL, 0);
318  }
319 
320  pqcminfo->idCmdFirst += 3;
321  }
322  else if (uMsg == DFM_INVOKECOMMAND)
323  {
324  WCHAR wszBuf[4] = L"A:\\";
325  wszBuf[0] = (WCHAR)szDrive[0];
326 
327  INT nStringID = 0;
328  DWORD dwError = NO_ERROR;
329 
330  if (wParam == DFM_CMD_PROPERTIES)
331  {
332  hr = SH_ShowDriveProperties(wszBuf, pidlFolder, apidl);
333  if (FAILED(hr))
334  {
335  dwError = ERROR_CAN_NOT_COMPLETE;
336  nStringID = IDS_CANTSHOWPROPERTIES;
337  }
338  }
339  else
340  {
341  if (wParam == CMDID_FORMAT)
342  {
343  hr = DoFormatDrive(hwnd, szDrive[0] - 'A');
344  }
345  else if (wParam == CMDID_EJECT)
346  {
347  /* do eject */
348  WCHAR physical[10];
349  wsprintfW(physical, _T("\\\\.\\%c:"), szDrive[0]);
350 
351  if (DoEjectDrive(physical, nDriveType, &nStringID))
352  {
354  }
355  else
356  {
357  dwError = GetLastError();
358  }
359  }
360  else if (wParam == CMDID_DISCONNECT)
361  {
362  /* do disconnect */
363  wszBuf[2] = UNICODE_NULL;
364  dwError = WNetCancelConnection2W(wszBuf, 0, FALSE);
365  if (dwError == NO_ERROR)
366  {
368  }
369  else
370  {
371  nStringID = IDS_CANTDISCONNECT;
372  }
373  }
374  }
375 
376  if (nStringID != 0)
377  {
378  /* show error message */
379  WCHAR szFormat[128], szMessage[128];
380  LoadStringW(shell32_hInstance, nStringID, szFormat, _countof(szFormat));
381  wsprintfW(szMessage, szFormat, dwError);
382  MessageBoxW(hwnd, szMessage, NULL, MB_ICONERROR);
383  }
384  }
385 
386  SHFree(pidlFolder);
387  _ILFreeaPidl(apidl, cidl);
388 
389  return hr;
390 }
391 
393  HWND hwnd,
394  UINT cidl,
395  PCUITEMID_CHILD_ARRAY apidl,
396  IShellFolder *psf,
397  IContextMenu **ppcm)
398 {
399  HKEY hKeys[2];
400  UINT cKeys = 0;
401  AddClassKeyToArray(L"Drive", hKeys, &cKeys);
402  AddClassKeyToArray(L"Folder", hKeys, &cKeys);
403 
404  return CDefFolderMenu_Create2(pidlFolder, hwnd, cidl, apidl, psf, DrivesContextMenuCallback, cKeys, hKeys, ppcm);
405 }
406 
407 static HRESULT
409  LPWSTR szIconFile, UINT cchMax, int *piIndex, UINT *pwFlags)
410 {
411  WCHAR wszPath[MAX_PATH];
412  WCHAR wszAutoRunInfPath[MAX_PATH];
413  WCHAR wszValue[MAX_PATH], wszTemp[MAX_PATH];
414  static const WCHAR wszAutoRunInf[] = { 'a','u','t','o','r','u','n','.','i','n','f',0 };
415  static const WCHAR wszAutoRun[] = { 'a','u','t','o','r','u','n',0 };
416 
417  // get path
418  if (!ILGetDisplayNameExW(psf, pidl, wszPath, 0))
419  return E_FAIL;
420  if (!PathIsDirectoryW(wszPath))
421  return E_FAIL;
422 
423  // build the full path of autorun.inf
424  StringCchCopyW(wszAutoRunInfPath, _countof(wszAutoRunInfPath), wszPath);
425  PathAppendW(wszAutoRunInfPath, wszAutoRunInf);
426 
427  // autorun.inf --> wszValue
428  if (GetPrivateProfileStringW(wszAutoRun, L"icon", NULL, wszValue, _countof(wszValue),
429  wszAutoRunInfPath) && wszValue[0] != 0)
430  {
431  // wszValue --> wszTemp
432  ExpandEnvironmentStringsW(wszValue, wszTemp, _countof(wszTemp));
433 
434  // parse the icon location
435  *piIndex = PathParseIconLocationW(wszTemp);
436 
437  // wszPath + wszTemp --> wszPath
438  if (PathIsRelativeW(wszTemp))
439  PathAppendW(wszPath, wszTemp);
440  else
441  StringCchCopyW(wszPath, _countof(wszPath), wszTemp);
442 
443  // wszPath --> szIconFile
444  GetFullPathNameW(wszPath, cchMax, szIconFile, NULL);
445 
446  return S_OK;
447  }
448 
449  return E_FAIL;
450 }
451 
452 BOOL IsDriveFloppyA(LPCSTR pszDriveRoot);
453 
455 {
456  CComPtr<IDefaultExtractIconInit> initIcon;
458  if (FAILED_UNEXPECTEDLY(hr))
459  return hr;
460 
461  CHAR* pszDrive = _ILGetDataPointer(pidl)->u.drive.szDriveName;
462  UINT DriveType = GetDriveTypeA(pszDrive);
463  if (DriveType > DRIVE_RAMDISK)
465 
466  WCHAR wTemp[MAX_PATH];
467  int icon_idx;
468  UINT flags = 0;
469  if ((DriveType == DRIVE_FIXED || DriveType == DRIVE_UNKNOWN) &&
470  (HCR_GetIconW(L"Drive", wTemp, NULL, MAX_PATH, &icon_idx)))
471  {
472  initIcon->SetNormalIcon(wTemp, icon_idx);
473  }
474  else if (SUCCEEDED(getIconLocationForDrive(psf, pidl, 0, wTemp, _countof(wTemp),
475  &icon_idx, &flags)))
476  {
477  initIcon->SetNormalIcon(wTemp, icon_idx);
478  }
479  else
480  {
481  if (DriveType == DRIVE_REMOVABLE && !IsDriveFloppyA(pszDrive))
482  {
483  icon_idx = IDI_SHELL_REMOVEABLE;
484  }
485  else
486  {
487  icon_idx = iDriveIconIds[DriveType];
488  }
489  initIcon->SetNormalIcon(swShell32Name, -icon_idx);
490  }
491 
492  return initIcon->QueryInterface(riid, ppvOut);
493 }
494 
496  public CEnumIDListBase
497 {
498  public:
499  HRESULT WINAPI Initialize(HWND hwndOwner, DWORD dwFlags, IEnumIDList* pRegEnumerator)
500  {
501  /* enumerate the folders */
502  if (dwFlags & SHCONTF_FOLDERS)
503  {
504  WCHAR wszDriveName[] = {'A', ':', '\\', '\0'};
505  DWORD dwDrivemap = GetLogicalDrives();
506 
507  while (wszDriveName[0] <= 'Z')
508  {
509  if(dwDrivemap & 0x00000001L)
510  AddToEnumList(_ILCreateDrive(wszDriveName));
511  wszDriveName[0]++;
512  dwDrivemap = dwDrivemap >> 1;
513  }
514  }
515 
516  /* Enumerate the items of the reg folder */
517  AppendItemsFromEnumerator(pRegEnumerator);
518 
519  return S_OK;
520  }
521 
523  COM_INTERFACE_ENTRY_IID(IID_IEnumIDList, IEnumIDList)
524  END_COM_MAP()
525 };
526 
527 /***********************************************************************
528 * IShellFolder [MyComputer] implementation
529 */
530 
531 static const shvheader MyComputerSFHeader[] = {
537 };
538 
539 #define MYCOMPUTERSHELLVIEWCOLUMNS 5
540 
542  SFGAO_CANRENAME | SFGAO_CANDELETE | SFGAO_HASPROPSHEET | SFGAO_DROPTARGET |
543  SFGAO_FILESYSANCESTOR | SFGAO_FOLDER | SFGAO_HASSUBFOLDER;
545  SFGAO_HASSUBFOLDER | SFGAO_FOLDER | SFGAO_CANLINK;
546 static const DWORD dwDriveAttributes =
547  SFGAO_HASSUBFOLDER | SFGAO_FILESYSTEM | SFGAO_FOLDER | SFGAO_FILESYSANCESTOR |
548  SFGAO_DROPTARGET | SFGAO_HASPROPSHEET | SFGAO_CANRENAME | SFGAO_CANLINK;
549 
551 {
552  pidlRoot = NULL;
553 }
554 
556 {
557  TRACE ("-- destroying IShellFolder(%p)\n", this);
558  SHFree(pidlRoot);
559 }
560 
562 {
563  pidlRoot = _ILCreateMyComputer(); /* my qualified pidl */
564  if (pidlRoot == NULL)
565  return E_OUTOFMEMORY;
566 
567  HRESULT hr = CRegFolder_CreateInstance(&CLSID_MyComputer,
568  pidlRoot,
569  L"::{20D04FE0-3AEA-1069-A2D8-08002B30309D}",
570  L"MyComputer",
572 
573  return hr;
574 }
575 
576 /**************************************************************************
577 * CDrivesFolder::ParseDisplayName
578 */
580  DWORD * pchEaten, PIDLIST_RELATIVE * ppidl, DWORD * pdwAttributes)
581 {
583  LPCWSTR szNext = NULL;
584  LPITEMIDLIST pidlTemp = NULL;
585  INT nDriveNumber;
586 
587  TRACE("(%p)->(HWND=%p,%p,%p=%s,%p,pidl=%p,%p)\n", this,
588  hwndOwner, pbc, lpszDisplayName, debugstr_w (lpszDisplayName),
589  pchEaten, ppidl, pdwAttributes);
590 
591  *ppidl = 0;
592  if (pchEaten)
593  *pchEaten = 0; /* strange but like the original */
594 
595  /* handle CLSID paths */
596  if (lpszDisplayName[0] == ':' && lpszDisplayName[1] == ':')
597  return m_regFolder->ParseDisplayName(hwndOwner, pbc, lpszDisplayName, pchEaten, ppidl, pdwAttributes);
598 
599  nDriveNumber = PathGetDriveNumberW(lpszDisplayName);
600  if (nDriveNumber < 0)
601  return E_INVALIDARG;
602 
603  /* check if this drive actually exists */
604  if ((::GetLogicalDrives() & (1 << nDriveNumber)) == 0)
605  {
607  }
608 
609  pidlTemp = _ILCreateDrive(lpszDisplayName);
610  if (!pidlTemp)
611  return E_OUTOFMEMORY;
612 
613  if (lpszDisplayName[2] == L'\\')
614  {
615  szNext = &lpszDisplayName[3];
616  }
617 
618  if (szNext && *szNext)
619  {
620  hr = SHELL32_ParseNextElement (this, hwndOwner, pbc, &pidlTemp,
621  (LPOLESTR) szNext, pchEaten, pdwAttributes);
622  }
623  else
624  {
625  hr = S_OK;
626  if (pdwAttributes && *pdwAttributes)
627  {
628  if (_ILIsDrive(pidlTemp))
629  *pdwAttributes &= dwDriveAttributes;
630  else if (_ILIsSpecialFolder(pidlTemp))
631  m_regFolder->GetAttributesOf(1, &pidlTemp, pdwAttributes);
632  else
633  ERR("Got an unkown pidl here!\n");
634  }
635  }
636 
637  *ppidl = pidlTemp;
638 
639  TRACE ("(%p)->(-- ret=0x%08x)\n", this, hr);
640 
641  return hr;
642 }
643 
644 /**************************************************************************
645 * CDrivesFolder::EnumObjects
646 */
647 HRESULT WINAPI CDrivesFolder::EnumObjects(HWND hwndOwner, DWORD dwFlags, LPENUMIDLIST *ppEnumIDList)
648 {
649  CComPtr<IEnumIDList> pRegEnumerator;
650  m_regFolder->EnumObjects(hwndOwner, dwFlags, &pRegEnumerator);
651 
652  return ShellObjectCreatorInit<CDrivesFolderEnum>(hwndOwner, dwFlags, pRegEnumerator, IID_PPV_ARG(IEnumIDList, ppEnumIDList));
653 }
654 
655 /**************************************************************************
656 * CDrivesFolder::BindToObject
657 */
659 {
660  TRACE("(%p)->(pidl=%p,%p,%s,%p)\n", this,
661  pidl, pbcReserved, shdebugstr_guid(&riid), ppvOut);
662 
663  if (!pidl)
664  return E_INVALIDARG;
665 
666  if (_ILIsSpecialFolder(pidl))
667  return m_regFolder->BindToObject(pidl, pbcReserved, riid, ppvOut);
668 
669  CHAR* pchDrive = _ILGetDataPointer(pidl)->u.drive.szDriveName;
670 
671  PERSIST_FOLDER_TARGET_INFO pfti = {0};
672  pfti.dwAttributes = -1;
673  pfti.csidl = -1;
674  pfti.szTargetParsingName[0] = *pchDrive;
675  pfti.szTargetParsingName[1] = L':';
676  pfti.szTargetParsingName[2] = L'\\';
677 
679  &pfti,
680  pidl,
681  &CLSID_ShellFSFolder,
682  riid,
683  ppvOut);
684  if (FAILED_UNEXPECTEDLY(hr))
685  return hr;
686 
687  return S_OK;
688 }
689 
690 /**************************************************************************
691 * CDrivesFolder::BindToStorage
692 */
694 {
695  FIXME("(%p)->(pidl=%p,%p,%s,%p) stub\n", this,
696  pidl, pbcReserved, shdebugstr_guid (&riid), ppvOut);
697 
698  *ppvOut = NULL;
699  return E_NOTIMPL;
700 }
701 
702 /**************************************************************************
703 * CDrivesFolder::CompareIDs
704 */
705 
707 {
708  HRESULT hres;
709 
710  if (!pidl1 || !pidl2)
711  {
712  ERR("Got null pidl pointer (%Ix %p %p)!\n", lParam, pidl1, pidl2);
713  return E_INVALIDARG;
714  }
715 
716  if (_ILIsSpecialFolder(pidl1) || _ILIsSpecialFolder(pidl2))
717  return m_regFolder->CompareIDs(lParam, pidl1, pidl2);
718 
719  if (!_ILIsDrive(pidl1) || !_ILIsDrive(pidl2) || LOWORD(lParam) >= MYCOMPUTERSHELLVIEWCOLUMNS)
720  return E_INVALIDARG;
721 
722  CHAR* pszDrive1 = _ILGetDataPointer(pidl1)->u.drive.szDriveName;
723  CHAR* pszDrive2 = _ILGetDataPointer(pidl2)->u.drive.szDriveName;
724 
725  int result;
726  switch(LOWORD(lParam))
727  {
728  case 0: /* name */
729  {
730  result = stricmp(pszDrive1, pszDrive2);
732  break;
733  }
734  case 1: /* comments */
736  break;
737  case 2: /* Type */
738  {
739  /* We want to return immediately because SHELL32_CompareDetails also compares children. */
740  return SHELL32_CompareDetails(this, lParam, pidl1, pidl2);
741  }
742  case 3: /* Size */
743  case 4: /* Size Available */
744  {
745  ULARGE_INTEGER Drive1Available, Drive1Total, Drive2Available, Drive2Total;
746 
747  if (GetVolumeInformationA(pszDrive1, NULL, 0, NULL, NULL, NULL, NULL, 0))
748  GetDiskFreeSpaceExA(pszDrive1, &Drive1Available, &Drive1Total, NULL);
749  else
750  Drive1Available.QuadPart = Drive1Total.QuadPart = 0;
751 
752  if (GetVolumeInformationA(pszDrive2, NULL, 0, NULL, NULL, NULL, NULL, 0))
753  GetDiskFreeSpaceExA(pszDrive2, &Drive2Available, &Drive2Total, NULL);
754  else
755  Drive2Available.QuadPart = Drive2Total.QuadPart = 0;
756 
757  LARGE_INTEGER Diff;
758  if (lParam == 3) /* Size */
759  Diff.QuadPart = Drive1Total.QuadPart - Drive2Total.QuadPart;
760  else /* Size available */
761  Diff.QuadPart = Drive1Available.QuadPart - Drive2Available.QuadPart;
762 
764  break;
765  }
766  default:
767  return E_INVALIDARG;
768  }
769 
770  if (HRESULT_CODE(hres) == 0)
771  return SHELL32_CompareChildren(this, lParam, pidl1, pidl2);
772 
773  return hres;
774 }
775 
776 /**************************************************************************
777 * CDrivesFolder::CreateViewObject
778 */
780 {
781  CComPtr<IShellView> pShellView;
783 
784  TRACE("(%p)->(hwnd=%p,%s,%p)\n", this,
785  hwndOwner, shdebugstr_guid (&riid), ppvOut);
786 
787  if (!ppvOut)
788  return hr;
789 
790  *ppvOut = NULL;
791 
792  if (IsEqualIID(riid, IID_IDropTarget))
793  {
794  WARN("IDropTarget not implemented\n");
795  hr = E_NOTIMPL;
796  }
797  else if (IsEqualIID(riid, IID_IContextMenu))
798  {
799  HKEY hKeys[16];
800  UINT cKeys = 0;
801  AddClassKeyToArray(L"Directory\\Background", hKeys, &cKeys);
802 
803  DEFCONTEXTMENU dcm;
804  dcm.hwnd = hwndOwner;
805  dcm.pcmcb = this;
806  dcm.pidlFolder = pidlRoot;
807  dcm.psf = this;
808  dcm.cidl = 0;
809  dcm.apidl = NULL;
810  dcm.cKeys = cKeys;
811  dcm.aKeys = hKeys;
813  hr = SHCreateDefaultContextMenu(&dcm, riid, ppvOut);
814  }
815  else if (IsEqualIID(riid, IID_IShellView))
816  {
817  SFV_CREATE sfvparams = {sizeof(SFV_CREATE), this};
818  hr = SHCreateShellFolderView(&sfvparams, (IShellView**)ppvOut);
819  }
820  TRACE ("-- (%p)->(interface=%p)\n", this, ppvOut);
821  return hr;
822 }
823 
825 {
826  GUID *guid = _ILGetGUIDPointer(pidl);
827 
828  TRACE("(%p)\n", pidl);
829 
830  if (guid)
831  return IsEqualIID(*guid, CLSID_ControlPanel);
832  return FALSE;
833 }
834 
835 /**************************************************************************
836 * CDrivesFolder::GetAttributesOf
837 */
839 {
840  TRACE ("(%p)->(cidl=%d apidl=%p mask=%p (0x%08x))\n",
841  this, cidl, apidl, rgfInOut, rgfInOut ? *rgfInOut : 0);
842 
843  if (cidl && !apidl)
844  return E_INVALIDARG;
845 
846  if (*rgfInOut == 0)
847  *rgfInOut = ~0;
848 
849  /* FIXME: always add SFGAO_CANLINK */
850  if(cidl == 0)
851  *rgfInOut &= dwComputerAttributes;
852  else
853  {
854  for (UINT i = 0; i < cidl; ++i)
855  {
856  if (_ILIsDrive(apidl[i]))
857  *rgfInOut &= dwDriveAttributes;
858  else if (_ILIsControlPanel(apidl[i]))
859  *rgfInOut &= dwControlPanelAttributes;
860  else if (_ILIsSpecialFolder(*apidl))
861  m_regFolder->GetAttributesOf(1, &apidl[i], rgfInOut);
862  else
863  ERR("Got unknown pidl type!\n");
864  }
865  }
866 
867  /* make sure SFGAO_VALIDATE is cleared, some apps depend on that */
868  *rgfInOut &= ~SFGAO_VALIDATE;
869 
870  TRACE ("-- result=0x%08x\n", *rgfInOut);
871  return S_OK;
872 }
873 
874 /**************************************************************************
875 * CDrivesFolder::GetUIObjectOf
876 *
877 * PARAMETERS
878 * hwndOwner [in] Parent window for any output
879 * cidl [in] array size
880 * apidl [in] simple pidl array
881 * riid [in] Requested Interface
882 * prgfInOut [ ] reserved
883 * ppvObject [out] Resulting Interface
884 *
885 */
887  UINT cidl, PCUITEMID_CHILD_ARRAY apidl,
888  REFIID riid, UINT *prgfInOut, LPVOID *ppvOut)
889 {
890  LPVOID pObj = NULL;
892 
893  TRACE("(%p)->(%p,%u,apidl=%p,%s,%p,%p)\n", this,
894  hwndOwner, cidl, apidl, shdebugstr_guid (&riid), prgfInOut, ppvOut);
895 
896  if (!ppvOut)
897  return hr;
898 
899  *ppvOut = NULL;
900 
901  if (IsEqualIID (riid, IID_IContextMenu) && (cidl >= 1))
902  {
903  if (_ILIsDrive(apidl[0]))
904  hr = CDrivesContextMenu_CreateInstance(pidlRoot, hwndOwner, cidl, apidl, static_cast<IShellFolder*>(this), (IContextMenu**)&pObj);
905  else
906  hr = m_regFolder->GetUIObjectOf(hwndOwner, cidl, apidl, riid, prgfInOut, &pObj);
907  }
908  else if (IsEqualIID (riid, IID_IDataObject) && (cidl >= 1))
909  {
910  hr = IDataObject_Constructor (hwndOwner,
911  pidlRoot, apidl, cidl, TRUE, (IDataObject **)&pObj);
912  }
913  else if ((IsEqualIID (riid, IID_IExtractIconA) || IsEqualIID (riid, IID_IExtractIconW)) && (cidl == 1))
914  {
915  if (_ILIsDrive(apidl[0]))
916  hr = CDrivesExtractIcon_CreateInstance(this, apidl[0], riid, &pObj);
917  else
918  hr = m_regFolder->GetUIObjectOf(hwndOwner, cidl, apidl, riid, prgfInOut, &pObj);
919  }
920  else if (IsEqualIID (riid, IID_IDropTarget) && (cidl == 1))
921  {
922  CComPtr<IShellFolder> psfChild;
923  hr = this->BindToObject(apidl[0], NULL, IID_PPV_ARG(IShellFolder, &psfChild));
924  if (FAILED_UNEXPECTEDLY(hr))
925  return hr;
926 
927  return psfChild->CreateViewObject(NULL, riid, ppvOut);
928  }
929  else
930  hr = E_NOINTERFACE;
931 
932  if (SUCCEEDED(hr) && !pObj)
933  hr = E_OUTOFMEMORY;
934 
935  *ppvOut = pObj;
936  TRACE ("(%p)->hr=0x%08x\n", this, hr);
937  return hr;
938 }
939 
940 /**************************************************************************
941 * CDrivesFolder::GetDisplayNameOf
942 */
944 {
945  LPWSTR pszPath;
946  HRESULT hr = S_OK;
947 
948  TRACE ("(%p)->(pidl=%p,0x%08x,%p)\n", this, pidl, dwFlags, strRet);
949  pdump (pidl);
950 
951  if (!strRet)
952  return E_INVALIDARG;
953 
954  if (!_ILIsPidlSimple (pidl))
955  {
956  return SHELL32_GetDisplayNameOfChild(this, pidl, dwFlags, strRet);
957  }
958  else if (_ILIsSpecialFolder(pidl))
959  {
960  return m_regFolder->GetDisplayNameOf(pidl, dwFlags, strRet);
961  }
962  else if (!_ILIsDrive(pidl))
963  {
964  ERR("Wrong pidl type\n");
965  return E_INVALIDARG;
966  }
967 
968  pszPath = (LPWSTR)CoTaskMemAlloc((MAX_PATH + 1) * sizeof(WCHAR));
969  if (!pszPath)
970  return E_OUTOFMEMORY;
971 
972  pszPath[0] = 0;
973 
974  _ILSimpleGetTextW(pidl, pszPath, MAX_PATH); /* append my own path */
975  /* long view "lw_name (C:)" */
976  if (!(dwFlags & SHGDN_FORPARSING))
977  {
978  WCHAR wszDrive[18] = {0};
979  DWORD dwVolumeSerialNumber, dwMaximumComponentLength, dwFileSystemFlags;
980  static const WCHAR wszOpenBracket[] = {' ', '(', 0};
981  static const WCHAR wszCloseBracket[] = {')', 0};
982 
983  lstrcpynW(wszDrive, pszPath, 4);
984  pszPath[0] = L'\0';
985  GetVolumeInformationW(wszDrive, pszPath,
986  MAX_PATH - 7,
987  &dwVolumeSerialNumber,
988  &dwMaximumComponentLength, &dwFileSystemFlags, NULL, 0);
989  pszPath[MAX_PATH-1] = L'\0';
990  if (!wcslen(pszPath))
991  {
992  UINT DriveType, ResourceId;
993  DriveType = GetDriveTypeW(wszDrive);
994  switch(DriveType)
995  {
996  case DRIVE_FIXED:
997  ResourceId = IDS_DRIVE_FIXED;
998  break;
999  case DRIVE_REMOTE:
1000  ResourceId = IDS_DRIVE_NETWORK;
1001  break;
1002  case DRIVE_CDROM:
1003  ResourceId = IDS_DRIVE_CDROM;
1004  break;
1005  default:
1006  ResourceId = 0;
1007  }
1008  if (ResourceId)
1009  {
1010  dwFileSystemFlags = LoadStringW(shell32_hInstance, ResourceId, pszPath, MAX_PATH);
1011  if (dwFileSystemFlags > MAX_PATH - 7)
1012  pszPath[MAX_PATH-7] = L'\0';
1013  }
1014  }
1015  wcscat (pszPath, wszOpenBracket);
1016  wszDrive[2] = L'\0';
1017  wcscat (pszPath, wszDrive);
1018  wcscat (pszPath, wszCloseBracket);
1019  }
1020 
1021  if (SUCCEEDED(hr))
1022  {
1023  strRet->uType = STRRET_WSTR;
1024  strRet->pOleStr = pszPath;
1025  }
1026  else
1027  CoTaskMemFree(pszPath);
1028 
1029  TRACE("-- (%p)->(%s)\n", this, strRet->uType == STRRET_CSTR ? strRet->cStr : debugstr_w(strRet->pOleStr));
1030  return hr;
1031 }
1032 
1033 /**************************************************************************
1034 * CDrivesFolder::SetNameOf
1035 * Changes the name of a file object or subfolder, possibly changing its item
1036 * identifier in the process.
1037 *
1038 * PARAMETERS
1039 * hwndOwner [in] Owner window for output
1040 * pidl [in] simple pidl of item to change
1041 * lpszName [in] the items new display name
1042 * dwFlags [in] SHGNO formatting flags
1043 * ppidlOut [out] simple pidl returned
1044 */
1046  LPCOLESTR lpName, DWORD dwFlags, PITEMID_CHILD *pPidlOut)
1047 {
1048  WCHAR szName[30];
1049 
1050  if (_ILIsDrive(pidl))
1051  {
1052  if (_ILSimpleGetTextW(pidl, szName, _countof(szName)))
1054  if (pPidlOut)
1055  *pPidlOut = _ILCreateDrive(szName);
1056  return S_OK;
1057  }
1058 
1059  return m_regFolder->SetNameOf(hwndOwner, pidl, lpName, dwFlags, pPidlOut);
1060 }
1061 
1063 {
1064  FIXME ("(%p)\n", this);
1065  return E_NOTIMPL;
1066 }
1067 
1069 {
1070  FIXME ("(%p)\n", this);
1071  return E_NOTIMPL;
1072 }
1073 
1075 {
1076  TRACE ("(%p)\n", this);
1077 
1078  if (pSort)
1079  *pSort = 0;
1080  if (pDisplay)
1081  *pDisplay = 0;
1082  return S_OK;
1083 }
1084 
1086 {
1087  TRACE ("(%p)\n", this);
1088 
1089  if (!pcsFlags || iColumn >= MYCOMPUTERSHELLVIEWCOLUMNS)
1090  return E_INVALIDARG;
1091  *pcsFlags = MyComputerSFHeader[iColumn].pcsFlags;
1092  return S_OK;
1093 }
1094 
1096 {
1097  FIXME ("(%p)\n", this);
1098  return E_NOTIMPL;
1099 }
1100 
1102 {
1103  HRESULT hr;
1104 
1105  TRACE ("(%p)->(%p %i %p)\n", this, pidl, iColumn, psd);
1106 
1107  if (!psd || iColumn >= MYCOMPUTERSHELLVIEWCOLUMNS)
1108  return E_INVALIDARG;
1109 
1110  if (!pidl)
1111  {
1112  psd->fmt = MyComputerSFHeader[iColumn].fmt;
1113  psd->cxChar = MyComputerSFHeader[iColumn].cxChar;
1114  return SHSetStrRet(&psd->str, MyComputerSFHeader[iColumn].colnameid);
1115  }
1116  else if (!_ILIsDrive(pidl))
1117  {
1118  return m_regFolder->GetDetailsOf(pidl, iColumn, psd);
1119  }
1120  else
1121  {
1122  ULARGE_INTEGER ulTotalBytes, ulFreeBytes;
1123  CHAR* pszDrive = _ILGetDataPointer(pidl)->u.drive.szDriveName;
1124  UINT DriveType = GetDriveTypeA(pszDrive);
1125  if (DriveType > DRIVE_RAMDISK)
1127 
1128  switch (iColumn)
1129  {
1130  case 0: /* name */
1132  break;
1133  case 1: /* FIXME: comments */
1134  hr = SHSetStrRet(&psd->str, "");
1135  break;
1136  case 2: /* type */
1137  if (DriveType == DRIVE_REMOVABLE && !IsDriveFloppyA(pszDrive))
1138  hr = SHSetStrRet(&psd->str, IDS_DRIVE_REMOVABLE);
1139  else
1140  hr = SHSetStrRet(&psd->str, iDriveTypeIds[DriveType]);
1141  break;
1142  case 3: /* total size */
1143  case 4: /* free size */
1144  psd->str.cStr[0] = 0x00;
1145  psd->str.uType = STRRET_CSTR;
1146  if (GetVolumeInformationA(pszDrive, NULL, 0, NULL, NULL, NULL, NULL, 0))
1147  {
1148  GetDiskFreeSpaceExA(pszDrive, &ulFreeBytes, &ulTotalBytes, NULL);
1149  if (iColumn == 3)
1150  StrFormatByteSize64A(ulTotalBytes.QuadPart, psd->str.cStr, MAX_PATH);
1151  else
1152  StrFormatByteSize64A(ulFreeBytes.QuadPart, psd->str.cStr, MAX_PATH);
1153  }
1154  hr = S_OK;
1155  break;
1156  }
1157  }
1158 
1159  return hr;
1160 }
1161 
1163 {
1164  FIXME("(%p)\n", this);
1165  return E_NOTIMPL;
1166 }
1167 
1168 /************************************************************************
1169  * CDrivesFolder::GetClassID
1170  */
1172 {
1173  TRACE ("(%p)\n", this);
1174 
1175  if (!lpClassId)
1176  return E_POINTER;
1177 
1178  *lpClassId = CLSID_MyComputer;
1179  return S_OK;
1180 }
1181 
1182 /************************************************************************
1183  * CDrivesFolder::Initialize
1184  *
1185  * NOTES: it makes no sense to change the pidl
1186  */
1188 {
1189  return S_OK;
1190 }
1191 
1192 /**************************************************************************
1193  * CDrivesFolder::GetCurFolder
1194  */
1196 {
1197  TRACE("(%p)->(%p)\n", this, pidl);
1198 
1199  if (!pidl)
1200  return E_INVALIDARG; /* xp doesn't have this check and crashes on NULL */
1201 
1202  *pidl = ILClone(pidlRoot);
1203  return S_OK;
1204 }
1205 
1206 /************************************************************************/
1207 /* IContextMenuCB interface */
1208 
1210 {
1211  if (uMsg != DFM_MERGECONTEXTMENU && uMsg != DFM_INVOKECOMMAND)
1212  return S_OK;
1213 
1214  /* no data object means no selection */
1215  if (!pdtobj)
1216  {
1217  if (uMsg == DFM_INVOKECOMMAND && wParam == 1) // #1
1218  {
1219  // "System" properties
1220  ShellExecuteW(hwndOwner,
1221  NULL,
1222  L"rundll32.exe",
1223  L"shell32.dll,Control_RunDLL sysdm.cpl",
1224  NULL,
1225  SW_SHOWNORMAL);
1226  }
1227  else if (uMsg == DFM_MERGECONTEXTMENU)
1228  {
1229  QCMINFO *pqcminfo = (QCMINFO *)lParam;
1230  HMENU hpopup = CreatePopupMenu();
1231  _InsertMenuItemW(hpopup, 0, TRUE, 0, MFT_SEPARATOR, NULL, MFS_ENABLED); // #0
1233  Shell_MergeMenus(pqcminfo->hmenu, hpopup, pqcminfo->indexMenu++, pqcminfo->idCmdFirst, pqcminfo->idCmdLast, MM_ADDSEPARATOR);
1234  DestroyMenu(hpopup);
1235  }
1236 
1237  return S_OK;
1238  }
1239 
1240  if (uMsg != DFM_INVOKECOMMAND || wParam != DFM_CMD_PROPERTIES)
1241  return S_OK;
1242 
1243  return Shell_DefaultContextMenuCallBack(this, pdtobj);
1244 }
int WINAPIV wsprintfW(_Out_ LPWSTR, _In_ _Printf_format_string_ LPCWSTR,...)
#define WS_CLIPSIBLINGS
Definition: pedump.c:618
void WINAPI _InsertMenuItemW(HMENU hmenu, UINT indexMenu, BOOL fByPosition, UINT wID, UINT fType, LPCWSTR dwTypeData, UINT fState)
HRESULT WINAPI FinalConstruct()
#define IDS_SHV_COLUMN_COMMENTS
Definition: shresdef.h:61
#define WS_DISABLED
Definition: pedump.c:621
BOOL WINAPI PathIsDirectoryW(LPCWSTR lpszPath)
Definition: path.c:1702
virtual HRESULT WINAPI MapColumnToSCID(UINT column, SHCOLUMNID *pscid)
const DOCKBAR PVOID HWND HWND * hwnd
Definition: tooldock.h:22
#define IDS_CANTDISMOUNTVOLUME
Definition: shresdef.h:139
#define WS_EX_WINDOWEDGE
Definition: winuser.h:407
UINT idCmdLast
Definition: shlobj.h:1318
#define MFT_STRING
Definition: winuser.h:741
#define IDI_SHELL_DRIVE
Definition: shresdef.h:504
virtual HRESULT WINAPI GetDefaultSearchGUID(GUID *pguid)
#define FSCTL_UNLOCK_VOLUME
Definition: nt_native.h:833
INT WINAPI GetPrivateProfileStringW(LPCWSTR section, LPCWSTR entry, LPCWSTR def_val, LPWSTR buffer, UINT len, LPCWSTR filename)
Definition: profile.c:1142
#define REFIID
Definition: guiddef.h:118
BOOL WINAPI PathIsRelativeW(LPCWSTR lpszPath)
Definition: path.c:1558
#define CloseHandle
Definition: compat.h:598
VOID WINAPI DECLSPEC_HOTPATCH Sleep(IN DWORD dwMilliseconds)
Definition: synch.c:790
LPPIDLDATA _ILGetDataPointer(LPCITEMIDLIST pidl)
Definition: pidl.c:2176
#define E_NOINTERFACE
Definition: winerror.h:2364
HRESULT CDrivesExtractIcon_CreateInstance(IShellFolder *psf, LPCITEMIDLIST pidl, REFIID riid, LPVOID *ppvOut)
#define HRESULT_FROM_WIN32(x)
Definition: winerror.h:92
UINT WINAPI GetDriveTypeA(IN LPCSTR lpRootPathName)
Definition: disk.c:468
#define CMDID_EJECT
VOID WINAPI CoTaskMemFree(LPVOID ptr)
Definition: ifs.c:442
static BOOL CALLBACK EnumStubProc(HWND hwnd, LPARAM lParam)
UINT WINAPI Shell_MergeMenus(HMENU hmDst, HMENU hmSrc, UINT uInsert, UINT uIDAdjust, UINT uIDAdjustMax, ULONG uFlags)
Definition: shlmenu.c:857
HRESULT hr
Definition: shlfolder.c:183
GLuint64EXT * result
Definition: glext.h:11304
virtual HRESULT WINAPI ParseDisplayName(HWND hwndOwner, LPBC pbc, LPOLESTR lpszDisplayName, DWORD *pchEaten, PIDLIST_RELATIVE *ppidl, DWORD *pdwAttributes)
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
const HKEY * aKeys
Definition: shlobj.h:2374
#define IOCTL_STORAGE_MEDIA_REMOVAL
Definition: ntddstor.h:104
interface IBindCtx * LPBC
Definition: objfwd.h:18
virtual HRESULT WINAPI GetAttributesOf(UINT cidl, PCUITEMID_CHILD_ARRAY apidl, DWORD *rgfInOut)
#define ERROR_INVALID_FUNCTION
Definition: dderror.h:6
LPSTR WINAPI StrFormatByteSize64A(LONGLONG llBytes, LPSTR lpszDest, UINT cchMax)
Definition: string.c:2488
#define TRUE
Definition: types.h:120
REFIID riid
Definition: precomp.h:44
virtual HRESULT WINAPI Initialize(PCIDLIST_ABSOLUTE pidl)
static BOOL TryToLockOrUnlockDrive(HANDLE hDrive, BOOL bLock)
LPITEMIDLIST _ILCreateDrive(LPCWSTR lpszNew)
Definition: pidl.c:1808
BOOL AddToEnumList(LPITEMIDLIST pidl)
BOOL HCR_GetIconW(LPCWSTR szClass, LPWSTR szDest, LPCWSTR szName, DWORD len, int *picon_idx)
Definition: classes.c:294
#define IDS_SHV_COLUMN_DISK_CAPACITY
Definition: shresdef.h:48
char CHAR
Definition: xmlstorage.h:175
#define CMDID_FORMAT
ITEMID_CHILD UNALIGNED * PUITEMID_CHILD
Definition: shtypes.idl:68
HRESULT WINAPI Shell_DefaultContextMenuCallBack(IShellFolder *psf, IDataObject *pdtobj)
Definition: shlfolder.cpp:450
HRESULT WINAPI SHCreateDefaultContextMenu(const DEFCONTEXTMENU *pdcm, REFIID riid, void **ppv)
#define WARN(fmt,...)
Definition: debug.h:112
#define CMDID_DISCONNECT
virtual HRESULT WINAPI GetDisplayNameOf(PCUITEMID_CHILD pidl, DWORD dwFlags, LPSTRRET strRet)
#define RETRY_SLEEP
void AddClassKeyToArray(const WCHAR *szClass, HKEY *array, UINT *cKeys)
Definition: shlfolder.cpp:267
#define DRIVE_RAMDISK
Definition: winbase.h:252
#define LVCFMT_RIGHT
Definition: commctrl.h:2595
const ITEMIDLIST UNALIGNED * LPCITEMIDLIST
Definition: shtypes.idl:42
IContextMenuCB * pcmcb
Definition: shlobj.h:2367
#define CALLBACK
Definition: compat.h:35
_In_ LPCSTR lpName
Definition: winbase.h:2752
Definition: stubgen.c:11
LPWSTR pOleStr
Definition: shtypes.idl:96
HMENU hmenu
Definition: shlobj.h:1315
virtual HRESULT WINAPI GetCurFolder(PIDLIST_ABSOLUTE *pidl)
GLdouble n
Definition: glext.h:7729
const char * shdebugstr_guid(const struct _GUID *id)
Definition: debughlp.cpp:414
WCHAR swShell32Name[MAX_PATH]
Definition: folders.cpp:22
#define IDI_SHELL_REMOVEABLE
Definition: shresdef.h:503
#define IDS_CANTSHOWPROPERTIES
Definition: shresdef.h:141
#define LVCFMT_LEFT
Definition: commctrl.h:2594
#define INVALID_HANDLE_VALUE
Definition: compat.h:590
UINT DriveType
const ITEMID_CHILD UNALIGNED * PCUITEMID_CHILD
Definition: shtypes.idl:70
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1044
DWORD WINAPI GetFullPathNameW(IN LPCWSTR lpFileName, IN DWORD nBufferLength, OUT LPWSTR lpBuffer, OUT LPWSTR *lpFilePart)
Definition: path.c:1105
HRESULT CALLBACK DrivesContextMenuCallback(IShellFolder *psf, HWND hwnd, IDataObject *pdtobj, UINT uMsg, WPARAM wParam, LPARAM lParam)
BOOL IsDriveFloppyA(LPCSTR pszDriveRoot)
Definition: drvdefext.cpp:373
const GUID IID_IDataObject
#define MAKE_COMPARE_HRESULT(x)
Definition: shellutils.h:535
UINT_PTR WPARAM
Definition: windef.h:207
#define IDS_PROPERTIES
Definition: resource.h:101
#define FILE_SHARE_WRITE
Definition: nt_native.h:681
UINT uFlags
Definition: api.c:59
#define SHFMT_ID_DEFAULT
Definition: shlobj.h:297
_CRTIMP uintptr_t __cdecl _beginthreadex(_In_opt_ void *_Security, _In_ unsigned _StackSize, _In_ unsigned(__stdcall *_StartAddress)(void *), _In_opt_ void *_ArgList, _In_ unsigned _InitFlag, _Out_opt_ unsigned *_ThrdAddr)
BOOL WINAPI GetVolumeInformationA(IN LPCSTR lpRootPathName, IN LPSTR lpVolumeNameBuffer, IN DWORD nVolumeNameSize, OUT LPDWORD lpVolumeSerialNumber OPTIONAL, OUT LPDWORD lpMaximumComponentLength OPTIONAL, OUT LPDWORD lpFileSystemFlags OPTIONAL, OUT LPSTR lpFileSystemNameBuffer OPTIONAL, IN DWORD nFileSystemNameSize)
Definition: volume.c:32
static LPOLESTR
Definition: stg_prop.c:27
HRESULT SHELL32_BindToSF(LPCITEMIDLIST pidlRoot, PERSIST_FOLDER_TARGET_INFO *ppfti, LPCITEMIDLIST pidl, const GUID *clsid, REFIID riid, LPVOID *ppvOut)
Definition: shlfolder.cpp:159
CComPtr< IShellFolder2 > m_regFolder
Definition: CDrivesFolder.h:36
static const DWORD dwComputerAttributes
virtual HRESULT WINAPI BindToObject(PCUIDLIST_RELATIVE pidl, LPBC pbcReserved, REFIID riid, LPVOID *ppvOut)
#define NO_ERROR
Definition: dderror.h:5
HRESULT WINAPI SHCreateShellFolderView(const SFV_CREATE *pcsfv, IShellView **ppsv)
Definition: CDefView.cpp:3755
#define IID_PPV_ARG(Itype, ppType)
#define E_FAIL
Definition: ddrawi.h:102
Definition: match.c:390
#define RETRY_COUNT
#define IDS_DRIVE_CDROM
Definition: shresdef.h:106
int WINAPI LoadStringW(_In_opt_ HINSTANCE hInstance, _In_ UINT uID, _Out_writes_to_(cchBufferMax, return+1) LPWSTR lpBuffer, _In_ int cchBufferMax)
STRRET str
Definition: shtypes.idl:108
int32_t INT
Definition: typedefs.h:58
WPARAM wParam
Definition: combotst.c:138
#define FILE_SHARE_READ
Definition: compat.h:136
HANDLE WINAPI RemovePropW(_In_ HWND, _In_ LPCWSTR)
#define DRIVE_REMOVABLE
Definition: winbase.h:248
virtual HRESULT WINAPI CompareIDs(LPARAM lParam, PCUIDLIST_RELATIVE pidl1, PCUIDLIST_RELATIVE pidl2)
#define IDS_SHV_COLUMN_TYPE
Definition: resource.h:75
#define lstrcpynW
Definition: compat.h:597
BOOL WINAPI PathAppendW(LPWSTR lpszPath, LPCWSTR lpszAppend)
Definition: path.c:121
int WINAPI lstrcmpiW(LPCWSTR lpString1, LPCWSTR lpString2)
Definition: lstring.c:194
int WINAPI GetClassNameW(_In_ HWND hWnd, _Out_writes_to_(nMaxCount, return) LPWSTR lpClassName, _In_ int nMaxCount)
virtual HRESULT WINAPI SetNameOf(HWND hwndOwner, PCUITEMID_CHILD pidl, LPCOLESTR lpName, DWORD dwFlags, PITEMID_CHILD *pPidlOut)
struct _stub stub
char cStr[MAX_PATH]
Definition: shtypes.idl:98
const GUID * guid
IShellFolder * psf
Definition: shlobj.h:2369
#define DRIVE_REMOTE
Definition: winbase.h:250
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
#define MFS_ENABLED
Definition: winuser.h:745
#define DRIVE_CDROM
Definition: machpc98.h:115
ULONGLONG QuadPart
Definition: ms-dtyp.idl:185
#define FALSE
Definition: types.h:117
#define IDS_FORMATDRIVE
Definition: shresdef.h:214
#define UNICODE_NULL
const PCUITEMID_CHILD * PCUITEMID_CHILD_ARRAY
Definition: shtypes.idl:71
static BOOL _ILIsSpecialFolder(LPCITEMIDLIST pidl)
#define IDS_SHV_COLUMN_DISK_AVAILABLE
Definition: shresdef.h:49
GLenum const GLfloat * params
Definition: glext.h:5645
unsigned int BOOL
Definition: ntddk_ex.h:94
#define ERROR_CAN_NOT_COMPLETE
Definition: winerror.h:582
static const DWORD dwControlPanelAttributes
HRESULT SHELL32_CompareChildren(IShellFolder2 *psf, LPARAM lParam, LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
Definition: shlfolder.cpp:215
if SUCCEEDED(hr)
STRSAFEAPI StringCchCopyW(STRSAFE_LPWSTR pszDest, size_t cchDest, STRSAFE_LPCWSTR pszSrc)
Definition: strsafe.h:149
#define debugstr_w
Definition: kernel32.h:32
#define FIXME(fmt,...)
Definition: debug.h:111
#define IOCTL_STORAGE_EJECT_MEDIA
Definition: ntddstor.h:107
#define IDS_CANTLOCKVOLUME
Definition: shresdef.h:138
#define E_INVALIDARG
Definition: ddrawi.h:101
BOOL WINAPI BringWindowToTop(_In_ HWND)
HRESULT SH_GetApidlFromDataObject(IDataObject *pDataObject, PIDLIST_ABSOLUTE *ppidlfolder, PUITEMID_CHILD **apidlItems, UINT *pcidl)
Definition: shlfolder.cpp:327
#define DFM_INVOKECOMMAND
Definition: precomp.h:45
HRESULT IDataObject_Constructor(HWND hwndOwner, PCIDLIST_ABSOLUTE pMyPidl, PCUIDLIST_RELATIVE_ARRAY apidl, UINT cidl, BOOL bExtendedObject, IDataObject **dataObject)
LONG_PTR LPARAM
Definition: windef.h:208
UINT indexMenu
Definition: shlobj.h:1316
HRESULT SHELL32_GetDisplayNameOfChild(IShellFolder2 *psf, LPCITEMIDLIST pidl, DWORD dwFlags, LPSTRRET strRet)
Definition: shlfolder.cpp:197
DWORD _ILSimpleGetTextW(LPCITEMIDLIST pidl, LPWSTR szOut, UINT uOutSize)
Definition: pidl.c:2096
static HRESULT getIconLocationForDrive(IShellFolder *psf, PCITEMID_CHILD pidl, UINT uFlags, LPWSTR szIconFile, UINT cchMax, int *piIndex, UINT *pwFlags)
static HRESULT DoFormatDrive(HWND hwnd, UINT nDriveNumber)
const char * LPCSTR
Definition: xmlstorage.h:183
struct _SFV_CREATE SFV_CREATE
LPITEMIDLIST _ILCreateMyComputer(void)
Definition: pidl.c:1613
BOOL ILGetDisplayNameExW(LPSHELLFOLDER psf, LPCITEMIDLIST pidl, LPWSTR path, DWORD type)
Definition: pidl.c:91
#define DRIVE_UNKNOWN
Definition: winbase.h:253
#define OPEN_EXISTING
Definition: compat.h:634
BOOL WINAPI _ILIsPidlSimple(LPCITEMIDLIST pidl)
virtual HRESULT WINAPI GetUIObjectOf(HWND hwndOwner, UINT cidl, PCUITEMID_CHILD_ARRAY apidl, REFIID riid, UINT *prgfInOut, LPVOID *ppvOut)
_Check_return_ _CRTIMP int __cdecl stricmp(_In_z_ const char *_Str1, _In_z_ const char *_Str2)
HRESULT SHELL32_ParseNextElement(IShellFolder2 *psf, HWND hwndOwner, LPBC pbc, LPITEMIDLIST *pidlInOut, LPOLESTR szNext, DWORD *pEaten, DWORD *pdwAttributes)
Definition: shlfolder.cpp:70
#define FSCTL_DISMOUNT_VOLUME
Definition: nt_native.h:834
HRESULT SHELL32_CompareDetails(IShellFolder2 *isf, LPARAM lParam, LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
Definition: shlfolder.cpp:238
#define WS_CAPTION
Definition: pedump.c:624
#define BEGIN_COM_MAP(x)
Definition: atlcom.h:541
HRESULT CRegFolder_CreateInstance(const GUID *pGuid, LPCITEMIDLIST pidlRoot, LPCWSTR lpszPath, LPCWSTR lpszEnumKeyName, REFIID riid, void **ppv)
Definition: CRegFolder.cpp:785
#define _T(x)
Definition: vfdio.h:22
#define IDI_SHELL_3_14_FLOPPY
Definition: shresdef.h:502
#define TRACE(s)
Definition: solgame.cpp:4
static BOOL _ILIsControlPanel(LPCITEMIDLIST pidl)
#define IDS_DRIVE_FIXED
Definition: shresdef.h:105
HRESULT hres
Definition: protocol.c:465
#define SHCNE_MEDIAREMOVED
Definition: shlobj.h:1735
BOOL WINAPI SetPropW(_In_ HWND, _In_ LPCWSTR, _In_opt_ HANDLE)
int WINAPI MessageBoxW(_In_opt_ HWND, _In_opt_ LPCWSTR, _In_opt_ LPCWSTR, _In_ UINT)
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define IDS_CANTEJECTMEDIA
Definition: shresdef.h:140
#define MM_ADDSEPARATOR
Definition: shlobj.h:2345
BOOL WINAPI SetVolumeLabelW(IN LPCWSTR lpRootPathName, IN LPCWSTR lpVolumeName OPTIONAL)
Definition: volume.c:503
LONG HRESULT
Definition: typedefs.h:79
IID * _ILGetGUIDPointer(LPCITEMIDLIST pidl)
Definition: pidl.c:2314
UINT idCmdFirst
Definition: shlobj.h:1317
#define _countof(array)
Definition: sndvol32.h:68
#define FAILED_UNEXPECTEDLY(hr)
Definition: shellutils.h:71
static int iDriveTypeIds[7]
#define MAX_PATH
Definition: compat.h:34
#define WINAPI
Definition: msvc.h:6
#define DFM_MERGECONTEXTMENU
Definition: precomp.h:44
BOOL WINAPI EnumWindows(_In_ WNDENUMPROC, _In_ LPARAM)
#define DFM_CMD_PROPERTIES
Definition: shlobj.h:2429
PVOID HANDLE
Definition: typedefs.h:73
unsigned long DWORD
Definition: ntddk_ex.h:95
#define IDS_DRIVE_REMOVABLE
Definition: shresdef.h:109
HRESULT AppendItemsFromEnumerator(IEnumIDList *pEnum)
#define IDS_DISCONNECT
Definition: shresdef.h:229
#define SetLastError(x)
Definition: compat.h:611
#define __stdcall
Definition: typedefs.h:25
GLbitfield flags
Definition: glext.h:7161
UINT cchMax
BOOL _ILIsDrive(LPCITEMIDLIST pidl)
Definition: pidl.c:1953
#define MFT_SEPARATOR
Definition: winuser.h:739
EXTERN_C void WINAPI SHChangeNotify(LONG wEventId, UINT uFlags, LPCVOID dwItem1, LPCVOID dwItem2)
BOOLEAN PreventMediaRemoval
Definition: ntddstor.h:343
HWND WINAPI GetWindow(_In_ HWND, _In_ UINT)
static const WCHAR L[]
Definition: oid.c:1250
virtual HRESULT WINAPI GetClassID(CLSID *lpClassId)
#define ERROR_INVALID_DRIVE
Definition: winerror.h:118
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
Definition: wincrypt.h:1175
#define MB_ICONERROR
Definition: winuser.h:781
virtual HRESULT WINAPI GetDefaultColumn(DWORD dwRes, ULONG *pSort, ULONG *pDisplay)
virtual HRESULT WINAPI GetDetailsOf(PCUITEMID_CHILD pidl, UINT iColumn, SHELLDETAILS *psd)
static int iDriveIconIds[7]
#define GENERIC_READ
Definition: compat.h:135
UINT WINAPI GetDriveTypeW(IN LPCWSTR lpRootPathName)
Definition: disk.c:497
static unsigned __stdcall format_drive_thread(void *args)
#define IDS_CANTDISCONNECT
Definition: shresdef.h:142
void _ILFreeaPidl(LPITEMIDLIST *apidl, UINT cidl)
Definition: pidl.c:2635
HRESULT WINAPI SHCreateDefaultExtractIcon(REFIID riid, void **ppv)
static const DWORD dwDriveAttributes
#define DRIVE_FIXED
Definition: winbase.h:249
DWORD WINAPI WNetCancelConnection2W(LPCWSTR lpName, DWORD dwFlags, BOOL fForce)
Definition: wnet.c:2418
BOOL WINAPI DestroyMenu(_In_ HMENU)
#define SHCNF_PATHW
Definition: shlobj.h:1764
DWORD WINAPI GetLogicalDrives(VOID)
Definition: disk.c:110
#define IDS_DRIVE_NETWORK
Definition: shresdef.h:107
int WINAPI PathParseIconLocationW(LPWSTR lpszPath)
Definition: path.c:1087
#define ERR(fmt,...)
Definition: debug.h:110
DWORD WINAPI SHFormatDrive(HWND hwnd, UINT drive, UINT fmtID, UINT options)
Definition: drive.cpp:685
BOOL WINAPI GetVolumeInformationW(IN LPCWSTR lpRootPathName, IN LPWSTR lpVolumeNameBuffer, IN DWORD nVolumeNameSize, OUT LPDWORD lpVolumeSerialNumber OPTIONAL, OUT LPDWORD lpMaximumComponentLength OPTIONAL, OUT LPDWORD lpFileSystemFlags OPTIONAL, OUT LPWSTR lpFileSystemNameBuffer OPTIONAL, IN DWORD nFileSystemNameSize)
Definition: volume.c:226
virtual HRESULT WINAPI CallBack(IShellFolder *psf, HWND hwndOwner, IDataObject *pdtobj, UINT uMsg, WPARAM wParam, LPARAM lParam)
HRESULT WINAPI Initialize(HWND hwndOwner, DWORD dwFlags, IEnumIDList *pRegEnumerator)
#define S_OK
Definition: intsafe.h:51
#define SW_SHOWNORMAL
Definition: winuser.h:764
#define shell32_hInstance
HRESULT SH_ShowDriveProperties(WCHAR *pwszDrive, LPCITEMIDLIST pidlFolder, PCUITEMID_CHILD_ARRAY apidl)
Definition: drive.cpp:120
BOOL WINAPI DeviceIoControl(IN HANDLE hDevice, IN DWORD dwIoControlCode, IN LPVOID lpInBuffer OPTIONAL, IN DWORD nInBufferSize OPTIONAL, OUT LPVOID lpOutBuffer OPTIONAL, IN DWORD nOutBufferSize OPTIONAL, OUT LPDWORD lpBytesReturned OPTIONAL, IN LPOVERLAPPED lpOverlapped OPTIONAL)
Definition: deviceio.c:136
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
IN OUT PVCB OUT PDIRENT OUT PBCB IN BOOLEAN CreateFile
Definition: fatprocs.h:913
void shell(int argc, const char *argv[])
Definition: cmds.c:1231
virtual HRESULT WINAPI GetDetailsEx(PCUITEMID_CHILD pidl, const SHCOLUMNID *pscid, VARIANT *pv)
LPITEMIDLIST WINAPI ILClone(LPCITEMIDLIST pidl)
Definition: pidl.c:228
#define MYCOMPUTERSHELLVIEWCOLUMNS
#define COM_INTERFACE_ENTRY_IID(iid, x)
Definition: atlcom.h:561
void pdump(LPCITEMIDLIST pidl)
Definition: debughlp.cpp:248
virtual HRESULT WINAPI BindToStorage(PCUIDLIST_RELATIVE pidl, LPBC pbcReserved, REFIID riid, LPVOID *ppvOut)
#define E_NOTIMPL
Definition: ddrawi.h:99
virtual HRESULT WINAPI CreateViewObject(HWND hwndOwner, REFIID riid, LPVOID *ppvOut)
HRESULT CDrivesContextMenu_CreateInstance(PCIDLIST_ABSOLUTE pidlFolder, HWND hwnd, UINT cidl, PCUITEMID_CHILD_ARRAY apidl, IShellFolder *psf, IContextMenu **ppcm)
__int3264 LONG_PTR
Definition: mstsclib_h.h:276
_CRTIMP wchar_t *__cdecl wcscat(_Inout_updates_z_(_String_length_(_Dest)+_String_length_(_Source)+1) wchar_t *_Dest, _In_z_ const wchar_t *_Source)
virtual HRESULT WINAPI EnumObjects(HWND hwndOwner, DWORD dwFlags, LPENUMIDLIST *ppEnumIDList)
unsigned int UINT
Definition: ndis.h:50
#define NULL
Definition: types.h:112
#define GW_OWNER
Definition: winuser.h:761
HANDLE WINAPI GetPropW(_In_ HWND, _In_ LPCWSTR)
DWORD WINAPI ExpandEnvironmentStringsW(IN LPCWSTR lpSrc, IN LPWSTR lpDst, IN DWORD nSize)
Definition: environ.c:519
WINE_DEFAULT_DEBUG_CHANNEL(shell)
HANDLE hThread
Definition: wizard.c:27
#define IDI_SHELL_CDROM
Definition: shresdef.h:507
virtual HRESULT WINAPI GetDefaultColumnState(UINT iColumn, DWORD *pcsFlags)
int WINAPI PathGetDriveNumberW(const WCHAR *path)
Definition: path.c:548
HMENU WINAPI CreatePopupMenu(void)
Definition: menu.c:846
static BOOL CALLBACK EnumStubProc2(HWND hwnd, LPARAM lParam)
void WINAPI SHFree(LPVOID pv)
Definition: shellole.c:331
const ITEMIDLIST_RELATIVE UNALIGNED * PCUIDLIST_RELATIVE
Definition: shtypes.idl:57
#define HRESULT_CODE(hr)
Definition: winerror.h:76
BOOL WINAPI GetDiskFreeSpaceExA(IN LPCSTR lpDirectoryName OPTIONAL, OUT PULARGE_INTEGER lpFreeBytesAvailableToCaller, OUT PULARGE_INTEGER lpTotalNumberOfBytes, OUT PULARGE_INTEGER lpTotalNumberOfFreeBytes)
Definition: disk.c:313
static const WCHAR szName[]
Definition: msipriv.h:1194
HINSTANCE WINAPI ShellExecuteW(HWND hwnd, LPCWSTR lpVerb, LPCWSTR lpFile, LPCWSTR lpParameters, LPCWSTR lpDirectory, INT nShowCmd)
Definition: shlexec.cpp:2274
#define FSCTL_LOCK_VOLUME
Definition: nt_native.h:832
unsigned int ULONG
Definition: retypes.h:1
IUnknown * punkAssociationInfo
Definition: shlobj.h:2372
virtual HRESULT WINAPI EnumSearches(IEnumExtraSearch **ppenum)
#define IDI_SHELL_RAMDISK
Definition: shresdef.h:508
#define IDI_SHELL_NETDRIVE
Definition: shresdef.h:505
#define MAKEINTRESOURCEW(i)
Definition: winuser.h:582
#define WS_EX_APPWINDOW
Definition: winuser.h:383
#define END_COM_MAP()
Definition: atlcom.h:552
#define FILE_READ_ONLY_VOLUME
Definition: from_kernel.h:246
#define IDS_SHV_COLUMN_NAME
Definition: resource.h:74
WCHAR * LPWSTR
Definition: xmlstorage.h:184
UINT uType
Definition: shtypes.idl:93
#define E_POINTER
Definition: winerror.h:2365
static BOOL DoEjectDrive(const WCHAR *physical, UINT nDriveType, INT *pnStringID)
Arabic default style
Definition: afstyles.h:93
PCUITEMID_CHILD_ARRAY apidl
Definition: shlobj.h:2371
DWORD _ILGetDrive(LPCITEMIDLIST pidl, LPSTR pOut, UINT uSize)
Definition: pidl.c:1855
LPITEMIDLIST pidlRoot
Definition: CDrivesFolder.h:35
ITEMIDLIST UNALIGNED * LPITEMIDLIST
Definition: shtypes.idl:41
static const shvheader MyComputerSFHeader[]
static const CLSID *static CLSID *static const GUID VARIANT VARIANT *static IServiceProvider DWORD *static HMENU
Definition: ordinal.c:60
static TfClientId tid
PCIDLIST_ABSOLUTE pidlFolder
Definition: shlobj.h:2368
LPVOID WINAPI CoTaskMemAlloc(SIZE_T size)
Definition: ifs.c:426
LPARAM lParam
Definition: combotst.c:139
#define LOWORD(l)
Definition: pedump.c:82
#define SHCNE_DRIVEREMOVED
Definition: shlobj.h:1736
size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
HRESULT WINAPI CDefFolderMenu_Create2(PCIDLIST_ABSOLUTE pidlFolder, HWND hwnd, UINT cidl, PCUITEMID_CHILD_ARRAY apidl, IShellFolder *psf, LPFNDFMCALLBACK lpfn, UINT nKeys, const HKEY *ahkeyClsKeys, IContextMenu **ppcm)
#define IsEqualIID(riid1, riid2)
Definition: guiddef.h:95
#define SHCNF_FLUSHNOWAIT
Definition: shlobj.h:1768
LONGLONG QuadPart
Definition: typedefs.h:114
#define IDS_DRIVE_FLOPPY
Definition: shresdef.h:108
#define IDS_EJECT
Definition: shresdef.h:228