1 // Licensed under the Apache License, Version 2.0
2 // <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
3 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
4 // All files in the project carrying such notice may not be copied, modified, or distributed
5 // except according to those terms
6 //! SHELL.DLL functions, types, and definitions
7 use ctypes::{__int64, c_int, c_void};
8 use shared::basetsd::{DWORD_PTR, UINT_PTR};
9 use shared::guiddef::{GUID, REFIID};
10 use shared::minwindef::{
11     BOOL, DWORD, FILETIME, HINSTANCE, HKEY, INT, LPARAM, LPVOID, MAX_PATH, UINT, ULONG, WORD,
12 };
13 use shared::windef::{HICON, HWND, POINT, RECT};
14 use um::minwinbase::LPSECURITY_ATTRIBUTES;
15 use um::processthreadsapi::{LPPROCESS_INFORMATION, LPSTARTUPINFOW};
16 use um::winnt::{
17     CHAR, HANDLE, HRESULT, LPCSTR, LPCWSTR, LPSTR, LPWSTR, PCSTR, PCWSTR, PCZZSTR, PCZZWSTR, PWSTR,
18     PZZSTR, PZZWSTR, ULARGE_INTEGER, WCHAR,
19 };
20 use um::winuser::WM_USER;
21 DECLARE_HANDLE!{HDROP, HDROP__}
22 extern "system" {
DragQueryFileA( hDrop: HDROP, iFile: UINT, lpszFile: LPSTR, cch: UINT, ) -> UINT23     pub fn DragQueryFileA(
24         hDrop: HDROP,
25         iFile: UINT,
26         lpszFile: LPSTR,
27         cch: UINT,
28     ) -> UINT;
DragQueryFileW( hDrop: HDROP, iFile: UINT, lpszFile: LPWSTR, cch: UINT, ) -> UINT29     pub fn DragQueryFileW(
30         hDrop: HDROP,
31         iFile: UINT,
32         lpszFile: LPWSTR,
33         cch: UINT,
34     ) -> UINT;
DragQueryPoint( hDrop: HDROP, lppt: *mut POINT, ) -> BOOL35     pub fn DragQueryPoint(
36         hDrop: HDROP,
37         lppt: *mut POINT,
38     ) -> BOOL;
DragFinish( hDrop: HDROP, )39     pub fn DragFinish(
40         hDrop: HDROP,
41     );
DragAcceptFiles( hWnd: HWND, fAccept: BOOL, )42     pub fn DragAcceptFiles(
43         hWnd: HWND,
44         fAccept: BOOL,
45     );
ShellExecuteA( hwnd: HWND, lpOperation: LPCSTR, lpFile: LPCSTR, lpParameters: LPCSTR, lpDirectory: LPCSTR, nShowCmd: c_int, ) -> HINSTANCE46     pub fn ShellExecuteA(
47         hwnd: HWND,
48         lpOperation: LPCSTR,
49         lpFile: LPCSTR,
50         lpParameters: LPCSTR,
51         lpDirectory: LPCSTR,
52         nShowCmd: c_int,
53     ) -> HINSTANCE;
ShellExecuteW( hwnd: HWND, lpOperation: LPCWSTR, lpFile: LPCWSTR, lpParameters: LPCWSTR, lpDirectory: LPCWSTR, nShowCmd: c_int, ) -> HINSTANCE54     pub fn ShellExecuteW(
55         hwnd: HWND,
56         lpOperation: LPCWSTR,
57         lpFile: LPCWSTR,
58         lpParameters: LPCWSTR,
59         lpDirectory: LPCWSTR,
60         nShowCmd: c_int,
61     ) -> HINSTANCE;
FindExecutableA( lpFile: LPCSTR, lpDirectory: LPCSTR, lpResult: LPSTR, ) -> HINSTANCE62     pub fn FindExecutableA(
63         lpFile: LPCSTR,
64         lpDirectory: LPCSTR,
65         lpResult: LPSTR,
66     ) -> HINSTANCE;
FindExecutableW( lpFile: LPCWSTR, lpDirectory: LPCWSTR, lpResult: LPWSTR, ) -> HINSTANCE67     pub fn FindExecutableW(
68         lpFile: LPCWSTR,
69         lpDirectory: LPCWSTR,
70         lpResult: LPWSTR,
71     ) -> HINSTANCE;
CommandLineToArgvW( lpCmdLine: LPCWSTR, pNumArgs: *mut c_int, ) -> *mut LPWSTR72     pub fn CommandLineToArgvW(
73         lpCmdLine: LPCWSTR,
74         pNumArgs: *mut c_int,
75     ) -> *mut LPWSTR;
ShellAboutA( hWnd: HWND, szApp: LPCSTR, szOtherStuff: LPCSTR, hIcon: HICON, ) -> INT76     pub fn ShellAboutA(
77         hWnd: HWND,
78         szApp: LPCSTR,
79         szOtherStuff: LPCSTR,
80         hIcon: HICON,
81     ) -> INT;
ShellAboutW( hWnd: HWND, szApp: LPCWSTR, szOtherStuff: LPCWSTR, hIcon: HICON, ) -> INT82     pub fn ShellAboutW(
83         hWnd: HWND,
84         szApp: LPCWSTR,
85         szOtherStuff: LPCWSTR,
86         hIcon: HICON,
87     ) -> INT;
DuplicateIcon( hInst: HINSTANCE, hIcon: HICON, ) -> HICON88     pub fn DuplicateIcon(
89         hInst: HINSTANCE,
90         hIcon: HICON,
91     ) -> HICON;
ExtractAssociatedIconA( hInst: HINSTANCE, pszIconPath: LPSTR, piIcon: *mut WORD, ) -> HICON92     pub fn ExtractAssociatedIconA(
93         hInst: HINSTANCE,
94         pszIconPath: LPSTR,
95         piIcon: *mut WORD,
96     ) -> HICON;
ExtractAssociatedIconW( hInst: HINSTANCE, pszIconPath: LPWSTR, piIcon: *mut WORD, ) -> HICON97     pub fn ExtractAssociatedIconW(
98         hInst: HINSTANCE,
99         pszIconPath: LPWSTR,
100         piIcon: *mut WORD,
101     ) -> HICON;
ExtractAssociatedIconExA( hInst: HINSTANCE, pszIconPath: LPSTR, piIconIndex: *mut WORD, piIconId: *mut WORD, ) -> HICON102     pub fn ExtractAssociatedIconExA(
103         hInst: HINSTANCE,
104         pszIconPath: LPSTR,
105         piIconIndex: *mut WORD,
106         piIconId: *mut WORD,
107     ) -> HICON;
ExtractAssociatedIconExW( hInst: HINSTANCE, pszIconPath: LPWSTR, piIconIndex: *mut WORD, piIconId: *mut WORD, ) -> HICON108     pub fn ExtractAssociatedIconExW(
109         hInst: HINSTANCE,
110         pszIconPath: LPWSTR,
111         piIconIndex: *mut WORD,
112         piIconId: *mut WORD,
113     ) -> HICON;
ExtractIconA( hInst: HINSTANCE, pszExeFileName: LPCSTR, nIconIndex: UINT, ) -> HICON114     pub fn ExtractIconA(
115         hInst: HINSTANCE,
116         pszExeFileName: LPCSTR,
117         nIconIndex: UINT,
118     ) -> HICON;
ExtractIconW( hInst: HINSTANCE, pszExeFileName: LPCWSTR, nIconIndex: UINT, ) -> HICON119     pub fn ExtractIconW(
120         hInst: HINSTANCE,
121         pszExeFileName: LPCWSTR,
122         nIconIndex: UINT,
123     ) -> HICON;
124 }
125 STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct DRAGINFOA {
126     uSize: UINT,
127     pt: POINT,
128     fNC: BOOL,
129     lpFileList: PZZSTR,
130     grfKeyState: DWORD,
131 }}
132 pub type LPDRAGINFOA = *mut DRAGINFOA;
133 STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct DRAGINFOW {
134     uSize: UINT,
135     pt: POINT,
136     fNC: BOOL,
137     lpFileList: PZZWSTR,
138     grfKeyState: DWORD,
139 }}
140 pub type LPDRAGINFOW = *mut DRAGINFOW;
141 pub const ABM_NEW: DWORD = 0x00000000;
142 pub const ABM_REMOVE: DWORD = 0x00000001;
143 pub const ABM_QUERYPOS: DWORD = 0x00000002;
144 pub const ABM_SETPOS: DWORD = 0x00000003;
145 pub const ABM_GETSTATE: DWORD = 0x00000004;
146 pub const ABM_GETTASKBARPOS: DWORD = 0x00000005;
147 pub const ABM_ACTIVATE: DWORD = 0x00000006;
148 pub const ABM_GETAUTOHIDEBAR: DWORD = 0x00000007;
149 pub const ABM_SETAUTOHIDEBAR: DWORD = 0x00000008;
150 pub const ABM_WINDOWPOSCHANGED: DWORD = 0x0000009;
151 pub const ABM_SETSTATE: DWORD = 0x0000000a;
152 pub const ABM_GETAUTOHIDEBAREX: DWORD = 0x0000000b;
153 pub const ABM_SETAUTOHIDEBAREX: DWORD = 0x0000000c;
154 pub const ABN_STATECHANGE: DWORD = 0x0000000;
155 pub const ABN_POSCHANGED: DWORD = 0x0000001;
156 pub const ABN_FULLSCREENAPP: DWORD = 0x0000002;
157 pub const ABN_WINDOWARRANGE: DWORD = 0x0000003;
158 pub const ABS_AUTOHIDE: UINT = 0x0000001;
159 pub const ABS_ALWAYSONTOP: UINT = 0x0000002;
160 pub const ABE_LEFT: UINT = 0;
161 pub const ABE_TOP: UINT = 1;
162 pub const ABE_RIGHT: UINT = 2;
163 pub const ABE_BOTTOM: UINT = 3;
164 STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct APPBARDATA {
165     cbSize: DWORD,
166     hWnd: HWND,
167     uCallbackMessage: UINT,
168     uEdge: UINT,
169     rc: RECT,
170     lParam: LPARAM,
171 }}
172 pub type PAPPBARDATA = *mut APPBARDATA;
173 extern "system" {
SHAppBarMessage( dwMessage: DWORD, pData: PAPPBARDATA, ) -> UINT_PTR174     pub fn SHAppBarMessage(
175         dwMessage: DWORD,
176         pData: PAPPBARDATA,
177     ) -> UINT_PTR;
DoEnvironmentSubstA( pszSrc: LPSTR, cchSrc: UINT, ) -> DWORD178     pub fn DoEnvironmentSubstA(
179         pszSrc: LPSTR,
180         cchSrc: UINT,
181     ) -> DWORD;
DoEnvironmentSubstW( pszSrc: LPWSTR, cchSrc: UINT, ) -> DWORD182     pub fn DoEnvironmentSubstW(
183         pszSrc: LPWSTR,
184         cchSrc: UINT,
185     ) -> DWORD;
ExtractIconExA( lpszFile: LPCSTR, nIconIndex: c_int, phiconLarge: *mut HICON, phiconSmall: *mut HICON, nIcons: UINT, ) -> UINT186     pub fn ExtractIconExA(
187         lpszFile: LPCSTR,
188         nIconIndex: c_int,
189         phiconLarge: *mut HICON,
190         phiconSmall: *mut HICON,
191         nIcons: UINT,
192     ) -> UINT;
ExtractIconExW( lpszFile: LPCWSTR, nIconIndex: c_int, phiconLarge: *mut HICON, phiconSmall: *mut HICON, nIcons: UINT, ) -> UINT193     pub fn ExtractIconExW(
194         lpszFile: LPCWSTR,
195         nIconIndex: c_int,
196         phiconLarge: *mut HICON,
197         phiconSmall: *mut HICON,
198         nIcons: UINT,
199     ) -> UINT;
200 }
201 pub const FO_MOVE: WORD = 0x0001;
202 pub const FO_COPY: WORD = 0x0002;
203 pub const FO_DELETE: WORD = 0x0003;
204 pub const FO_RENAME: WORD = 0x0004;
205 pub const FOF_MULTIDESTFILES: WORD = 0x0001;
206 pub const FOF_CONFIRMMOUSE: WORD = 0x0002;
207 pub const FOF_SILENT: WORD = 0x0004;
208 pub const FOF_RENAMEONCOLLISION: WORD = 0x0008;
209 pub const FOF_NOCONFIRMATION: WORD = 0x0010;
210 pub const FOF_WANTMAPPINGHANDLE: WORD = 0x0020;
211 pub const FOF_ALLOWUNDO: WORD = 0x0040;
212 pub const FOF_FILESONLY: WORD = 0x0080;
213 pub const FOF_SIMPLEPROGRESS: WORD = 0x0100;
214 pub const FOF_NOCONFIRMMKDIR: WORD = 0x0200;
215 pub const FOF_NOERRORUI: WORD = 0x0400;
216 pub const FOF_NOCOPYSECURITYATTRIBS: WORD = 0x0800;
217 pub const FOF_NORECURSION: WORD = 0x1000;
218 pub const FOF_NO_CONNECTED_ELEMENTS: WORD = 0x2000;
219 pub const FOF_WANTNUKEWARNING: WORD = 0x4000;
220 pub const FOF_NORECURSEREPARSE: WORD = 0x8000;
221 pub const FOF_NO_UI: WORD = FOF_SILENT | FOF_NOCONFIRMATION | FOF_NOERRORUI | FOF_NOCONFIRMMKDIR;
222 pub type FILEOP_FLAGS = WORD;
223 pub const PO_DELETE: WORD = 0x0013;
224 pub const PO_RENAME: WORD = 0x0014;
225 pub const PO_PORTCHANGE: WORD = 0x0020;
226 pub const PO_REN_PORT: WORD = 0x0034;
227 pub type PRINTEROP_FLAGS = WORD;
228 STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SHFILEOPSTRUCTA {
229     hwnd: HWND,
230     wFunc: UINT,
231     pFrom: PCZZSTR,
232     pTo: PCZZSTR,
233     fFlags: FILEOP_FLAGS,
234     fAnyOperationsAborted: BOOL,
235     hNameMappings: LPVOID,
236     lpszProgressTitle: PCSTR,
237 }}
238 pub type LPSHFILEOPSTRUCTA = *mut SHFILEOPSTRUCTA;
239 STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SHFILEOPSTRUCTW {
240     hwnd: HWND,
241     wFunc: UINT,
242     pFrom: PCZZWSTR,
243     pTo: PCZZWSTR,
244     fFlags: FILEOP_FLAGS,
245     fAnyOperationsAborted: BOOL,
246     hNameMappings: LPVOID,
247     lpszProgressTitle: PCWSTR,
248 }}
249 pub type LPSHFILEOPSTRUCTW = *mut SHFILEOPSTRUCTW;
250 extern "system" {
SHFileOperationA( lpFileOp: LPSHFILEOPSTRUCTA, ) -> c_int251     pub fn SHFileOperationA(
252         lpFileOp: LPSHFILEOPSTRUCTA,
253     ) -> c_int;
SHFileOperationW( lpFileOp: LPSHFILEOPSTRUCTW, ) -> c_int254     pub fn SHFileOperationW(
255         lpFileOp: LPSHFILEOPSTRUCTW,
256     ) -> c_int;
SHFreeNameMappings( hNameMappings: HANDLE, )257     pub fn SHFreeNameMappings(
258         hNameMappings: HANDLE,
259     );
260 }
261 STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SHNAMEMAPPINGA {
262     pszOldPath: LPSTR,
263     pszNewPath: LPSTR,
264     cchOldPath: c_int,
265     cchNewPath: c_int,
266 }}
267 pub type LPSHNAMEMAPPINGA = *mut SHNAMEMAPPINGA;
268 STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SHNAMEMAPPINGW {
269     pszOldPath: LPWSTR,
270     pszNewPath: LPWSTR,
271     cchOldPath: c_int,
272     cchNewPath: c_int,
273 }}
274 pub type LPSHNAMEMAPPINGW = *mut SHNAMEMAPPINGW;
275 pub const SE_ERR_FNF: DWORD = 2;
276 pub const SE_ERR_PNF: DWORD = 3;
277 pub const SE_ERR_ACCESSDENIED: DWORD = 5;
278 pub const SE_ERR_OOM: DWORD = 8;
279 pub const SE_ERR_DLLNOTFOUND: DWORD = 32;
280 pub const SE_ERR_SHARE: DWORD = 26;
281 pub const SE_ERR_ASSOCINCOMPLETE: DWORD = 27;
282 pub const SE_ERR_DDETIMEOUT: DWORD = 28;
283 pub const SE_ERR_DDEFAIL: DWORD = 29;
284 pub const SE_ERR_DDEBUSY: DWORD = 30;
285 pub const SE_ERR_NOASSOC: DWORD = 31;
286 pub const SEE_MASK_DEFAULT: DWORD = 0x00000000;
287 pub const SEE_MASK_CLASSNAME: DWORD = 0x00000001;
288 pub const SEE_MASK_CLASSKEY: DWORD = 0x00000003;
289 pub const SEE_MASK_IDLIST: DWORD = 0x00000004;
290 pub const SEE_MASK_INVOKEIDLIST: DWORD = 0x0000000c;
291 pub const SEE_MASK_ICON: DWORD = 0x00000010;
292 pub const SEE_MASK_HOTKEY: DWORD = 0x00000020;
293 pub const SEE_MASK_NOCLOSEPROCESS: DWORD = 0x00000040;
294 pub const SEE_MASK_CONNECTNETDRV: DWORD = 0x00000080;
295 pub const SEE_MASK_NOASYNC: DWORD = 0x00000100;
296 pub const SEE_MASK_FLAG_DDEWAIT: DWORD = SEE_MASK_NOASYNC;
297 pub const SEE_MASK_DOENVSUBST: DWORD = 0x00000200;
298 pub const SEE_MASK_FLAG_NO_UI: DWORD = 0x00000400;
299 pub const SEE_MASK_UNICODE: DWORD = 0x00004000;
300 pub const SEE_MASK_NO_CONSOLE: DWORD = 0x00008000;
301 pub const SEE_MASK_ASYNCOK: DWORD = 0x00100000;
302 pub const SEE_MASK_HMONITOR: DWORD = 0x00200000;
303 pub const SEE_MASK_NOZONECHECKS: DWORD = 0x00800000;
304 pub const SEE_MASK_NOQUERYCLASSSTORE: DWORD = 0x01000000;
305 pub const SEE_MASK_WAITFORINPUTIDLE: DWORD = 0x02000000;
306 pub const SEE_MASK_FLAG_LOG_USAGE: DWORD = 0x04000000;
307 pub const SEE_MASK_FLAG_HINST_IS_SITE: DWORD = 0x08000000;
308 STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SHELLEXECUTEINFOA {
309     cbSize: DWORD,
310     fMask: ULONG,
311     hwnd: HWND,
312     lpVerb: LPCSTR,
313     lpFile: LPCSTR,
314     lpParameters: LPCSTR,
315     lpDirectory: LPCSTR,
316     nShow: c_int,
317     hInstApp: HINSTANCE,
318     lpIDList: *mut c_void,
319     lpClass: LPCSTR,
320     hkeyClass: HKEY,
321     dwHotKey: DWORD,
322     hMonitor: HANDLE,
323     hProcess: HANDLE,
324 }}
325 pub type LPSHELLEXECUTEINFOA = *mut SHELLEXECUTEINFOA;
326 STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SHELLEXECUTEINFOW {
327     cbSize: DWORD,
328     fMask: ULONG,
329     hwnd: HWND,
330     lpVerb: LPCWSTR,
331     lpFile: LPCWSTR,
332     lpParameters: LPCWSTR,
333     lpDirectory: LPCWSTR,
334     nShow: c_int,
335     hInstApp: HINSTANCE,
336     lpIDList: *mut c_void,
337     lpClass: LPCWSTR,
338     hkeyClass: HKEY,
339     dwHotKey: DWORD,
340     hMonitor: HANDLE,
341     hProcess: HANDLE,
342 }}
343 pub type LPSHELLEXECUTEINFOW = *mut SHELLEXECUTEINFOW;
344 extern "system" {
ShellExecuteExA( pExecInfo: *mut SHELLEXECUTEINFOA, ) -> BOOL345     pub fn ShellExecuteExA(
346         pExecInfo: *mut SHELLEXECUTEINFOA,
347     ) -> BOOL;
ShellExecuteExW( pExecInfo: *mut SHELLEXECUTEINFOW, ) -> BOOL348     pub fn ShellExecuteExW(
349         pExecInfo: *mut SHELLEXECUTEINFOW,
350     ) -> BOOL;
351 }
352 STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SHCREATEPROCESSINFOW {
353     cbSize: DWORD,
354     fMask: ULONG,
355     hwnd: HWND,
356     pszFile: LPCWSTR,
357     pszParameters: LPCWSTR,
358     pszCurrentDirectory: LPCWSTR,
359     hUserToken: HANDLE,
360     lpProcessAttributes: LPSECURITY_ATTRIBUTES,
361     lpThreadAttributes: LPSECURITY_ATTRIBUTES,
362     bInheritHandles: BOOL,
363     dwCreationFlags: DWORD,
364     lpStartupInfo: LPSTARTUPINFOW,
365     lpProcessInformation: LPPROCESS_INFORMATION,
366 }}
367 pub type PSHCREATEPROCESSINFOW = *mut SHCREATEPROCESSINFOW;
368 extern "system" {
SHCreateProcessAsUserW( pscpi: PSHCREATEPROCESSINFOW, ) -> BOOL369     pub fn SHCreateProcessAsUserW(
370         pscpi: PSHCREATEPROCESSINFOW,
371     ) -> BOOL;
SHEvaluateSystemCommandTemplate( pszCmdTemplate: PCWSTR, ppszApplication: *mut PWSTR, ppszCommandLine: *mut PWSTR, ppszParameters: *mut PWSTR, ) -> HRESULT372     pub fn SHEvaluateSystemCommandTemplate(
373         pszCmdTemplate: PCWSTR,
374         ppszApplication: *mut PWSTR,
375         ppszCommandLine: *mut PWSTR,
376         ppszParameters: *mut PWSTR,
377     ) -> HRESULT;
378 }
379 ENUM!{enum ASSOCCLASS {
380     ASSOCCLASS_SHELL_KEY = 0,
381     ASSOCCLASS_PROGID_KEY,
382     ASSOCCLASS_PROGID_STR,
383     ASSOCCLASS_CLSID_KEY,
384     ASSOCCLASS_CLSID_STR,
385     ASSOCCLASS_APP_KEY,
386     ASSOCCLASS_APP_STR,
387     ASSOCCLASS_SYSTEM_STR,
388     ASSOCCLASS_FOLDER,
389     ASSOCCLASS_STAR,
390     ASSOCCLASS_FIXED_PROGID_STR,
391     ASSOCCLASS_PROTOCOL_STR,
392 }}
393 STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct ASSOCIATIONELEMENT {
394     ac: ASSOCCLASS,
395     hkClass: HKEY,
396     pszClass: PCWSTR,
397 }}
398 extern "system" {
AssocCreateForClasses( rgClasses: *const ASSOCIATIONELEMENT, cClasses: ULONG, riid: REFIID, ppv: *mut *mut c_void, ) -> HRESULT399     pub fn AssocCreateForClasses(
400         rgClasses: *const ASSOCIATIONELEMENT,
401         cClasses: ULONG,
402         riid: REFIID,
403         ppv: *mut *mut c_void,
404     ) -> HRESULT;
405 }
406 STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SHQUERYRBINFO {
407     cbSize: DWORD,
408     i64Size: __int64,
409     i64NumItems: __int64,
410 }}
411 pub type LPSHQUERYRBINFO = *mut SHQUERYRBINFO;
412 pub const SHERB_NOCONFIRMATION: DWORD = 0x00000001;
413 pub const SHERB_NOPROGRESSUI: DWORD = 0x00000002;
414 pub const SHERB_NOSOUND: DWORD = 0x00000004;
415 extern "system" {
SHQueryRecycleBinA( pszRootPath: LPCSTR, pSHQueryRBInfo: LPSHQUERYRBINFO, ) -> HRESULT416     pub fn SHQueryRecycleBinA(
417         pszRootPath: LPCSTR,
418         pSHQueryRBInfo: LPSHQUERYRBINFO,
419     ) -> HRESULT;
SHQueryRecycleBinW( pszRootPath: LPCWSTR, pSHQueryRBInfo: LPSHQUERYRBINFO, ) -> HRESULT420     pub fn SHQueryRecycleBinW(
421         pszRootPath: LPCWSTR,
422         pSHQueryRBInfo: LPSHQUERYRBINFO,
423     ) -> HRESULT;
SHEmptyRecycleBinA( hwnd: HWND, pszRootPath: LPCSTR, dwFlags: DWORD, ) -> HRESULT424     pub fn SHEmptyRecycleBinA(
425         hwnd: HWND,
426         pszRootPath: LPCSTR,
427         dwFlags: DWORD,
428     ) -> HRESULT;
SHEmptyRecycleBinW( hwnd: HWND, pszRootPath: LPCWSTR, dwFlags: DWORD, ) -> HRESULT429     pub fn SHEmptyRecycleBinW(
430         hwnd: HWND,
431         pszRootPath: LPCWSTR,
432         dwFlags: DWORD,
433     ) -> HRESULT;
434 }
435 ENUM!{enum QUERY_USER_NOTIFICATION_STATE {
436     QUNS_NOT_PRESENT = 1,
437     QUNS_BUSY = 2,
438     QUNS_RUNNING_D3D_FULL_SCREEN = 3,
439     QUNS_PRESENTATION_MODE = 4,
440     QUNS_ACCEPTS_NOTIFICATIONS = 5,
441     QUNS_QUIET_TIME = 6,
442     QUNS_APP = 7,
443 }}
444 extern "system" {
SHQueryUserNotificationState( pquns: *mut QUERY_USER_NOTIFICATION_STATE, ) -> HRESULT445     pub fn SHQueryUserNotificationState(
446         pquns: *mut QUERY_USER_NOTIFICATION_STATE,
447     ) -> HRESULT;
SHGetPropertyStoreForWindow( hwnd: HWND, riid: REFIID, ppv: *mut *mut c_void, ) -> HRESULT448     pub fn SHGetPropertyStoreForWindow(
449         hwnd: HWND,
450         riid: REFIID,
451         ppv: *mut *mut c_void,
452     ) -> HRESULT;
453 }
454 UNION!{#[cfg_attr(target_arch = "x86", repr(packed))] union NOTIFYICONDATAA_u {
455     [u32; 1],
456     uTimeout uTimeout_mut: UINT,
457     uVersion uVersion_mut: UINT,
458 }}
459 STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct NOTIFYICONDATAA {
460     cbSize: DWORD,
461     hWnd: HWND,
462     uID: UINT,
463     uFlags: UINT,
464     uCallbackMessage: UINT,
465     hIcon: HICON,
466     szTip: [CHAR; 128],
467     dwState: DWORD,
468     dwStateMask: DWORD,
469     szInfo: [CHAR; 256],
470     u: NOTIFYICONDATAA_u,
471     szInfoTitle: [CHAR; 64],
472     dwInfoFlags: DWORD,
473     guidItem: GUID,
474     hBalloonIcon: HICON,
475 }}
476 pub type PNOTIFYICONDATAA = *mut NOTIFYICONDATAA;
477 UNION!{#[cfg_attr(target_arch = "x86", repr(packed))] union NOTIFYICONDATAW_u {
478     [u32; 1],
479     uTimeout uTimeout_mut: UINT,
480     uVersion uVersion_mut: UINT,
481 }}
482 STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct NOTIFYICONDATAW {
483     cbSize: DWORD,
484     hWnd: HWND,
485     uID: UINT,
486     uFlags: UINT,
487     uCallbackMessage: UINT,
488     hIcon: HICON,
489     szTip: [WCHAR; 128],
490     dwState: DWORD,
491     dwStateMask: DWORD,
492     szInfo: [WCHAR; 256],
493     u: NOTIFYICONDATAW_u,
494     szInfoTitle: [WCHAR; 64],
495     dwInfoFlags: DWORD,
496     guidItem: GUID,
497     hBalloonIcon: HICON,
498 }}
499 pub type PNOTIFYICONDATAW = *mut NOTIFYICONDATAW;
500 pub const NIN_SELECT: DWORD = WM_USER + 0;
501 pub const NINF_KEY: DWORD = 0x1;
502 pub const NIN_KEYSELECT: DWORD = NIN_SELECT | NINF_KEY;
503 pub const NIN_BALLOONSHOW: DWORD = WM_USER + 2;
504 pub const NIN_BALLOONHIDE: DWORD = WM_USER + 3;
505 pub const NIN_BALLOONTIMEOUT: DWORD = WM_USER + 4;
506 pub const NIN_BALLOONUSERCLICK: DWORD = WM_USER + 5;
507 pub const NIN_POPUPOPEN: DWORD = WM_USER + 6;
508 pub const NIN_POPUPCLOSE: DWORD = WM_USER + 7;
509 pub const NIM_ADD: DWORD = 0x00000000;
510 pub const NIM_MODIFY: DWORD = 0x00000001;
511 pub const NIM_DELETE: DWORD = 0x00000002;
512 pub const NIM_SETFOCUS: DWORD = 0x00000003;
513 pub const NIM_SETVERSION: DWORD = 0x00000004;
514 pub const NOTIFYICON_VERSION: DWORD = 3;
515 pub const NOTIFYICON_VERSION_4: DWORD = 4;
516 pub const NIF_MESSAGE: DWORD = 0x00000001;
517 pub const NIF_ICON: DWORD = 0x00000002;
518 pub const NIF_TIP: DWORD = 0x00000004;
519 pub const NIF_STATE: DWORD = 0x00000008;
520 pub const NIF_INFO: DWORD = 0x00000010;
521 pub const NIF_GUID: DWORD = 0x00000020;
522 pub const NIF_REALTIME: DWORD = 0x00000040;
523 pub const NIF_SHOWTIP: DWORD = 0x00000080;
524 pub const NIS_HIDDEN: DWORD = 0x00000001;
525 pub const NIS_SHAREDICON: DWORD = 0x00000002;
526 pub const NIIF_NONE: DWORD = 0x00000000;
527 pub const NIIF_INFO: DWORD = 0x00000001;
528 pub const NIIF_WARNING: DWORD = 0x00000002;
529 pub const NIIF_ERROR: DWORD = 0x00000003;
530 pub const NIIF_USER: DWORD = 0x00000004;
531 pub const NIIF_ICON_MASK: DWORD = 0x0000000F;
532 pub const NIIF_NOSOUND: DWORD = 0x00000010;
533 pub const NIIF_LARGE_ICON: DWORD = 0x00000020;
534 pub const NIIF_RESPECT_QUIET_TIME: DWORD = 0x00000080;
535 STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct NOTIFYICONIDENTIFIER {
536     cbSize: DWORD,
537     hWnd: HWND,
538     uID: UINT,
539     guidItem: GUID,
540 }}
541 pub type PNOTIFYICONIDENTIFIER = *mut NOTIFYICONIDENTIFIER;
542 extern "system" {
Shell_NotifyIconA( dwMessage: DWORD, lpData: PNOTIFYICONDATAA, ) -> BOOL543     pub fn Shell_NotifyIconA(
544         dwMessage: DWORD,
545         lpData: PNOTIFYICONDATAA,
546     ) -> BOOL;
Shell_NotifyIconW( dwMessage: DWORD, lpData: PNOTIFYICONDATAW, ) -> BOOL547     pub fn Shell_NotifyIconW(
548         dwMessage: DWORD,
549         lpData: PNOTIFYICONDATAW,
550     ) -> BOOL;
Shell_NotifyIconGetRect( identifier: *const NOTIFYICONIDENTIFIER, iconLocation: *mut RECT, ) -> HRESULT551     pub fn Shell_NotifyIconGetRect(
552         identifier: *const NOTIFYICONIDENTIFIER,
553         iconLocation: *mut RECT,
554     ) -> HRESULT;
555 }
556 STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SHFILEINFOA {
557     hIcon: HICON,
558     iIcon: c_int,
559     dwAttributes: DWORD,
560     szDisplayName: [CHAR; MAX_PATH],
561     szTypeName: [CHAR; 80],
562 }}
563 STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SHFILEINFOW {
564     hIcon: HICON,
565     iIcon: c_int,
566     dwAttributes: DWORD,
567     szDisplayName: [WCHAR; MAX_PATH],
568     szTypeName: [WCHAR; 80],
569 }}
570 pub const SHGFI_ICON: DWORD = 0x000000100;
571 pub const SHGFI_DISPLAYNAME: DWORD = 0x000000200;
572 pub const SHGFI_TYPENAME: DWORD = 0x000000400;
573 pub const SHGFI_ATTRIBUTES: DWORD = 0x000000800;
574 pub const SHGFI_ICONLOCATION: DWORD = 0x000001000;
575 pub const SHGFI_EXETYPE: DWORD = 0x000002000;
576 pub const SHGFI_SYSICONINDEX: DWORD = 0x000004000;
577 pub const SHGFI_LINKOVERLAY: DWORD = 0x000008000;
578 pub const SHGFI_SELECTED: DWORD = 0x000010000;
579 pub const SHGFI_ATTR_SPECIFIED: DWORD = 0x000020000;
580 pub const SHGFI_LARGEICON: DWORD = 0x000000000;
581 pub const SHGFI_SMALLICON: DWORD = 0x000000001;
582 pub const SHGFI_OPENICON: DWORD = 0x000000002;
583 pub const SHGFI_SHELLICONSIZE: DWORD = 0x000000004;
584 pub const SHGFI_PIDL: DWORD = 0x000000008;
585 pub const SHGFI_USEFILEATTRIBUTES: DWORD = 0x000000010;
586 pub const SHGFI_ADDOVERLAYS: DWORD = 0x000000020;
587 pub const SHGFI_OVERLAYINDEX: DWORD = 0x000000040;
588 extern "system" {
SHGetFileInfoA( pszPath: LPCSTR, dwFileAttributes: DWORD, psfi: *mut SHFILEINFOA, cbFileInfo: UINT, uFlags: UINT, ) -> DWORD_PTR589     pub fn SHGetFileInfoA(
590         pszPath: LPCSTR,
591         dwFileAttributes: DWORD,
592         psfi: *mut SHFILEINFOA,
593         cbFileInfo: UINT,
594         uFlags: UINT,
595     ) -> DWORD_PTR;
SHGetFileInfoW( pszPath: LPCWSTR, dwFileAttributes: DWORD, psfi: *mut SHFILEINFOW, cbFileInfo: UINT, uFlags: UINT, ) -> DWORD_PTR596     pub fn SHGetFileInfoW(
597         pszPath: LPCWSTR,
598         dwFileAttributes: DWORD,
599         psfi: *mut SHFILEINFOW,
600         cbFileInfo: UINT,
601         uFlags: UINT,
602     ) -> DWORD_PTR;
603 }
604 STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SHSTOCKICONINFO {
605     cbSize: DWORD,
606     hIcon: HICON,
607     iSysImageIndex: c_int,
608     iIcon: c_int,
609     szPath: [WCHAR; MAX_PATH],
610 }}
611 pub const SHGSI_ICONLOCATION: DWORD = 0;
612 pub const SHGSI_ICON: DWORD = SHGFI_ICON;
613 pub const SHGSI_SYSICONINDEX: DWORD = SHGFI_SYSICONINDEX;
614 pub const SHGSI_LINKOVERLAY: DWORD = SHGFI_LINKOVERLAY;
615 pub const SHGSI_SELECTED: DWORD = SHGFI_SELECTED;
616 pub const SHGSI_LARGEICON: DWORD = SHGFI_LARGEICON;
617 pub const SHGSI_SMALLICON: DWORD = SHGFI_SMALLICON;
618 pub const SHGSI_SHELLICONSIZE: DWORD = SHGFI_SHELLICONSIZE;
619 ENUM!{enum SHSTOCKICONID {
620     SIID_DOCNOASSOC = 0,
621     SIID_DOCASSOC = 1,
622     SIID_APPLICATION = 2,
623     SIID_FOLDER = 3,
624     SIID_FOLDEROPEN = 4,
625     SIID_DRIVE525 = 5,
626     SIID_DRIVE35 = 6,
627     SIID_DRIVEREMOVE = 7,
628     SIID_DRIVEFIXED = 8,
629     SIID_DRIVENET = 9,
630     SIID_DRIVENETDISABLED = 10,
631     SIID_DRIVECD = 11,
632     SIID_DRIVERAM = 12,
633     SIID_WORLD = 13,
634     SIID_SERVER = 15,
635     SIID_PRINTER = 16,
636     SIID_MYNETWORK = 17,
637     SIID_FIND = 22,
638     SIID_HELP = 23,
639     SIID_SHARE = 28,
640     SIID_LINK = 29,
641     SIID_SLOWFILE = 30,
642     SIID_RECYCLER = 31,
643     SIID_RECYCLERFULL = 32,
644     SIID_MEDIACDAUDIO = 40,
645     SIID_LOCK = 47,
646     SIID_AUTOLIST = 49,
647     SIID_PRINTERNET = 50,
648     SIID_SERVERSHARE = 51,
649     SIID_PRINTERFAX = 52,
650     SIID_PRINTERFAXNET = 53,
651     SIID_PRINTERFILE = 54,
652     SIID_STACK = 55,
653     SIID_MEDIASVCD = 56,
654     SIID_STUFFEDFOLDER = 57,
655     SIID_DRIVEUNKNOWN = 58,
656     SIID_DRIVEDVD = 59,
657     SIID_MEDIADVD = 60,
658     SIID_MEDIADVDRAM = 61,
659     SIID_MEDIADVDRW = 62,
660     SIID_MEDIADVDR = 63,
661     SIID_MEDIADVDROM = 64,
662     SIID_MEDIACDAUDIOPLUS = 65,
663     SIID_MEDIACDRW = 66,
664     SIID_MEDIACDR = 67,
665     SIID_MEDIACDBURN = 68,
666     SIID_MEDIABLANKCD = 69,
667     SIID_MEDIACDROM = 70,
668     SIID_AUDIOFILES = 71,
669     SIID_IMAGEFILES = 72,
670     SIID_VIDEOFILES = 73,
671     SIID_MIXEDFILES = 74,
672     SIID_FOLDERBACK = 75,
673     SIID_FOLDERFRONT = 76,
674     SIID_SHIELD = 77,
675     SIID_WARNING = 78,
676     SIID_INFO = 79,
677     SIID_ERROR = 80,
678     SIID_KEY = 81,
679     SIID_SOFTWARE = 82,
680     SIID_RENAME = 83,
681     SIID_DELETE = 84,
682     SIID_MEDIAAUDIODVD = 85,
683     SIID_MEDIAMOVIEDVD = 86,
684     SIID_MEDIAENHANCEDCD = 87,
685     SIID_MEDIAENHANCEDDVD = 88,
686     SIID_MEDIAHDDVD = 89,
687     SIID_MEDIABLURAY = 90,
688     SIID_MEDIAVCD = 91,
689     SIID_MEDIADVDPLUSR = 92,
690     SIID_MEDIADVDPLUSRW = 93,
691     SIID_DESKTOPPC = 94,
692     SIID_MOBILEPC = 95,
693     SIID_USERS = 96,
694     SIID_MEDIASMARTMEDIA = 97,
695     SIID_MEDIACOMPACTFLASH = 98,
696     SIID_DEVICECELLPHONE = 99,
697     SIID_DEVICECAMERA = 100,
698     SIID_DEVICEVIDEOCAMERA = 101,
699     SIID_DEVICEAUDIOPLAYER = 102,
700     SIID_NETWORKCONNECT = 103,
701     SIID_INTERNET = 104,
702     SIID_ZIPFILE = 105,
703     SIID_SETTINGS = 106,
704     SIID_DRIVEHDDVD = 132,
705     SIID_DRIVEBD = 133,
706     SIID_MEDIAHDDVDROM = 134,
707     SIID_MEDIAHDDVDR = 135,
708     SIID_MEDIAHDDVDRAM = 136,
709     SIID_MEDIABDROM = 137,
710     SIID_MEDIABDR = 138,
711     SIID_MEDIABDRE = 139,
712     SIID_CLUSTEREDDRIVE = 140,
713     SIID_MAX_ICONS = 181,
714 }}
715 pub const SIID_INVALID: SHSTOCKICONID = -1i32 as u32;
716 extern "system" {
SHGetStockIconInfo( siid: SHSTOCKICONID, uFlags: UINT, psii: *mut SHSTOCKICONINFO, ) -> HRESULT717     pub fn SHGetStockIconInfo(
718         siid: SHSTOCKICONID,
719         uFlags: UINT,
720         psii: *mut SHSTOCKICONINFO,
721     ) -> HRESULT;
SHGetDiskFreeSpaceExA( pszDirectoryName: LPCSTR, pulFreeBytesAvailableToCaller: *mut ULARGE_INTEGER, pulTotalNumberOfBytes: *mut ULARGE_INTEGER, pulTotalNumberOfFreeBytes: *mut ULARGE_INTEGER, ) -> BOOL722     pub fn SHGetDiskFreeSpaceExA(
723         pszDirectoryName: LPCSTR,
724         pulFreeBytesAvailableToCaller: *mut ULARGE_INTEGER,
725         pulTotalNumberOfBytes: *mut ULARGE_INTEGER,
726         pulTotalNumberOfFreeBytes: *mut ULARGE_INTEGER,
727     ) -> BOOL;
SHGetDiskFreeSpaceExW( pszDirectoryName: LPCWSTR, pulFreeBytesAvailableToCaller: *mut ULARGE_INTEGER, pulTotalNumberOfBytes: *mut ULARGE_INTEGER, pulTotalNumberOfFreeBytes: *mut ULARGE_INTEGER, ) -> BOOL728     pub fn SHGetDiskFreeSpaceExW(
729         pszDirectoryName: LPCWSTR,
730         pulFreeBytesAvailableToCaller: *mut ULARGE_INTEGER,
731         pulTotalNumberOfBytes: *mut ULARGE_INTEGER,
732         pulTotalNumberOfFreeBytes: *mut ULARGE_INTEGER,
733     ) -> BOOL;
SHGetNewLinkInfoA( pszLinkTo: LPCSTR, pszDir: LPCSTR, pszName: LPSTR, pfMustCopy: *mut BOOL, uFlags: UINT, ) -> BOOL734     pub fn SHGetNewLinkInfoA(
735         pszLinkTo: LPCSTR,
736         pszDir: LPCSTR,
737         pszName: LPSTR,
738         pfMustCopy: *mut BOOL,
739         uFlags: UINT,
740     ) -> BOOL;
SHGetNewLinkInfoW( pszLinkTo: LPCWSTR, pszDir: LPCWSTR, pszName: LPWSTR, pfMustCopy: *mut BOOL, uFlags: UINT, ) -> BOOL741     pub fn SHGetNewLinkInfoW(
742         pszLinkTo: LPCWSTR,
743         pszDir: LPCWSTR,
744         pszName: LPWSTR,
745         pfMustCopy: *mut BOOL,
746         uFlags: UINT,
747     ) -> BOOL;
748 }
749 pub const SHGNLI_PIDL: DWORD = 0x000000001;
750 pub const SHGNLI_PREFIXNAME: DWORD = 0x000000002;
751 pub const SHGNLI_NOUNIQUE: DWORD = 0x000000004;
752 pub const SHGNLI_NOLNK: DWORD = 0x000000008;
753 pub const SHGNLI_NOLOCNAME: DWORD = 0x000000010;
754 pub const SHGNLI_USEURLEXT: DWORD = 0x000000020;
755 pub const PRINTACTION_OPEN: DWORD = 0;
756 pub const PRINTACTION_PROPERTIES: DWORD = 1;
757 pub const PRINTACTION_NETINSTALL: DWORD = 2;
758 pub const PRINTACTION_NETINSTALLLINK: DWORD = 3;
759 pub const PRINTACTION_TESTPAGE: DWORD = 4;
760 pub const PRINTACTION_OPENNETPRN: DWORD = 5;
761 pub const PRINTACTION_DOCUMENTDEFAULTS: DWORD = 6;
762 pub const PRINTACTION_SERVERPROPERTIES: DWORD = 7;
763 extern "system" {
SHInvokePrinterCommandA( hwnd: HWND, uAction: UINT, lpBuf1: LPCSTR, lpBuf2: LPCSTR, fModal: BOOL, ) -> BOOL764     pub fn SHInvokePrinterCommandA(
765         hwnd: HWND,
766         uAction: UINT,
767         lpBuf1: LPCSTR,
768         lpBuf2: LPCSTR,
769         fModal: BOOL,
770     ) -> BOOL;
SHInvokePrinterCommandW( hwnd: HWND, uAction: UINT, lpBuf1: LPCWSTR, lpBuf2: LPCWSTR, fModal: BOOL, ) -> BOOL771     pub fn SHInvokePrinterCommandW(
772         hwnd: HWND,
773         uAction: UINT,
774         lpBuf1: LPCWSTR,
775         lpBuf2: LPCWSTR,
776         fModal: BOOL,
777     ) -> BOOL;
778 }
779 STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct OPEN_PRINTER_PROPS_INFOA {
780     dwSize: DWORD,
781     pszSheetName: LPSTR,
782     uSheetIndex: UINT,
783     dwFlags: DWORD,
784     bModal: BOOL,
785 }}
786 pub type POPEN_PRINTER_PROPS_INFOA = *mut OPEN_PRINTER_PROPS_INFOA;
787 STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct OPEN_PRINTER_PROPS_INFOW {
788     dwSize: DWORD,
789     pszSheetName: LPWSTR,
790     uSheetIndex: UINT,
791     dwFlags: DWORD,
792     bModal: BOOL,
793 }}
794 pub type POPEN_PRINTER_PROPS_INFOW = *mut OPEN_PRINTER_PROPS_INFOW;
795 pub const PRINT_PROP_FORCE_NAME: DWORD = 0x01;
796 extern "system" {
SHLoadNonloadedIconOverlayIdentifiers() -> HRESULT797     pub fn SHLoadNonloadedIconOverlayIdentifiers() -> HRESULT;
SHIsFileAvailableOffline( pwszPath: PCWSTR, pdwStatus: *mut DWORD, ) -> HRESULT798     pub fn SHIsFileAvailableOffline(
799         pwszPath: PCWSTR,
800         pdwStatus: *mut DWORD,
801     ) -> HRESULT;
802 }
803 pub const OFFLINE_STATUS_LOCAL: DWORD = 0x0001;
804 pub const OFFLINE_STATUS_REMOTE: DWORD = 0x0002;
805 pub const OFFLINE_STATUS_INCOMPLETE: DWORD = 0x0004;
806 extern "system" {
SHSetLocalizedName( pszPath: PCWSTR, pszResModule: PCWSTR, idsRes: c_int, ) -> HRESULT807     pub fn SHSetLocalizedName(
808         pszPath: PCWSTR,
809         pszResModule: PCWSTR,
810         idsRes: c_int,
811     ) -> HRESULT;
SHRemoveLocalizedName( pszPath: PCWSTR, ) -> HRESULT812     pub fn SHRemoveLocalizedName(
813         pszPath: PCWSTR,
814     ) -> HRESULT;
SHGetLocalizedName( pszPath: PCWSTR, pszResModule: PWSTR, cch: UINT, pidsRes: *mut c_int, ) -> HRESULT815     pub fn SHGetLocalizedName(
816         pszPath: PCWSTR,
817         pszResModule: PWSTR,
818         cch: UINT,
819         pidsRes: *mut c_int,
820     ) -> HRESULT;
821 }
822 extern "C" {
ShellMessageBoxA( hAppInst: HINSTANCE, hWnd: HWND, lpcText: LPCSTR, lpcTitle: LPCSTR, fuStyle: UINT, ... ) -> c_int823     pub fn ShellMessageBoxA(
824         hAppInst: HINSTANCE,
825         hWnd: HWND,
826         lpcText: LPCSTR,
827         lpcTitle: LPCSTR,
828         fuStyle: UINT,
829         ...
830     ) -> c_int;
ShellMessageBoxW( hAppInst: HINSTANCE, hWnd: HWND, lpcText: LPCWSTR, lpcTitle: LPCWSTR, fuStyle: UINT, ... ) -> c_int831     pub fn ShellMessageBoxW(
832         hAppInst: HINSTANCE,
833         hWnd: HWND,
834         lpcText: LPCWSTR,
835         lpcTitle: LPCWSTR,
836         fuStyle: UINT,
837         ...
838     ) -> c_int;
839 }
840 extern "system" {
IsLFNDriveA( pszPath: LPCSTR, ) -> BOOL841     pub fn IsLFNDriveA(
842         pszPath: LPCSTR,
843     ) -> BOOL;
IsLFNDriveW( pszPath: LPCWSTR, ) -> BOOL844     pub fn IsLFNDriveW(
845         pszPath: LPCWSTR,
846     ) -> BOOL;
SHEnumerateUnreadMailAccountsA( hKeyUser: HKEY, dwIndex: DWORD, pszMailAddress: LPSTR, cchMailAddress: c_int, ) -> HRESULT847     pub fn SHEnumerateUnreadMailAccountsA(
848         hKeyUser: HKEY,
849         dwIndex: DWORD,
850         pszMailAddress: LPSTR,
851         cchMailAddress: c_int,
852     ) -> HRESULT;
SHEnumerateUnreadMailAccountsW( hKeyUser: HKEY, dwIndex: DWORD, pszMailAddress: LPWSTR, cchMailAddress: c_int, ) -> HRESULT853     pub fn SHEnumerateUnreadMailAccountsW(
854         hKeyUser: HKEY,
855         dwIndex: DWORD,
856         pszMailAddress: LPWSTR,
857         cchMailAddress: c_int,
858     ) -> HRESULT;
SHGetUnreadMailCountA( hKeyUser: HKEY, pszMailAddress: LPCSTR, pdwCount: *mut DWORD, pFileTime: *mut FILETIME, pszShellExecuteCommand: LPSTR, cchShellExecuteCommand: c_int, ) -> HRESULT859     pub fn SHGetUnreadMailCountA(
860         hKeyUser: HKEY,
861         pszMailAddress: LPCSTR,
862         pdwCount: *mut DWORD,
863         pFileTime: *mut FILETIME,
864         pszShellExecuteCommand: LPSTR,
865         cchShellExecuteCommand: c_int,
866     ) -> HRESULT;
SHGetUnreadMailCountW( hKeyUser: HKEY, pszMailAddress: LPCWSTR, pdwCount: *mut DWORD, pFileTime: *mut FILETIME, pszShellExecuteCommand: LPWSTR, cchShellExecuteCommand: c_int, ) -> HRESULT867     pub fn SHGetUnreadMailCountW(
868         hKeyUser: HKEY,
869         pszMailAddress: LPCWSTR,
870         pdwCount: *mut DWORD,
871         pFileTime: *mut FILETIME,
872         pszShellExecuteCommand: LPWSTR,
873         cchShellExecuteCommand: c_int,
874     ) -> HRESULT;
SHSetUnreadMailCountA( pszMailAddress: LPCSTR, dwCount: DWORD, pszShellExecuteCommand: LPCSTR, ) -> HRESULT875     pub fn SHSetUnreadMailCountA(
876         pszMailAddress: LPCSTR,
877         dwCount: DWORD,
878         pszShellExecuteCommand: LPCSTR,
879     ) -> HRESULT;
SHSetUnreadMailCountW( pszMailAddress: LPCWSTR, dwCount: DWORD, pszShellExecuteCommand: LPCWSTR, ) -> HRESULT880     pub fn SHSetUnreadMailCountW(
881         pszMailAddress: LPCWSTR,
882         dwCount: DWORD,
883         pszShellExecuteCommand: LPCWSTR,
884     ) -> HRESULT;
SHTestTokenMembership( hToken: HANDLE, ulRID: ULONG, ) -> BOOL885     pub fn SHTestTokenMembership(
886         hToken: HANDLE,
887         ulRID: ULONG,
888     ) -> BOOL;
SHGetImageList( iImageList: c_int, riid: REFIID, ppvObj: *mut *mut c_void, ) -> HRESULT889     pub fn SHGetImageList(
890         iImageList: c_int,
891         riid: REFIID,
892         ppvObj: *mut *mut c_void,
893     ) -> HRESULT;
894 }
895 pub const SHIL_LARGE: DWORD = 0;
896 pub const SHIL_SMALL: DWORD = 1;
897 pub const SHIL_EXTRALARGE: DWORD = 2;
898 pub const SHIL_SYSSMALL: DWORD = 3;
899 pub const SHIL_JUMBO: DWORD = 4;
900 pub const SHIL_LAST: DWORD = SHIL_JUMBO;
901 FN!{stdcall PFNCANSHAREFOLDERW(
902     pszPath: PCWSTR,
903 ) -> HRESULT}
904 FN!{stdcall PFNSHOWSHAREFOLDERUIW(
905     hwndParent: HWND,
906     pszPath: PCWSTR,
907 ) -> HRESULT}
908 pub const WC_NETADDRESS: &'static str = "msctls_netaddress";
909 extern "system" {
InitNetworkAddressControl() -> BOOL910     pub fn InitNetworkAddressControl() -> BOOL;
911 }
912 // STRUCT!{struct NC_ADDRESS {
913 //     pAddrInfo: *mut NET_ADDRESS_INFO,
914 //     PortNumber: USHORT,
915 //     PrefixLength: BYTE,
916 // }}
917 // pub type PNC_ADDRESS = *mut NC_ADDRESS;
918 extern "system" {
SHGetDriveMedia( pszDrive: PCWSTR, pdwMediaContent: *mut DWORD, ) -> HRESULT919     pub fn SHGetDriveMedia(
920         pszDrive: PCWSTR,
921         pdwMediaContent: *mut DWORD,
922     ) -> HRESULT;
923 }
924