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