1 /* 2 * SHLWAPI.DLL functions 3 * 4 * Copyright (C) 2000 Juergen Schmied 5 * 6 * This library is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU Lesser General Public 8 * License as published by the Free Software Foundation; either 9 * version 2.1 of the License, or (at your option) any later version. 10 * 11 * This library is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 * Lesser General Public License for more details. 15 * 16 * You should have received a copy of the GNU Lesser General Public 17 * License along with this library; if not, write to the Free Software 18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA 19 */ 20 21 #ifndef __WINE_SHLWAPI_H 22 #define __WINE_SHLWAPI_H 23 24 #include <specstrings.h> 25 #include <objbase.h> 26 #include <shtypes.h> 27 28 #ifdef __cplusplus 29 extern "C" { 30 #endif /* defined(__cplusplus) */ 31 32 #include <pshpack8.h> 33 34 #ifndef NO_SHLWAPI_REG 35 36 /* Registry functions */ 37 38 DWORD WINAPI SHDeleteEmptyKeyA(_In_ HKEY, _In_opt_ LPCSTR); 39 DWORD WINAPI SHDeleteEmptyKeyW(_In_ HKEY, _In_opt_ LPCWSTR); 40 #define SHDeleteEmptyKey WINELIB_NAME_AW(SHDeleteEmptyKey) 41 42 DWORD WINAPI SHDeleteKeyA(_In_ HKEY, _In_opt_ LPCSTR); 43 DWORD WINAPI SHDeleteKeyW(_In_ HKEY, _In_opt_ LPCWSTR); 44 #define SHDeleteKey WINELIB_NAME_AW(SHDeleteKey) 45 46 DWORD WINAPI SHDeleteValueA(_In_ HKEY, _In_opt_ LPCSTR, _In_ LPCSTR); 47 DWORD WINAPI SHDeleteValueW(_In_ HKEY, _In_opt_ LPCWSTR, _In_ LPCWSTR); 48 #define SHDeleteValue WINELIB_NAME_AW(SHDeleteValue) 49 50 DWORD 51 WINAPI 52 SHGetValueA( 53 _In_ HKEY, 54 _In_opt_ LPCSTR, 55 _In_opt_ LPCSTR, 56 _Out_opt_ LPDWORD, 57 _Out_writes_bytes_opt_(*pcbData) LPVOID, 58 _Inout_opt_ LPDWORD pcbData); 59 60 DWORD 61 WINAPI 62 SHGetValueW( 63 _In_ HKEY, 64 _In_opt_ LPCWSTR, 65 _In_opt_ LPCWSTR, 66 _Out_opt_ LPDWORD, 67 _Out_writes_bytes_opt_(*pcbData) LPVOID, 68 _Inout_opt_ LPDWORD pcbData); 69 70 #define SHGetValue WINELIB_NAME_AW(SHGetValue) 71 72 DWORD 73 WINAPI 74 SHSetValueA( 75 _In_ HKEY, 76 _In_opt_ LPCSTR, 77 _In_opt_ LPCSTR, 78 _In_ DWORD, 79 _In_reads_bytes_opt_(cbData) LPCVOID, 80 _In_ DWORD cbData); 81 82 DWORD 83 WINAPI 84 SHSetValueW( 85 _In_ HKEY, 86 _In_opt_ LPCWSTR, 87 _In_opt_ LPCWSTR, 88 _In_ DWORD, 89 _In_reads_bytes_opt_(cbData) LPCVOID, 90 _In_ DWORD cbData); 91 92 #define SHSetValue WINELIB_NAME_AW(SHSetValue) 93 94 DWORD 95 WINAPI 96 SHQueryValueExA( 97 _In_ HKEY, 98 _In_opt_ LPCSTR, 99 _Reserved_ LPDWORD, 100 _Out_opt_ LPDWORD, 101 _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID, 102 _Inout_opt_ LPDWORD pcbData); 103 104 DWORD 105 WINAPI 106 SHQueryValueExW( 107 _In_ HKEY, 108 _In_opt_ LPCWSTR, 109 _Reserved_ LPDWORD, 110 _Out_opt_ LPDWORD, 111 _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID, 112 _Inout_opt_ LPDWORD pcbData); 113 114 #define SHQueryValueEx WINELIB_NAME_AW(SHQueryValueEx) 115 116 LONG 117 WINAPI 118 SHEnumKeyExA( 119 _In_ HKEY, 120 _In_ DWORD, 121 _Out_writes_(*pcchName) LPSTR, 122 _Inout_ LPDWORD pcchName); 123 124 LONG 125 WINAPI 126 SHEnumKeyExW( 127 _In_ HKEY, 128 _In_ DWORD, 129 _Out_writes_(*pcchName) LPWSTR, 130 _Inout_ LPDWORD pcchName); 131 132 #define SHEnumKeyEx WINELIB_NAME_AW(SHEnumKeyEx) 133 134 LONG 135 WINAPI 136 SHEnumValueA( 137 _In_ HKEY, 138 _In_ DWORD, 139 _Out_writes_opt_(*pcchValueName) LPSTR, 140 _Inout_opt_ LPDWORD pcchValueName, 141 _Out_opt_ LPDWORD, 142 _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID, 143 _Inout_opt_ LPDWORD pcbData); 144 145 LONG 146 WINAPI 147 SHEnumValueW( 148 _In_ HKEY, 149 _In_ DWORD, 150 _Out_writes_opt_(*pcchValueName) LPWSTR, 151 _Inout_opt_ LPDWORD pcchValueName, 152 _Out_opt_ LPDWORD, 153 _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID, 154 _Inout_opt_ LPDWORD pcbData); 155 156 #define SHEnumValue WINELIB_NAME_AW(SHEnumValue) 157 158 LONG 159 WINAPI 160 SHQueryInfoKeyA( 161 _In_ HKEY, 162 _Out_opt_ LPDWORD, 163 _Out_opt_ LPDWORD, 164 _Out_opt_ LPDWORD, 165 _Out_opt_ LPDWORD); 166 167 LONG 168 WINAPI 169 SHQueryInfoKeyW( 170 _In_ HKEY, 171 _Out_opt_ LPDWORD, 172 _Out_opt_ LPDWORD, 173 _Out_opt_ LPDWORD, 174 _Out_opt_ LPDWORD); 175 176 #define SHQueryInfoKey WINELIB_NAME_AW(SHQueryInfoKey) 177 178 DWORD 179 WINAPI 180 SHRegGetPathA( 181 _In_ HKEY, 182 _In_opt_ LPCSTR, 183 _In_opt_ LPCSTR, 184 _Out_writes_(MAX_PATH) LPSTR, 185 _In_ DWORD); 186 187 DWORD 188 WINAPI 189 SHRegGetPathW( 190 _In_ HKEY, 191 _In_opt_ LPCWSTR, 192 _In_opt_ LPCWSTR, 193 _Out_writes_(MAX_PATH) LPWSTR, 194 _In_ DWORD); 195 196 #define SHRegGetPath WINELIB_NAME_AW(SHRegGetPath) 197 198 DWORD 199 WINAPI 200 SHRegSetPathA( 201 _In_ HKEY, 202 _In_opt_ LPCSTR, 203 _In_opt_ LPCSTR, 204 _In_ LPCSTR, 205 _In_ DWORD); 206 207 DWORD 208 WINAPI 209 SHRegSetPathW( 210 _In_ HKEY, 211 _In_opt_ LPCWSTR, 212 _In_opt_ LPCWSTR, 213 _In_ LPCWSTR, 214 _In_ DWORD); 215 216 #define SHRegSetPath WINELIB_NAME_AW(SHRegSetPath) 217 218 DWORD 219 WINAPI 220 SHCopyKeyA( 221 _In_ HKEY, 222 _In_opt_ LPCSTR, 223 _In_ HKEY, 224 _Reserved_ DWORD); 225 226 DWORD 227 WINAPI 228 SHCopyKeyW( 229 _In_ HKEY, 230 _In_opt_ LPCWSTR, 231 _In_ HKEY, 232 _Reserved_ DWORD); 233 234 #define SHCopyKey WINELIB_NAME_AW(SHCopyKey) 235 236 HKEY WINAPI SHRegDuplicateHKey(_In_ HKEY); 237 238 /* SHRegGetValue flags */ 239 typedef INT SRRF; 240 241 #define SRRF_RT_REG_NONE 0x1 242 #define SRRF_RT_REG_SZ 0x2 243 #define SRRF_RT_REG_EXPAND_SZ 0x4 244 #define SRRF_RT_REG_BINARY 0x8 245 #define SRRF_RT_REG_DWORD 0x10 246 #define SRRF_RT_REG_MULTI_SZ 0x20 247 #define SRRF_RT_REG_QWORD 0x40 248 249 #define SRRF_RT_DWORD (SRRF_RT_REG_BINARY|SRRF_RT_REG_DWORD) 250 #define SRRF_RT_QWORD (SRRF_RT_REG_BINARY|SRRF_RT_REG_QWORD) 251 #define SRRF_RT_ANY 0xffff 252 253 #define SRRF_RM_ANY 0 254 #define SRRF_RM_NORMAL 0x10000 255 #define SRRF_RM_SAFE 0x20000 256 #define SRRF_RM_SAFENETWORK 0x40000 257 258 #define SRRF_NOEXPAND 0x10000000 259 #define SRRF_ZEROONFAILURE 0x20000000 260 #define SRRF_NOVIRT 0x40000000 261 262 LSTATUS 263 WINAPI 264 SHRegGetValueA( 265 _In_ HKEY hkey, 266 _In_opt_ LPCSTR pszSubKey, 267 _In_opt_ LPCSTR pszValue, 268 _In_ SRRF srrfFlags, 269 _Out_opt_ LPDWORD pdwType, 270 _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID pvData, 271 _Inout_opt_ LPDWORD pcbData); 272 273 LSTATUS 274 WINAPI 275 SHRegGetValueW( 276 _In_ HKEY hkey, 277 _In_opt_ LPCWSTR pszSubKey, 278 _In_opt_ LPCWSTR pszValue, 279 _In_ SRRF srrfFlags, 280 _Out_opt_ LPDWORD pdwType, 281 _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID pvData, 282 _Inout_opt_ LPDWORD pcbData); 283 284 #define SHRegGetValue WINELIB_NAME_AW(SHRegGetValue) 285 286 /* Undocumented registry functions */ 287 288 DWORD WINAPI SHDeleteOrphanKeyA(HKEY,LPCSTR); 289 DWORD WINAPI SHDeleteOrphanKeyW(HKEY,LPCWSTR); 290 #define SHDeleteOrphanKey WINELIB_NAME_AW(SHDeleteOrphanKey) 291 292 293 /* User registry functions */ 294 295 typedef enum 296 { 297 SHREGDEL_DEFAULT = 0, 298 SHREGDEL_HKCU = 0x1, 299 SHREGDEL_HKLM = 0x10, 300 SHREGDEL_BOTH = SHREGDEL_HKLM | SHREGDEL_HKCU 301 } SHREGDEL_FLAGS; 302 303 typedef enum 304 { 305 SHREGENUM_DEFAULT = 0, 306 SHREGENUM_HKCU = 0x1, 307 SHREGENUM_HKLM = 0x10, 308 SHREGENUM_BOTH = SHREGENUM_HKLM | SHREGENUM_HKCU 309 } SHREGENUM_FLAGS; 310 311 #define SHREGSET_HKCU 0x1 /* Apply to HKCU if empty */ 312 #define SHREGSET_FORCE_HKCU 0x2 /* Always apply to HKCU */ 313 #define SHREGSET_HKLM 0x4 /* Apply to HKLM if empty */ 314 #define SHREGSET_FORCE_HKLM 0x8 /* Always apply to HKLM */ 315 #define SHREGSET_DEFAULT (SHREGSET_FORCE_HKCU | SHREGSET_HKLM) 316 317 typedef HANDLE HUSKEY; 318 typedef HUSKEY *PHUSKEY; 319 320 LONG 321 WINAPI 322 SHRegCreateUSKeyA( 323 _In_ LPCSTR, 324 _In_ REGSAM, 325 _In_opt_ HUSKEY, 326 _Out_ PHUSKEY, 327 _In_ DWORD); 328 329 LONG 330 WINAPI 331 SHRegCreateUSKeyW( 332 _In_ LPCWSTR, 333 _In_ REGSAM, 334 _In_opt_ HUSKEY, 335 _Out_ PHUSKEY, 336 _In_ DWORD); 337 338 #define SHRegCreateUSKey WINELIB_NAME_AW(SHRegCreateUSKey) 339 340 LONG 341 WINAPI 342 SHRegOpenUSKeyA( 343 _In_ LPCSTR, 344 _In_ REGSAM, 345 _In_opt_ HUSKEY, 346 _Out_ PHUSKEY, 347 _In_ BOOL); 348 349 LONG 350 WINAPI 351 SHRegOpenUSKeyW( 352 _In_ LPCWSTR, 353 _In_ REGSAM, 354 _In_opt_ HUSKEY, 355 _Out_ PHUSKEY, 356 _In_ BOOL); 357 358 #define SHRegOpenUSKey WINELIB_NAME_AW(SHRegOpenUSKey) 359 360 LONG 361 WINAPI 362 SHRegQueryUSValueA( 363 _In_ HUSKEY, 364 _In_opt_ LPCSTR, 365 _Inout_opt_ LPDWORD, 366 _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID, 367 _Inout_opt_ LPDWORD pcbData, 368 _In_ BOOL, 369 _In_reads_bytes_opt_(dwDefaultDataSize) LPVOID, 370 _In_opt_ DWORD dwDefaultDataSize); 371 372 LONG 373 WINAPI 374 SHRegQueryUSValueW( 375 _In_ HUSKEY, 376 _In_opt_ LPCWSTR, 377 _Inout_opt_ LPDWORD, 378 _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID, 379 _Inout_opt_ LPDWORD pcbData, 380 _In_ BOOL, 381 _In_reads_bytes_opt_(dwDefaultDataSize) LPVOID, 382 _In_opt_ DWORD dwDefaultDataSize); 383 384 #define SHRegQueryUSValue WINELIB_NAME_AW(SHRegQueryUSValue) 385 386 LONG 387 WINAPI 388 SHRegWriteUSValueA( 389 _In_ HUSKEY, 390 _In_ LPCSTR, 391 _In_ DWORD, 392 _In_reads_bytes_(cbData) LPVOID, 393 _In_ DWORD cbData, 394 _In_ DWORD); 395 396 LONG 397 WINAPI 398 SHRegWriteUSValueW( 399 _In_ HUSKEY, 400 _In_ LPCWSTR, 401 _In_ DWORD, 402 _In_reads_bytes_(cbData) LPVOID, 403 _In_ DWORD cbData, 404 _In_ DWORD); 405 406 #define SHRegWriteUSValue WINELIB_NAME_AW(SHRegWriteUSValue) 407 408 LONG 409 WINAPI 410 SHRegDeleteUSValueA( 411 _In_ HUSKEY, 412 _In_ LPCSTR, 413 _In_ SHREGDEL_FLAGS); 414 415 LONG 416 WINAPI 417 SHRegDeleteUSValueW( 418 _In_ HUSKEY, 419 _In_ LPCWSTR, 420 _In_ SHREGDEL_FLAGS); 421 422 #define SHRegDeleteUSValue WINELIB_NAME_AW(SHRegDeleteUSValue) 423 424 LONG 425 WINAPI 426 SHRegDeleteEmptyUSKeyA( 427 _In_ HUSKEY, 428 _In_ LPCSTR, 429 _In_ SHREGDEL_FLAGS); 430 431 LONG 432 WINAPI 433 SHRegDeleteEmptyUSKeyW( 434 _In_ HUSKEY, 435 _In_ LPCWSTR, 436 _In_ SHREGDEL_FLAGS); 437 438 #define SHRegDeleteEmptyUSKey WINELIB_NAME_AW(SHRegDeleteEmptyUSKey) 439 440 LONG 441 WINAPI 442 SHRegEnumUSKeyA( 443 _In_ HUSKEY, 444 _In_ DWORD, 445 _Out_writes_to_(*pcchName, *pcchName) LPSTR, 446 _Inout_ LPDWORD pcchName, 447 _In_ SHREGENUM_FLAGS); 448 449 LONG 450 WINAPI 451 SHRegEnumUSKeyW( 452 _In_ HUSKEY, 453 _In_ DWORD, 454 _Out_writes_to_(*pcchName, *pcchName) LPWSTR, 455 _Inout_ LPDWORD pcchName, 456 _In_ SHREGENUM_FLAGS); 457 458 #define SHRegEnumUSKey WINELIB_NAME_AW(SHRegEnumUSKey) 459 460 LONG 461 WINAPI 462 SHRegEnumUSValueA( 463 _In_ HUSKEY, 464 _In_ DWORD, 465 _Out_writes_to_(*pcchValueName, *pcchValueName) LPSTR, 466 _Inout_ LPDWORD pcchValueName, 467 _Out_opt_ LPDWORD, 468 _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID, 469 _Inout_opt_ LPDWORD pcbData, 470 _In_ SHREGENUM_FLAGS); 471 472 LONG 473 WINAPI 474 SHRegEnumUSValueW( 475 _In_ HUSKEY, 476 _In_ DWORD, 477 _Out_writes_to_(*pcchValueName, *pcchValueName) LPWSTR, 478 _Inout_ LPDWORD pcchValueName, 479 _Out_opt_ LPDWORD, 480 _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID, 481 _Inout_opt_ LPDWORD pcbData, 482 _In_ SHREGENUM_FLAGS); 483 484 #define SHRegEnumUSValue WINELIB_NAME_AW(SHRegEnumUSValue) 485 486 LONG 487 WINAPI 488 SHRegQueryInfoUSKeyA( 489 _In_ HUSKEY, 490 _Out_opt_ LPDWORD, 491 _Out_opt_ LPDWORD, 492 _Out_opt_ LPDWORD, 493 _Out_opt_ LPDWORD, 494 _In_ SHREGENUM_FLAGS); 495 496 LONG 497 WINAPI 498 SHRegQueryInfoUSKeyW( 499 _In_ HUSKEY, 500 _Out_opt_ LPDWORD, 501 _Out_opt_ LPDWORD, 502 _Out_opt_ LPDWORD, 503 _Out_opt_ LPDWORD, 504 _In_ SHREGENUM_FLAGS); 505 506 #define SHRegQueryInfoUSKey WINELIB_NAME_AW(SHRegQueryInfoUSKey) 507 508 LONG WINAPI SHRegCloseUSKey(_In_ HUSKEY); 509 510 LONG 511 WINAPI 512 SHRegGetUSValueA( 513 _In_ LPCSTR, 514 _In_opt_ LPCSTR, 515 _Inout_opt_ LPDWORD, 516 _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID, 517 _Inout_opt_ LPDWORD pcbData, 518 _In_ BOOL, 519 _In_reads_bytes_opt_(dwDefaultDataSize) LPVOID, 520 _In_ DWORD dwDefaultDataSize); 521 522 LONG 523 WINAPI 524 SHRegGetUSValueW( 525 _In_ LPCWSTR, 526 _In_opt_ LPCWSTR, 527 _Inout_opt_ LPDWORD, 528 _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID, 529 _Inout_opt_ LPDWORD pcbData, 530 _In_ BOOL, 531 _In_reads_bytes_opt_(dwDefaultDataSize) LPVOID, 532 _In_ DWORD dwDefaultDataSize); 533 534 #define SHRegGetUSValue WINELIB_NAME_AW(SHRegGetUSValue) 535 536 LONG 537 WINAPI 538 SHRegSetUSValueA( 539 _In_ LPCSTR, 540 _In_ LPCSTR, 541 _In_ DWORD, 542 _In_reads_bytes_opt_(cbData) LPVOID, 543 _In_opt_ DWORD cbData, 544 _In_opt_ DWORD); 545 546 LONG 547 WINAPI 548 SHRegSetUSValueW( 549 _In_ LPCWSTR, 550 _In_ LPCWSTR, 551 _In_ DWORD, 552 _In_reads_bytes_opt_(cbData) LPVOID, 553 _In_opt_ DWORD cbData, 554 _In_opt_ DWORD); 555 556 #define SHRegSetUSValue WINELIB_NAME_AW(SHRegSetUSValue) 557 558 BOOL 559 WINAPI 560 SHRegGetBoolUSValueA( 561 _In_ LPCSTR, 562 _In_opt_ LPCSTR, 563 _In_ BOOL, 564 _In_ BOOL); 565 566 BOOL 567 WINAPI 568 SHRegGetBoolUSValueW( 569 _In_ LPCWSTR, 570 _In_opt_ LPCWSTR, 571 _In_ BOOL, 572 _In_ BOOL); 573 574 #define SHRegGetBoolUSValue WINELIB_NAME_AW(SHRegGetBoolUSValue) 575 576 int WINAPI SHRegGetIntW(_In_ HKEY, _In_opt_ LPCWSTR, _In_ int); 577 578 /* IQueryAssociation and helpers */ 579 enum 580 { 581 ASSOCF_NONE = 0x0000, 582 ASSOCF_INIT_NOREMAPCLSID = 0x0001, /* Don't map clsid->progid */ 583 ASSOCF_INIT_BYEXENAME = 0x0002, /* .exe name given */ 584 ASSOCF_OPEN_BYEXENAME = 0x0002, /* Synonym */ 585 ASSOCF_INIT_DEFAULTTOSTAR = 0x0004, /* Use * as base */ 586 ASSOCF_INIT_DEFAULTTOFOLDER = 0x0008, /* Use folder as base */ 587 ASSOCF_NOUSERSETTINGS = 0x0010, /* No HKCU reads */ 588 ASSOCF_NOTRUNCATE = 0x0020, /* Don't truncate return */ 589 ASSOCF_VERIFY = 0x0040, /* Verify data */ 590 ASSOCF_REMAPRUNDLL = 0x0080, /* Get rundll args */ 591 ASSOCF_NOFIXUPS = 0x0100, /* Don't fixup errors */ 592 ASSOCF_IGNOREBASECLASS = 0x0200, /* Don't read baseclass */ 593 ASSOCF_INIT_IGNOREUNKNOWN = 0x0400, /* Fail for unknown progid */ 594 ASSOCF_INIT_FIXED_PROGID = 0x0800, /* Used passed string as progid, don't try to map it */ 595 ASSOCF_IS_PROTOCOL = 0x1000, /* Treat as protocol, that should be mapped */ 596 ASSOCF_INIT_FOR_FILE = 0x2000, /* progid is for file extension association */ 597 }; 598 599 typedef DWORD ASSOCF; 600 601 typedef enum 602 { 603 ASSOCSTR_COMMAND = 1, /* Verb command */ 604 ASSOCSTR_EXECUTABLE, /* .exe from command string */ 605 ASSOCSTR_FRIENDLYDOCNAME, /* Friendly doc type name */ 606 ASSOCSTR_FRIENDLYAPPNAME, /* Friendly .exe name */ 607 ASSOCSTR_NOOPEN, /* noopen value */ 608 ASSOCSTR_SHELLNEWVALUE, /* Use shellnew key */ 609 ASSOCSTR_DDECOMMAND, /* DDE command template */ 610 ASSOCSTR_DDEIFEXEC, /* DDE command for process create */ 611 ASSOCSTR_DDEAPPLICATION, /* DDE app name */ 612 ASSOCSTR_DDETOPIC, /* DDE topic */ 613 ASSOCSTR_INFOTIP, /* Infotip */ 614 ASSOCSTR_QUICKTIP, /* Quick infotip */ 615 ASSOCSTR_TILEINFO, /* Properties for tileview */ 616 ASSOCSTR_CONTENTTYPE, /* Mimetype */ 617 ASSOCSTR_DEFAULTICON, /* Icon */ 618 ASSOCSTR_SHELLEXTENSION, /* GUID for shell extension handler */ 619 ASSOCSTR_MAX 620 } ASSOCSTR; 621 622 typedef enum 623 { 624 ASSOCKEY_SHELLEXECCLASS = 1, /* Key for ShellExec */ 625 ASSOCKEY_APP, /* Application */ 626 ASSOCKEY_CLASS, /* Progid or class */ 627 ASSOCKEY_BASECLASS, /* Base class */ 628 ASSOCKEY_MAX 629 } ASSOCKEY; 630 631 typedef enum 632 { 633 ASSOCDATA_MSIDESCRIPTOR = 1, /* Component descriptor */ 634 ASSOCDATA_NOACTIVATEHANDLER, /* Don't activate */ 635 ASSOCDATA_QUERYCLASSSTORE, /* Look in Class Store */ 636 ASSOCDATA_HASPERUSERASSOC, /* Use user association */ 637 ASSOCDATA_EDITFLAGS, /* Edit flags */ 638 ASSOCDATA_VALUE, /* pszExtra is value */ 639 ASSOCDATA_MAX 640 } ASSOCDATA; 641 642 typedef enum 643 { 644 ASSOCENUM_NONE 645 } ASSOCENUM; 646 647 typedef struct IQueryAssociations *LPQUERYASSOCIATIONS; 648 649 #define INTERFACE IQueryAssociations 650 DECLARE_INTERFACE_(IQueryAssociations,IUnknown) 651 { 652 /*** IUnknown methods ***/ 653 STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; 654 STDMETHOD_(ULONG,AddRef)(THIS) PURE; 655 STDMETHOD_(ULONG,Release)(THIS) PURE; 656 /*** IQueryAssociations methods ***/ 657 STDMETHOD(Init)(THIS_ _In_ ASSOCF flags, _In_opt_ LPCWSTR pszAssoc, _In_opt_ HKEY hkProgid, _In_opt_ HWND hwnd) PURE; 658 STDMETHOD(GetString)(THIS_ _In_ ASSOCF flags, _In_ ASSOCSTR str, _In_opt_ LPCWSTR pszExtra, _Out_writes_opt_(*pcchOut) LPWSTR pszOut, _Inout_ DWORD *pcchOut) PURE; 659 STDMETHOD(GetKey)(THIS_ _In_ ASSOCF flags, _In_ ASSOCKEY key, _In_opt_ LPCWSTR pszExtra, _Out_ HKEY *phkeyOut) PURE; 660 STDMETHOD(GetData)(THIS_ _In_ ASSOCF flags, _In_ ASSOCDATA data, _In_opt_ LPCWSTR pszExtra, _Out_writes_bytes_opt_(*pcbOut) LPVOID pvOut, _Inout_opt_ DWORD *pcbOut) PURE; 661 STDMETHOD(GetEnum)(THIS_ _In_ ASSOCF flags, _In_ ASSOCENUM assocenum, _In_opt_ LPCWSTR pszExtra, _In_ REFIID riid, _Outptr_ LPVOID *ppvOut) PURE; 662 }; 663 #undef INTERFACE 664 665 #if !defined(__cplusplus) || defined(CINTERFACE) 666 #define IQueryAssociations_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) 667 #define IQueryAssociations_AddRef(p) (p)->lpVtbl->AddRef(p) 668 #define IQueryAssociations_Release(p) (p)->lpVtbl->Release(p) 669 #define IQueryAssociations_Init(p,a,b,c,d) (p)->lpVtbl->Init(p,a,b,c,d) 670 #define IQueryAssociations_GetString(p,a,b,c,d,e) (p)->lpVtbl->GetString(p,a,b,c,d,e) 671 #define IQueryAssociations_GetKey(p,a,b,c,d) (p)->lpVtbl->GetKey(p,a,b,c,d) 672 #define IQueryAssociations_GetData(p,a,b,c,d,e) (p)->lpVtbl->GetData(p,a,b,c,d,e) 673 #define IQueryAssociations_GetEnum(p,a,b,c,d,e) (p)->lpVtbl->GetEnum(p,a,b,c,d,e) 674 #endif 675 676 HRESULT WINAPI AssocCreate(_In_ CLSID, _In_ REFIID, _Outptr_ LPVOID*); 677 678 HRESULT 679 WINAPI 680 AssocQueryStringA( 681 _In_ ASSOCF, 682 _In_ ASSOCSTR, 683 _In_ LPCSTR, 684 _In_opt_ LPCSTR, 685 _Out_writes_opt_(*pcchOut) LPSTR, 686 _Inout_ LPDWORD pcchOut); 687 688 HRESULT 689 WINAPI 690 AssocQueryStringW( 691 _In_ ASSOCF, 692 _In_ ASSOCSTR, 693 _In_ LPCWSTR, 694 _In_opt_ LPCWSTR, 695 _Out_writes_opt_(*pcchOut) LPWSTR, 696 _Inout_ LPDWORD pcchOut); 697 698 #define AssocQueryString WINELIB_NAME_AW(AssocQueryString) 699 700 HRESULT 701 WINAPI 702 AssocQueryStringByKeyA( 703 _In_ ASSOCF, 704 _In_ ASSOCSTR, 705 _In_ HKEY, 706 _In_opt_ LPCSTR, 707 _Out_writes_opt_(*pcchOut) LPSTR, 708 _Inout_ LPDWORD pcchOut); 709 710 HRESULT 711 WINAPI 712 AssocQueryStringByKeyW( 713 _In_ ASSOCF, 714 _In_ ASSOCSTR, 715 _In_ HKEY, 716 _In_opt_ LPCWSTR, 717 _Out_writes_opt_(*pcchOut) LPWSTR, 718 _Inout_ LPDWORD pcchOut); 719 720 #define AssocQueryStringByKey WINELIB_NAME_AW(AssocQueryStringByKey) 721 722 HRESULT 723 WINAPI 724 AssocQueryKeyA( 725 _In_ ASSOCF, 726 _In_ ASSOCKEY, 727 _In_ LPCSTR, 728 _In_opt_ LPCSTR, 729 _Out_ PHKEY); 730 731 HRESULT 732 WINAPI 733 AssocQueryKeyW( 734 _In_ ASSOCF, 735 _In_ ASSOCKEY, 736 _In_ LPCWSTR, 737 _In_opt_ LPCWSTR, 738 _Out_ PHKEY); 739 740 #define AssocQueryKey WINELIB_NAME_AW(AssocQueryKey) 741 742 BOOL WINAPI AssocIsDangerous(_In_ LPCWSTR); 743 744 #endif /* NO_SHLWAPI_REG */ 745 746 void WINAPI IUnknown_Set(_Inout_ IUnknown **ppunk, _In_opt_ IUnknown *punk); 747 void WINAPI IUnknown_AtomicRelease(_Inout_opt_ IUnknown **punk); 748 HRESULT WINAPI IUnknown_GetWindow(_In_ IUnknown *punk, _Out_ HWND *phwnd); 749 750 HRESULT 751 WINAPI 752 IUnknown_SetSite( 753 _In_ IUnknown *punk, 754 _In_opt_ IUnknown *punkSite); 755 756 HRESULT 757 WINAPI 758 IUnknown_GetSite( 759 _In_ IUnknown *punk, 760 _In_ REFIID riid, 761 _Outptr_ void **ppv); 762 763 HRESULT 764 WINAPI 765 IUnknown_QueryService( 766 _In_opt_ IUnknown *punk, 767 _In_ REFGUID guidService, 768 _In_ REFIID riid, 769 _Outptr_ void **ppvOut); 770 771 /* Path functions */ 772 #ifndef NO_SHLWAPI_PATH 773 774 /* GetPathCharType return flags */ 775 #define GCT_INVALID 0x0 776 #define GCT_LFNCHAR 0x1 777 #define GCT_SHORTCHAR 0x2 778 #define GCT_WILD 0x4 779 #define GCT_SEPARATOR 0x8 780 781 LPSTR WINAPI PathAddBackslashA(_Inout_updates_(MAX_PATH) LPSTR); 782 LPWSTR WINAPI PathAddBackslashW(_Inout_updates_(MAX_PATH) LPWSTR); 783 #define PathAddBackslash WINELIB_NAME_AW(PathAddBackslash) 784 785 BOOL 786 WINAPI 787 PathAddExtensionA( 788 _Inout_updates_(MAX_PATH) LPSTR, 789 _In_opt_ LPCSTR); 790 791 BOOL 792 WINAPI 793 PathAddExtensionW( 794 _Inout_updates_(MAX_PATH) LPWSTR, 795 _In_opt_ LPCWSTR); 796 797 #define PathAddExtension WINELIB_NAME_AW(PathAddExtension) 798 799 BOOL WINAPI PathAppendA(_Inout_updates_(MAX_PATH) LPSTR, _In_ LPCSTR); 800 BOOL WINAPI PathAppendW(_Inout_updates_(MAX_PATH) LPWSTR, _In_ LPCWSTR); 801 #define PathAppend WINELIB_NAME_AW(PathAppend) 802 803 LPSTR WINAPI PathBuildRootA(_Out_writes_(4) LPSTR, int); 804 LPWSTR WINAPI PathBuildRootW(_Out_writes_(4) LPWSTR, int); 805 #define PathBuildRoot WINELIB_NAME_AW(PathBuiltRoot) 806 807 BOOL WINAPI PathCanonicalizeA(_Out_writes_(MAX_PATH) LPSTR, _In_ LPCSTR); 808 BOOL WINAPI PathCanonicalizeW(_Out_writes_(MAX_PATH) LPWSTR, _In_ LPCWSTR); 809 #define PathCanonicalize WINELIB_NAME_AW(PathCanonicalize) 810 811 LPSTR 812 WINAPI 813 PathCombineA( 814 _Out_writes_(MAX_PATH) LPSTR, 815 _In_opt_ LPCSTR, 816 _In_opt_ LPCSTR); 817 818 LPWSTR 819 WINAPI 820 PathCombineW( 821 _Out_writes_(MAX_PATH) LPWSTR, 822 _In_opt_ LPCWSTR, 823 _In_opt_ LPCWSTR); 824 825 #define PathCombine WINELIB_NAME_AW(PathCombine) 826 827 BOOL 828 WINAPI 829 PathCompactPathA( 830 _In_opt_ HDC, 831 _Inout_updates_(MAX_PATH) LPSTR, 832 _In_ UINT); 833 834 BOOL 835 WINAPI 836 PathCompactPathW( 837 _In_opt_ HDC, 838 _Inout_updates_(MAX_PATH) LPWSTR, 839 _In_ UINT); 840 841 #define PathCompactPath WINELIB_NAME_AW(PathCompactPath) 842 843 BOOL 844 WINAPI 845 PathCompactPathExA( 846 _Out_writes_(cchMax) LPSTR, 847 _In_ LPCSTR, 848 _In_ UINT cchMax, 849 _In_ DWORD); 850 851 BOOL 852 WINAPI 853 PathCompactPathExW( 854 _Out_writes_(cchMax) LPWSTR, 855 _In_ LPCWSTR, 856 _In_ UINT cchMax, 857 _In_ DWORD); 858 859 #define PathCompactPathEx WINELIB_NAME_AW(PathCompactPathEx) 860 861 int 862 WINAPI 863 PathCommonPrefixA( 864 _In_ LPCSTR, 865 _In_ LPCSTR, 866 _Out_writes_opt_(MAX_PATH) LPSTR); 867 868 int 869 WINAPI 870 PathCommonPrefixW( 871 _In_ LPCWSTR, 872 _In_ LPCWSTR, 873 _Out_writes_opt_(MAX_PATH) LPWSTR); 874 875 #define PathCommonPrefix WINELIB_NAME_AW(PathCommonPrefix) 876 877 HRESULT 878 WINAPI 879 PathCreateFromUrlA( 880 _In_ LPCSTR, 881 _Out_writes_to_(*pcchPath, *pcchPath) LPSTR, 882 _Inout_ LPDWORD pcchPath, 883 DWORD); 884 885 HRESULT 886 WINAPI 887 PathCreateFromUrlW( 888 _In_ LPCWSTR pszUrl, 889 _Out_writes_to_(*pcchPath, *pcchPath) LPWSTR pszPath, 890 _Inout_ LPDWORD pcchPath, 891 DWORD dwFlags); 892 893 #define PathCreateFromUrl WINELIB_NAME_AW(PathCreateFromUrl) 894 895 HRESULT WINAPI PathCreateFromUrlAlloc(_In_ LPCWSTR pszUrl, _Outptr_ LPWSTR* pszPath, DWORD dwReserved); 896 897 BOOL WINAPI PathFileExistsA(_In_ LPCSTR pszPath); 898 BOOL WINAPI PathFileExistsW(_In_ LPCWSTR pszPath); 899 #define PathFileExists WINELIB_NAME_AW(PathFileExists) 900 901 BOOL WINAPI PathFileExistsAndAttributesA(LPCSTR lpszPath,DWORD* dwAttr); 902 BOOL WINAPI PathFileExistsAndAttributesW(LPCWSTR lpszPath,DWORD* dwAttr); 903 #define PathFileExistsAndAttributes WINELIB_NAME_AW(PathFileExistsAndAttributes) 904 905 LPSTR WINAPI PathFindExtensionA(_In_ LPCSTR pszPath); 906 LPWSTR WINAPI PathFindExtensionW(_In_ LPCWSTR pszPath); 907 #define PathFindExtension WINELIB_NAME_AW(PathFindExtension) 908 909 LPSTR WINAPI PathFindFileNameA(_In_ LPCSTR pszPath); 910 LPWSTR WINAPI PathFindFileNameW(_In_ LPCWSTR pszPath); 911 #define PathFindFileName WINELIB_NAME_AW(PathFindFileName) 912 913 LPSTR WINAPI PathFindNextComponentA(_In_ LPCSTR); 914 LPWSTR WINAPI PathFindNextComponentW(_In_ LPCWSTR); 915 #define PathFindNextComponent WINELIB_NAME_AW(PathFindNextComponent) 916 917 BOOL WINAPI PathFindOnPathA(_Inout_updates_(MAX_PATH) LPSTR, _In_opt_ LPCSTR*); 918 BOOL WINAPI PathFindOnPathW(_Inout_updates_(MAX_PATH) LPWSTR, _In_opt_ LPCWSTR*); 919 #define PathFindOnPath WINELIB_NAME_AW(PathFindOnPath) 920 921 LPSTR WINAPI PathGetArgsA(_In_ LPCSTR pszPath); 922 LPWSTR WINAPI PathGetArgsW(_In_ LPCWSTR pszPath); 923 #define PathGetArgs WINELIB_NAME_AW(PathGetArgs) 924 925 UINT WINAPI PathGetCharTypeA(_In_ UCHAR ch); 926 UINT WINAPI PathGetCharTypeW(_In_ WCHAR ch); 927 #define PathGetCharType WINELIB_NAME_AW(PathGetCharType) 928 929 int WINAPI PathGetDriveNumberA(_In_ LPCSTR); 930 int WINAPI PathGetDriveNumberW(_In_ LPCWSTR); 931 #define PathGetDriveNumber WINELIB_NAME_AW(PathGetDriveNumber) 932 933 BOOL WINAPI PathIsDirectoryA(_In_ LPCSTR); 934 BOOL WINAPI PathIsDirectoryW(_In_ LPCWSTR); 935 #define PathIsDirectory WINELIB_NAME_AW(PathIsDirectory) 936 937 BOOL WINAPI PathIsDirectoryEmptyA(_In_ LPCSTR); 938 BOOL WINAPI PathIsDirectoryEmptyW(_In_ LPCWSTR); 939 #define PathIsDirectoryEmpty WINELIB_NAME_AW(PathIsDirectoryEmpty) 940 941 BOOL WINAPI PathIsFileSpecA(_In_ LPCSTR); 942 BOOL WINAPI PathIsFileSpecW(_In_ LPCWSTR); 943 #define PathIsFileSpec WINELIB_NAME_AW(PathIsFileSpec); 944 945 BOOL WINAPI PathIsPrefixA(_In_ LPCSTR, _In_ LPCSTR); 946 BOOL WINAPI PathIsPrefixW(_In_ LPCWSTR, _In_ LPCWSTR); 947 #define PathIsPrefix WINELIB_NAME_AW(PathIsPrefix) 948 949 BOOL WINAPI PathIsRelativeA(_In_ LPCSTR); 950 BOOL WINAPI PathIsRelativeW(_In_ LPCWSTR); 951 #define PathIsRelative WINELIB_NAME_AW(PathIsRelative) 952 953 BOOL WINAPI PathIsRootA(_In_ LPCSTR); 954 BOOL WINAPI PathIsRootW(_In_ LPCWSTR); 955 #define PathIsRoot WINELIB_NAME_AW(PathIsRoot) 956 957 BOOL WINAPI PathIsSameRootA(_In_ LPCSTR, _In_ LPCSTR); 958 BOOL WINAPI PathIsSameRootW(_In_ LPCWSTR, _In_ LPCWSTR); 959 #define PathIsSameRoot WINELIB_NAME_AW(PathIsSameRoot) 960 961 BOOL WINAPI PathIsUNCA(_In_ LPCSTR); 962 BOOL WINAPI PathIsUNCW(_In_ LPCWSTR); 963 #define PathIsUNC WINELIB_NAME_AW(PathIsUNC) 964 965 BOOL WINAPI PathIsUNCServerA(_In_ LPCSTR); 966 BOOL WINAPI PathIsUNCServerW(_In_ LPCWSTR); 967 #define PathIsUNCServer WINELIB_NAME_AW(PathIsUNCServer) 968 969 BOOL WINAPI PathIsUNCServerShareA(_In_ LPCSTR); 970 BOOL WINAPI PathIsUNCServerShareW(_In_ LPCWSTR); 971 #define PathIsUNCServerShare WINELIB_NAME_AW(PathIsUNCServerShare) 972 973 BOOL WINAPI PathIsContentTypeA(_In_ LPCSTR, _In_ LPCSTR); 974 BOOL WINAPI PathIsContentTypeW(_In_ LPCWSTR, _In_ LPCWSTR); 975 #define PathIsContentType WINELIB_NAME_AW(PathIsContentType) 976 977 BOOL WINAPI PathIsURLA(_In_ LPCSTR); 978 BOOL WINAPI PathIsURLW(_In_ LPCWSTR); 979 #define PathIsURL WINELIB_NAME_AW(PathIsURL) 980 981 BOOL WINAPI PathMakePrettyA(_Inout_ LPSTR); 982 BOOL WINAPI PathMakePrettyW(_Inout_ LPWSTR); 983 #define PathMakePretty WINELIB_NAME_AW(PathMakePretty) 984 985 BOOL WINAPI PathMatchSpecA(_In_ LPCSTR, _In_ LPCSTR); 986 BOOL WINAPI PathMatchSpecW(_In_ LPCWSTR, _In_ LPCWSTR); 987 #define PathMatchSpec WINELIB_NAME_AW(PathMatchSpec) 988 989 int WINAPI PathParseIconLocationA(_Inout_ LPSTR); 990 int WINAPI PathParseIconLocationW(_Inout_ LPWSTR); 991 #define PathParseIconLocation WINELIB_NAME_AW(PathParseIconLocation) 992 993 VOID WINAPI PathQuoteSpacesA(_Inout_updates_(MAX_PATH) LPSTR); 994 VOID WINAPI PathQuoteSpacesW(_Inout_updates_(MAX_PATH) LPWSTR); 995 #define PathQuoteSpaces WINELIB_NAME_AW(PathQuoteSpaces) 996 997 BOOL 998 WINAPI 999 PathRelativePathToA( 1000 _Out_writes_(MAX_PATH) LPSTR, 1001 _In_ LPCSTR, 1002 _In_ DWORD, 1003 _In_ LPCSTR, 1004 _In_ DWORD); 1005 1006 BOOL 1007 WINAPI 1008 PathRelativePathToW( 1009 _Out_writes_(MAX_PATH) LPWSTR, 1010 _In_ LPCWSTR, 1011 _In_ DWORD, 1012 _In_ LPCWSTR, 1013 _In_ DWORD); 1014 1015 #define PathRelativePathTo WINELIB_NAME_AW(PathRelativePathTo) 1016 1017 VOID WINAPI PathRemoveArgsA(_Inout_ LPSTR); 1018 VOID WINAPI PathRemoveArgsW(_Inout_ LPWSTR); 1019 #define PathRemoveArgs WINELIB_NAME_AW(PathRemoveArgs) 1020 1021 LPSTR WINAPI PathRemoveBackslashA(_Inout_ LPSTR); 1022 LPWSTR WINAPI PathRemoveBackslashW(_Inout_ LPWSTR); 1023 #define PathRemoveBackslash WINELIB_NAME_AW(PathRemoveBackslash) 1024 1025 VOID WINAPI PathRemoveBlanksA(_Inout_ LPSTR); 1026 VOID WINAPI PathRemoveBlanksW(_Inout_ LPWSTR); 1027 #define PathRemoveBlanks WINELIB_NAME_AW(PathRemoveBlanks) 1028 1029 VOID WINAPI PathRemoveExtensionA(_Inout_ LPSTR); 1030 VOID WINAPI PathRemoveExtensionW(_Inout_ LPWSTR); 1031 #define PathRemoveExtension WINELIB_NAME_AW(PathRemoveExtension) 1032 1033 BOOL WINAPI PathRemoveFileSpecA(_Inout_ LPSTR); 1034 BOOL WINAPI PathRemoveFileSpecW(_Inout_ LPWSTR); 1035 #define PathRemoveFileSpec WINELIB_NAME_AW(PathRemoveFileSpec) 1036 1037 BOOL 1038 WINAPI 1039 PathRenameExtensionA( 1040 _Inout_updates_(MAX_PATH) LPSTR, 1041 _In_ LPCSTR); 1042 1043 BOOL 1044 WINAPI 1045 PathRenameExtensionW( 1046 _Inout_updates_(MAX_PATH) LPWSTR, 1047 _In_ LPCWSTR); 1048 1049 #define PathRenameExtension WINELIB_NAME_AW(PathRenameExtension) 1050 1051 BOOL 1052 WINAPI 1053 PathSearchAndQualifyA( 1054 _In_ LPCSTR, 1055 _Out_writes_(cchBuf) LPSTR, 1056 _In_ UINT cchBuf); 1057 1058 BOOL 1059 WINAPI 1060 PathSearchAndQualifyW( 1061 _In_ LPCWSTR, 1062 _Out_writes_(cchBuf) LPWSTR, 1063 _In_ UINT cchBuf); 1064 1065 #define PathSearchAndQualify WINELIB_NAME_AW(PathSearchAndQualify) 1066 1067 VOID WINAPI PathSetDlgItemPathA(_In_ HWND, int, LPCSTR); 1068 VOID WINAPI PathSetDlgItemPathW(_In_ HWND, int, LPCWSTR); 1069 #define PathSetDlgItemPath WINELIB_NAME_AW(PathSetDlgItemPath) 1070 1071 LPSTR WINAPI PathSkipRootA(_In_ LPCSTR); 1072 LPWSTR WINAPI PathSkipRootW(_In_ LPCWSTR); 1073 #define PathSkipRoot WINELIB_NAME_AW(PathSkipRoot) 1074 1075 VOID WINAPI PathStripPathA(_Inout_ LPSTR); 1076 VOID WINAPI PathStripPathW(_Inout_ LPWSTR); 1077 #define PathStripPath WINELIB_NAME_AW(PathStripPath) 1078 1079 BOOL WINAPI PathStripToRootA(_Inout_ LPSTR); 1080 BOOL WINAPI PathStripToRootW(_Inout_ LPWSTR); 1081 #define PathStripToRoot WINELIB_NAME_AW(PathStripToRoot) 1082 1083 VOID WINAPI PathUnquoteSpacesA(_Inout_ LPSTR); 1084 VOID WINAPI PathUnquoteSpacesW(_Inout_ LPWSTR); 1085 #define PathUnquoteSpaces WINELIB_NAME_AW(PathUnquoteSpaces) 1086 1087 BOOL WINAPI PathMakeSystemFolderA(_In_ LPCSTR); 1088 BOOL WINAPI PathMakeSystemFolderW(_In_ LPCWSTR); 1089 #define PathMakeSystemFolder WINELIB_NAME_AW(PathMakeSystemFolder) 1090 1091 BOOL WINAPI PathUnmakeSystemFolderA(_In_ LPCSTR); 1092 BOOL WINAPI PathUnmakeSystemFolderW(_In_ LPCWSTR); 1093 #define PathUnmakeSystemFolder WINELIB_NAME_AW(PathUnmakeSystemFolder) 1094 1095 BOOL WINAPI PathIsSystemFolderA(_In_opt_ LPCSTR, _In_ DWORD); 1096 BOOL WINAPI PathIsSystemFolderW(_In_opt_ LPCWSTR, _In_ DWORD); 1097 #define PathIsSystemFolder WINELIB_NAME_AW(PathIsSystemFolder) 1098 1099 BOOL WINAPI PathIsNetworkPathA(_In_ LPCSTR); 1100 BOOL WINAPI PathIsNetworkPathW(_In_ LPCWSTR); 1101 #define PathIsNetworkPath WINELIB_NAME_AW(PathIsNetworkPath) 1102 1103 BOOL WINAPI PathIsLFNFileSpecA(_In_ LPCSTR); 1104 BOOL WINAPI PathIsLFNFileSpecW(_In_ LPCWSTR); 1105 #define PathIsLFNFileSpec WINELIB_NAME_AW(PathIsLFNFileSpec) 1106 1107 LPCSTR 1108 WINAPI 1109 PathFindSuffixArrayA( 1110 _In_ LPCSTR, 1111 _In_reads_(iArraySize) LPCSTR *, 1112 int iArraySize); 1113 1114 LPCWSTR 1115 WINAPI 1116 PathFindSuffixArrayW( 1117 _In_ LPCWSTR, 1118 _In_reads_(iArraySize) LPCWSTR *, 1119 int iArraySize); 1120 1121 #define PathFindSuffixArray WINELIB_NAME_AW(PathFindSuffixArray) 1122 1123 VOID WINAPI PathUndecorateA(_Inout_ LPSTR); 1124 VOID WINAPI PathUndecorateW(_Inout_ LPWSTR); 1125 #define PathUndecorate WINELIB_NAME_AW(PathUndecorate) 1126 1127 BOOL 1128 WINAPI 1129 PathUnExpandEnvStringsA( 1130 _In_ LPCSTR, 1131 _Out_writes_(cchBuf) LPSTR, 1132 _In_ UINT cchBuf); 1133 1134 BOOL 1135 WINAPI 1136 PathUnExpandEnvStringsW( 1137 _In_ LPCWSTR, 1138 _Out_writes_(cchBuf) LPWSTR, 1139 _In_ UINT cchBuf); 1140 1141 #define PathUnExpandEnvStrings WINELIB_NAME_AW(PathUnExpandEnvStrings) 1142 1143 /* Url functions */ 1144 typedef enum { 1145 URL_SCHEME_INVALID = -1, 1146 URL_SCHEME_UNKNOWN = 0, 1147 URL_SCHEME_FTP, 1148 URL_SCHEME_HTTP, 1149 URL_SCHEME_GOPHER, 1150 URL_SCHEME_MAILTO, 1151 URL_SCHEME_NEWS, 1152 URL_SCHEME_NNTP, 1153 URL_SCHEME_TELNET, 1154 URL_SCHEME_WAIS, 1155 URL_SCHEME_FILE, 1156 URL_SCHEME_MK, 1157 URL_SCHEME_HTTPS, 1158 URL_SCHEME_SHELL, 1159 URL_SCHEME_SNEWS, 1160 URL_SCHEME_LOCAL, 1161 URL_SCHEME_JAVASCRIPT, 1162 URL_SCHEME_VBSCRIPT, 1163 URL_SCHEME_ABOUT, 1164 URL_SCHEME_RES, 1165 URL_SCHEME_MSSHELLROOTED, 1166 URL_SCHEME_MSSHELLIDLIST, 1167 URL_SCHEME_MSHELP, 1168 URL_SCHEME_MSSHELLDEVICE, 1169 URL_SCHEME_WILDCARD, 1170 URL_SCHEME_SEARCH_MS, 1171 URL_SCHEME_SEARCH, 1172 URL_SCHEME_KNOWNFOLDER, 1173 URL_SCHEME_MAXVALUE 1174 } URL_SCHEME; 1175 1176 /* These are used by UrlGetPart routine */ 1177 typedef enum { 1178 URL_PART_NONE = 0, 1179 URL_PART_SCHEME = 1, 1180 URL_PART_HOSTNAME, 1181 URL_PART_USERNAME, 1182 URL_PART_PASSWORD, 1183 URL_PART_PORT, 1184 URL_PART_QUERY 1185 } URL_PART; 1186 1187 #define URL_PARTFLAG_KEEPSCHEME 0x00000001 1188 1189 /* These are used by the UrlIs... routines */ 1190 typedef enum { 1191 URLIS_URL, 1192 URLIS_OPAQUE, 1193 URLIS_NOHISTORY, 1194 URLIS_FILEURL, 1195 URLIS_APPLIABLE, 1196 URLIS_DIRECTORY, 1197 URLIS_HASQUERY 1198 } URLIS; 1199 1200 /* This is used by the UrlApplyScheme... routines */ 1201 #define URL_APPLY_FORCEAPPLY 0x00000008 1202 #define URL_APPLY_GUESSFILE 0x00000004 1203 #define URL_APPLY_GUESSSCHEME 0x00000002 1204 #define URL_APPLY_DEFAULT 0x00000001 1205 1206 /* The following are used by UrlEscape..., UrlUnEscape..., 1207 * UrlCanonicalize..., and UrlCombine... routines 1208 */ 1209 #define URL_WININET_COMPATIBILITY 0x80000000 1210 #define URL_PLUGGABLE_PROTOCOL 0x40000000 1211 #define URL_ESCAPE_UNSAFE 0x20000000 1212 #define URL_UNESCAPE 0x10000000 1213 1214 #define URL_DONT_SIMPLIFY 0x08000000 1215 #define URL_NO_META URL_DONT_SIMPLIFY 1216 #define URL_ESCAPE_SPACES_ONLY 0x04000000 1217 #define URL_DONT_ESCAPE_EXTRA_INFO 0x02000000 1218 #define URL_DONT_UNESCAPE_EXTRA_INFO URL_DONT_ESCAPE_EXTRA_INFO 1219 #define URL_BROWSER_MODE URL_DONT_ESCAPE_EXTRA_INFO 1220 1221 #define URL_INTERNAL_PATH 0x00800000 /* Will escape #'s in paths */ 1222 #define URL_UNESCAPE_HIGH_ANSI_ONLY 0x00400000 1223 #define URL_CONVERT_IF_DOSPATH 0x00200000 1224 #define URL_UNESCAPE_INPLACE 0x00100000 1225 1226 #define URL_FILE_USE_PATHURL 0x00010000 1227 #define URL_ESCAPE_AS_UTF8 0x00040000 1228 1229 #define URL_ESCAPE_SEGMENT_ONLY 0x00002000 1230 #define URL_ESCAPE_PERCENT 0x00001000 1231 1232 HRESULT 1233 WINAPI 1234 UrlApplySchemeA( 1235 _In_ LPCSTR, 1236 _Out_writes_(*pcchOut) LPSTR, 1237 _Inout_ LPDWORD pcchOut, 1238 DWORD); 1239 1240 HRESULT 1241 WINAPI 1242 UrlApplySchemeW( 1243 _In_ LPCWSTR, 1244 _Out_writes_(*pcchOut) LPWSTR, 1245 _Inout_ LPDWORD pcchOut, 1246 DWORD); 1247 1248 #define UrlApplyScheme WINELIB_NAME_AW(UrlApplyScheme) 1249 1250 HRESULT 1251 WINAPI 1252 UrlCanonicalizeA( 1253 _In_ LPCSTR, 1254 _Out_writes_to_(*pcchCanonicalized, *pcchCanonicalized) LPSTR, 1255 _Inout_ LPDWORD pcchCanonicalized, 1256 DWORD); 1257 1258 HRESULT 1259 WINAPI 1260 UrlCanonicalizeW( 1261 _In_ LPCWSTR, 1262 _Out_writes_to_(*pcchCanonicalized, *pcchCanonicalized) LPWSTR, 1263 _Inout_ LPDWORD pcchCanonicalized, 1264 DWORD); 1265 1266 #define UrlCanonicalize WINELIB_NAME_AW(UrlCanonicalize) 1267 1268 HRESULT 1269 WINAPI 1270 UrlCombineA( 1271 _In_ LPCSTR, 1272 _In_ LPCSTR, 1273 _Out_writes_to_opt_(*pcchCombined, *pcchCombined) LPSTR, 1274 _Inout_ LPDWORD pcchCombined, 1275 DWORD); 1276 1277 HRESULT 1278 WINAPI 1279 UrlCombineW( 1280 _In_ LPCWSTR, 1281 _In_ LPCWSTR, 1282 _Out_writes_to_opt_(*pcchCombined, *pcchCombined) LPWSTR, 1283 _Inout_ LPDWORD pcchCombined, 1284 DWORD); 1285 1286 #define UrlCombine WINELIB_NAME_AW(UrlCombine) 1287 1288 INT WINAPI UrlCompareA(_In_ LPCSTR, _In_ LPCSTR, BOOL); 1289 INT WINAPI UrlCompareW(_In_ LPCWSTR, _In_ LPCWSTR, BOOL); 1290 #define UrlCompare WINELIB_NAME_AW(UrlCompare) 1291 1292 HRESULT 1293 WINAPI 1294 UrlEscapeA( 1295 _In_ LPCSTR, 1296 _Out_writes_to_(*pcchEscaped, *pcchEscaped) LPSTR, 1297 _Inout_ LPDWORD pcchEscaped, 1298 DWORD); 1299 1300 HRESULT 1301 WINAPI 1302 UrlEscapeW( 1303 _In_ LPCWSTR, 1304 _Out_writes_to_(*pcchEscaped, *pcchEscaped) LPWSTR, 1305 _Inout_ LPDWORD pcchEscaped, 1306 DWORD); 1307 1308 #define UrlEscape WINELIB_NAME_AW(UrlEscape) 1309 1310 #define UrlEscapeSpacesA(x,y,z) UrlCanonicalizeA(x, y, z, \ 1311 URL_DONT_ESCAPE_EXTRA_INFO|URL_ESCAPE_SPACES_ONLY) 1312 #define UrlEscapeSpacesW(x,y,z) UrlCanonicalizeW(x, y, z, \ 1313 URL_DONT_ESCAPE_EXTRA_INFO|URL_ESCAPE_SPACES_ONLY) 1314 #define UrlEscapeSpaces WINELIB_NAME_AW(UrlEscapeSpaces) 1315 1316 LPCSTR WINAPI UrlGetLocationA(_In_ LPCSTR); 1317 LPCWSTR WINAPI UrlGetLocationW(_In_ LPCWSTR); 1318 #define UrlGetLocation WINELIB_NAME_AW(UrlGetLocation) 1319 1320 HRESULT 1321 WINAPI 1322 UrlGetPartA( 1323 _In_ LPCSTR, 1324 _Out_writes_(*pcchOut) LPSTR, 1325 _Inout_ LPDWORD pcchOut, 1326 DWORD, 1327 DWORD); 1328 1329 HRESULT 1330 WINAPI 1331 UrlGetPartW( 1332 _In_ LPCWSTR, 1333 _Out_writes_(*pcchOut) LPWSTR, 1334 _Inout_ LPDWORD pcchOut, 1335 DWORD, 1336 DWORD); 1337 1338 #define UrlGetPart WINELIB_NAME_AW(UrlGetPart) 1339 1340 HRESULT 1341 WINAPI 1342 HashData( 1343 _In_reads_bytes_(cbData) const unsigned char *, 1344 DWORD cbData, 1345 _Out_writes_bytes_(cbHash) unsigned char *lpDest, 1346 DWORD cbHash); 1347 1348 HRESULT 1349 WINAPI 1350 UrlHashA( 1351 _In_ LPCSTR, 1352 _Out_writes_bytes_(cbHash) unsigned char *, 1353 DWORD cbHash); 1354 1355 HRESULT 1356 WINAPI 1357 UrlHashW( 1358 _In_ LPCWSTR, 1359 _Out_writes_bytes_(cbHash) unsigned char *, 1360 DWORD cbHash); 1361 1362 #define UrlHash WINELIB_NAME_AW(UrlHash) 1363 1364 BOOL WINAPI UrlIsA(_In_ LPCSTR, URLIS); 1365 BOOL WINAPI UrlIsW(_In_ LPCWSTR, URLIS); 1366 #define UrlIs WINELIB_NAME_AW(UrlIs) 1367 1368 BOOL WINAPI UrlIsNoHistoryA(_In_ LPCSTR); 1369 BOOL WINAPI UrlIsNoHistoryW(_In_ LPCWSTR); 1370 #define UrlIsNoHistory WINELIB_NAME_AW(UrlIsNoHistory) 1371 1372 BOOL WINAPI UrlIsOpaqueA(_In_ LPCSTR); 1373 BOOL WINAPI UrlIsOpaqueW(_In_ LPCWSTR); 1374 #define UrlIsOpaque WINELIB_NAME_AW(UrlIsOpaque) 1375 1376 #define UrlIsFileUrlA(x) UrlIsA(x, URLIS_FILEURL) 1377 #define UrlIsFileUrlW(x) UrlIsW(x, URLIS_FILEURL) 1378 #define UrlIsFileUrl WINELIB_NAME_AW(UrlIsFileUrl) 1379 1380 HRESULT 1381 WINAPI 1382 UrlUnescapeA( 1383 _Inout_ LPSTR, 1384 _Out_writes_to_opt_(*pcchUnescaped, *pcchUnescaped) LPSTR, 1385 _Inout_opt_ LPDWORD pcchUnescaped, 1386 DWORD); 1387 1388 HRESULT 1389 WINAPI 1390 UrlUnescapeW( 1391 _Inout_ LPWSTR, 1392 _Out_writes_to_opt_(*pcchUnescaped, *pcchUnescaped) LPWSTR, 1393 _Inout_opt_ LPDWORD pcchUnescaped, 1394 DWORD); 1395 1396 #define UrlUnescape WINELIB_NAME_AW(UrlUnescape) 1397 1398 #define UrlUnescapeInPlaceA(x,y) UrlUnescapeA(x, NULL, NULL, \ 1399 y | URL_UNESCAPE_INPLACE) 1400 #define UrlUnescapeInPlaceW(x,y) UrlUnescapeW(x, NULL, NULL, \ 1401 y | URL_UNESCAPE_INPLACE) 1402 #define UrlUnescapeInPlace WINELIB_NAME_AW(UrlUnescapeInPlace) 1403 1404 HRESULT 1405 WINAPI 1406 UrlCreateFromPathA( 1407 _In_ LPCSTR, 1408 _Out_writes_to_(*pcchUrl, *pcchUrl) LPSTR, 1409 _Inout_ LPDWORD pcchUrl, 1410 DWORD); 1411 1412 HRESULT 1413 WINAPI 1414 UrlCreateFromPathW( 1415 _In_ LPCWSTR, 1416 _Out_writes_to_(*pcchUrl, *pcchUrl) LPWSTR, 1417 _Inout_ LPDWORD pcchUrl, 1418 DWORD); 1419 1420 #define UrlCreateFromPath WINELIB_NAME_AW(UrlCreateFromPath) 1421 1422 typedef struct tagPARSEDURLA { 1423 DWORD cbSize; 1424 LPCSTR pszProtocol; 1425 UINT cchProtocol; 1426 LPCSTR pszSuffix; 1427 UINT cchSuffix; 1428 UINT nScheme; 1429 } PARSEDURLA, *PPARSEDURLA; 1430 1431 typedef struct tagPARSEDURLW { 1432 DWORD cbSize; 1433 LPCWSTR pszProtocol; 1434 UINT cchProtocol; 1435 LPCWSTR pszSuffix; 1436 UINT cchSuffix; 1437 UINT nScheme; 1438 } PARSEDURLW, *PPARSEDURLW; 1439 1440 HRESULT WINAPI ParseURLA(_In_ LPCSTR pszUrl, _Inout_ PARSEDURLA *ppu); 1441 HRESULT WINAPI ParseURLW(_In_ LPCWSTR pszUrl, _Inout_ PARSEDURLW *ppu); 1442 #define ParseURL WINELIB_NAME_AW(ParseUrl) 1443 1444 #endif /* NO_SHLWAPI_PATH */ 1445 1446 1447 /* String functions */ 1448 #ifndef NO_SHLWAPI_STRFCNS 1449 1450 /* StrToIntEx flags */ 1451 #define STIF_DEFAULT 0x0L 1452 #define STIF_SUPPORT_HEX 0x1L 1453 1454 BOOL WINAPI ChrCmpIA (WORD,WORD); 1455 BOOL WINAPI ChrCmpIW (WCHAR,WCHAR); 1456 #define ChrCmpI WINELIB_NAME_AW(ChrCmpI) 1457 1458 INT WINAPI StrCSpnA(_In_ LPCSTR, _In_ LPCSTR); 1459 INT WINAPI StrCSpnW(_In_ LPCWSTR, _In_ LPCWSTR); 1460 #define StrCSpn WINELIB_NAME_AW(StrCSpn) 1461 1462 INT WINAPI StrCSpnIA(_In_ LPCSTR, _In_ LPCSTR); 1463 INT WINAPI StrCSpnIW(_In_ LPCWSTR, _In_ LPCWSTR); 1464 #define StrCSpnI WINELIB_NAME_AW(StrCSpnI) 1465 1466 #define StrCatA lstrcatA 1467 LPWSTR WINAPI StrCatW(_Inout_ LPWSTR, _In_ LPCWSTR); 1468 #define StrCat WINELIB_NAME_AW(StrCat) 1469 1470 LPSTR 1471 WINAPI 1472 StrCatBuffA( 1473 _Inout_updates_(cchDestBuffSize) LPSTR, 1474 _In_ LPCSTR, 1475 INT cchDestBuffSize); 1476 1477 LPWSTR 1478 WINAPI 1479 StrCatBuffW( 1480 _Inout_updates_(cchDestBuffSize) LPWSTR, 1481 _In_ LPCWSTR, 1482 INT cchDestBuffSize); 1483 1484 #define StrCatBuff WINELIB_NAME_AW(StrCatBuff) 1485 1486 DWORD 1487 WINAPI 1488 StrCatChainW( 1489 _Out_writes_(cchDst) LPWSTR, 1490 DWORD cchDst, 1491 DWORD, 1492 _In_ LPCWSTR); 1493 1494 LPSTR WINAPI StrChrA(_In_ LPCSTR, WORD); 1495 LPWSTR WINAPI StrChrW(_In_ LPCWSTR, WCHAR); 1496 #define StrChr WINELIB_NAME_AW(StrChr) 1497 1498 LPSTR WINAPI StrChrIA(_In_ LPCSTR, WORD); 1499 LPWSTR WINAPI StrChrIW(_In_ LPCWSTR, WCHAR); 1500 #define StrChrI WINELIB_NAME_AW(StrChrI) 1501 1502 #define StrCmpA lstrcmpA 1503 int WINAPI StrCmpW(_In_ LPCWSTR, _In_ LPCWSTR); 1504 #define StrCmp WINELIB_NAME_AW(StrCmp) 1505 1506 #define StrCmpIA lstrcmpiA 1507 int WINAPI StrCmpIW(_In_ LPCWSTR, _In_ LPCWSTR); 1508 #define StrCmpI WINELIB_NAME_AW(StrCmpI) 1509 1510 #define StrCpyA lstrcpyA 1511 LPWSTR WINAPI StrCpyW(_Out_ LPWSTR, _In_ LPCWSTR); 1512 #define StrCpy WINELIB_NAME_AW(StrCpy) 1513 1514 #define StrCpyNA lstrcpynA 1515 LPWSTR WINAPI StrCpyNW(_Out_writes_(cchMax) LPWSTR, _In_ LPCWSTR, int cchMax); 1516 #define StrCpyN WINELIB_NAME_AW(StrCpyN) 1517 #define StrNCpy WINELIB_NAME_AW(StrCpyN) 1518 1519 INT WINAPI StrCmpLogicalW(_In_ LPCWSTR, _In_ LPCWSTR); 1520 1521 INT WINAPI StrCmpNA(_In_ LPCSTR, _In_ LPCSTR, INT); 1522 INT WINAPI StrCmpNW(_In_ LPCWSTR, _In_ LPCWSTR, INT); 1523 #define StrCmpN WINELIB_NAME_AW(StrCmpN) 1524 #define StrNCmp WINELIB_NAME_AW(StrCmpN) 1525 1526 INT WINAPI StrCmpNIA(_In_ LPCSTR, _In_ LPCSTR, INT); 1527 INT WINAPI StrCmpNIW(_In_ LPCWSTR, _In_ LPCWSTR, INT); 1528 #define StrCmpNI WINELIB_NAME_AW(StrCmpNI) 1529 #define StrNCmpI WINELIB_NAME_AW(StrCmpNI) 1530 1531 LPSTR WINAPI StrDupA(_In_ LPCSTR); 1532 LPWSTR WINAPI StrDupW(_In_ LPCWSTR); 1533 #define StrDup WINELIB_NAME_AW(StrDup) 1534 1535 HRESULT WINAPI SHStrDupA(_In_ LPCSTR, _Outptr_ WCHAR**); 1536 HRESULT WINAPI SHStrDupW(_In_ LPCWSTR, _Outptr_ WCHAR**); 1537 #define SHStrDup WINELIB_NAME_AW(SHStrDup) 1538 1539 LPSTR 1540 WINAPI 1541 StrFormatByteSizeA( 1542 DWORD, 1543 _Out_writes_(cchBuf) LPSTR, 1544 UINT cchBuf); 1545 1546 /* A/W Pairing is broken for this function */ 1547 1548 LPSTR 1549 WINAPI 1550 StrFormatByteSize64A( 1551 LONGLONG, 1552 _Out_writes_(cchBuf) LPSTR, 1553 UINT cchBuf); 1554 1555 LPWSTR 1556 WINAPI 1557 StrFormatByteSizeW( 1558 LONGLONG, 1559 _Out_writes_(cchBuf) LPWSTR, 1560 UINT cchBuf); 1561 1562 #ifndef WINE_NO_UNICODE_MACROS 1563 #ifdef UNICODE 1564 #define StrFormatByteSize StrFormatByteSizeW 1565 #else 1566 #define StrFormatByteSize StrFormatByteSize64A 1567 #endif 1568 #endif 1569 1570 LPSTR 1571 WINAPI 1572 StrFormatKBSizeA( 1573 LONGLONG, 1574 _Out_writes_(cchBuf) LPSTR, 1575 UINT cchBuf); 1576 1577 LPWSTR 1578 WINAPI 1579 StrFormatKBSizeW( 1580 LONGLONG, 1581 _Out_writes_(cchBuf) LPWSTR, 1582 UINT cchBuf); 1583 1584 #define StrFormatKBSize WINELIB_NAME_AW(StrFormatKBSize) 1585 1586 int 1587 WINAPI 1588 StrFromTimeIntervalA( 1589 _Out_writes_(cchMax) LPSTR, 1590 UINT cchMax, 1591 DWORD, 1592 int); 1593 1594 int 1595 WINAPI 1596 StrFromTimeIntervalW( 1597 _Out_writes_(cchMax) LPWSTR, 1598 UINT cchMax, 1599 DWORD, 1600 int); 1601 1602 #define StrFromTimeInterval WINELIB_NAME_AW(StrFromTimeInterval) 1603 1604 BOOL WINAPI StrIsIntlEqualA(BOOL, _In_ LPCSTR, _In_ LPCSTR, int); 1605 BOOL WINAPI StrIsIntlEqualW(BOOL, _In_ LPCWSTR, _In_ LPCWSTR, int); 1606 #define StrIsIntlEqual WINELIB_NAME_AW(StrIsIntlEqual) 1607 1608 #define StrIntlEqNA(a,b,c) StrIsIntlEqualA(TRUE,a,b,c) 1609 #define StrIntlEqNW(a,b,c) StrIsIntlEqualW(TRUE,a,b,c) 1610 1611 #define StrIntlEqNIA(a,b,c) StrIsIntlEqualA(FALSE,a,b,c) 1612 #define StrIntlEqNIW(a,b,c) StrIsIntlEqualW(FALSE,a,b,c) 1613 1614 LPSTR WINAPI StrNCatA(_Inout_updates_(cchMax) LPSTR, LPCSTR, int cchMax); 1615 LPWSTR WINAPI StrNCatW(_Inout_updates_(cchMax) LPWSTR, LPCWSTR, int cchMax); 1616 #define StrNCat WINELIB_NAME_AW(StrNCat) 1617 #define StrCatN WINELIB_NAME_AW(StrNCat) 1618 1619 LPSTR WINAPI StrPBrkA(_In_ LPCSTR, _In_ LPCSTR); 1620 LPWSTR WINAPI StrPBrkW(_In_ LPCWSTR, _In_ LPCWSTR); 1621 #define StrPBrk WINELIB_NAME_AW(StrPBrk) 1622 1623 LPSTR WINAPI StrRChrA(_In_ LPCSTR, _In_opt_ LPCSTR, WORD); 1624 LPWSTR WINAPI StrRChrW(_In_ LPCWSTR, _In_opt_ LPCWSTR, WCHAR); 1625 #define StrRChr WINELIB_NAME_AW(StrRChr) 1626 1627 LPSTR WINAPI StrRChrIA(_In_ LPCSTR, _In_opt_ LPCSTR, WORD); 1628 LPWSTR WINAPI StrRChrIW(_In_ LPCWSTR, _In_opt_ LPCWSTR, WCHAR); 1629 #define StrRChrI WINELIB_NAME_AW(StrRChrI) 1630 1631 LPSTR WINAPI StrRStrIA(_In_ LPCSTR, _In_opt_ LPCSTR, _In_ LPCSTR); 1632 LPWSTR WINAPI StrRStrIW(_In_ LPCWSTR, _In_opt_ LPCWSTR, _In_ LPCWSTR); 1633 #define StrRStrI WINELIB_NAME_AW(StrRStrI) 1634 1635 int WINAPI StrSpnA(_In_ LPCSTR psz, _In_ LPCSTR pszSet); 1636 int WINAPI StrSpnW(_In_ LPCWSTR psz, _In_ LPCWSTR pszSet); 1637 #define StrSpn WINELIB_NAME_AW(StrSpn) 1638 1639 LPSTR WINAPI StrStrA(_In_ LPCSTR pszFirst, _In_ LPCSTR pszSrch); 1640 LPWSTR WINAPI StrStrW(_In_ LPCWSTR pszFirst, _In_ LPCWSTR pszSrch); 1641 #define StrStr WINELIB_NAME_AW(StrStr) 1642 1643 LPSTR WINAPI StrStrIA(_In_ LPCSTR pszFirst, _In_ LPCSTR pszSrch); 1644 LPWSTR WINAPI StrStrIW(_In_ LPCWSTR pszFirst, _In_ LPCWSTR pszSrch); 1645 #define StrStrI WINELIB_NAME_AW(StrStrI) 1646 1647 LPWSTR WINAPI StrStrNW(_In_ LPCWSTR, _In_ LPCWSTR, UINT); 1648 LPWSTR WINAPI StrStrNIW(_In_ LPCWSTR, _In_ LPCWSTR, UINT); 1649 1650 int WINAPI StrToIntA(_In_ LPCSTR); 1651 int WINAPI StrToIntW(_In_ LPCWSTR); 1652 #define StrToInt WINELIB_NAME_AW(StrToInt) 1653 #define StrToLong WINELIB_NAME_AW(StrToInt) 1654 1655 BOOL WINAPI StrToIntExA(_In_ LPCSTR, DWORD, _Out_ int*); 1656 BOOL WINAPI StrToIntExW(_In_ LPCWSTR, DWORD, _Out_ int*); 1657 #define StrToIntEx WINELIB_NAME_AW(StrToIntEx) 1658 1659 BOOL WINAPI StrToInt64ExA(_In_ LPCSTR, DWORD, _Out_ LONGLONG*); 1660 BOOL WINAPI StrToInt64ExW(_In_ LPCWSTR, DWORD, _Out_ LONGLONG*); 1661 #define StrToIntEx64 WINELIB_NAME_AW(StrToIntEx64) 1662 1663 BOOL WINAPI StrTrimA(_Inout_ LPSTR, _In_ LPCSTR); 1664 BOOL WINAPI StrTrimW(_Inout_ LPWSTR, _In_ LPCWSTR); 1665 #define StrTrim WINELIB_NAME_AW(StrTrim) 1666 1667 INT 1668 WINAPI 1669 wvnsprintfA( 1670 _Out_writes_(cchDest) LPSTR, 1671 _In_ INT cchDest, 1672 _In_ _Printf_format_string_ LPCSTR, 1673 _In_ __ms_va_list); 1674 1675 INT 1676 WINAPI 1677 wvnsprintfW( 1678 _Out_writes_(cchDest) LPWSTR, 1679 _In_ INT cchDest, 1680 _In_ _Printf_format_string_ LPCWSTR, 1681 _In_ __ms_va_list); 1682 1683 #define wvnsprintf WINELIB_NAME_AW(wvnsprintf) 1684 1685 INT 1686 WINAPIV 1687 wnsprintfA( 1688 _Out_writes_(cchDest) LPSTR, 1689 _In_ INT cchDest, 1690 _In_ _Printf_format_string_ LPCSTR, 1691 ...); 1692 1693 INT 1694 WINAPIV 1695 wnsprintfW( 1696 _Out_writes_(cchDest) LPWSTR, 1697 _In_ INT cchDest, 1698 _In_ _Printf_format_string_ LPCWSTR, 1699 ...); 1700 1701 #define wnsprintf WINELIB_NAME_AW(wnsprintf) 1702 1703 HRESULT 1704 WINAPI 1705 SHLoadIndirectString( 1706 _In_ LPCWSTR, 1707 _Out_writes_(cchOutBuf) LPWSTR, 1708 _In_ UINT cchOutBuf, 1709 _Reserved_ PVOID*); 1710 1711 BOOL 1712 WINAPI 1713 IntlStrEqWorkerA( 1714 BOOL, 1715 _In_reads_(nChar) LPCSTR, 1716 _In_reads_(nChar) LPCSTR, 1717 int nChar); 1718 1719 BOOL 1720 WINAPI 1721 IntlStrEqWorkerW( 1722 BOOL, 1723 _In_reads_(nChar) LPCWSTR, 1724 _In_reads_(nChar) LPCWSTR, 1725 int nChar); 1726 1727 #define IntlStrEqWorker WINELIB_NAME_AW(IntlStrEqWorker) 1728 1729 #define IntlStrEqNA(s1,s2,n) IntlStrEqWorkerA(TRUE,s1,s2,n) 1730 #define IntlStrEqNW(s1,s2,n) IntlStrEqWorkerW(TRUE,s1,s2,n) 1731 #define IntlStrEqN WINELIB_NAME_AW(IntlStrEqN) 1732 1733 #define IntlStrEqNIA(s1,s2,n) IntlStrEqWorkerA(FALSE,s1,s2,n) 1734 #define IntlStrEqNIW(s1,s2,n) IntlStrEqWorkerW(FALSE,s1,s2,n) 1735 #define IntlStrEqNI WINELIB_NAME_AW(IntlStrEqNI) 1736 1737 HRESULT 1738 WINAPI 1739 StrRetToStrA( 1740 _Inout_ STRRET*, 1741 _In_opt_ PCUITEMID_CHILD, 1742 _Outptr_ LPSTR*); 1743 1744 HRESULT 1745 WINAPI 1746 StrRetToStrW( 1747 _Inout_ STRRET*, 1748 _In_opt_ PCUITEMID_CHILD, 1749 _Outptr_ LPWSTR*); 1750 1751 #define StrRetToStr WINELIB_NAME_AW(StrRetToStr) 1752 1753 HRESULT 1754 WINAPI 1755 StrRetToBufA( 1756 _Inout_ STRRET*, 1757 _In_opt_ PCUITEMID_CHILD, 1758 _Out_writes_(cchBuf) LPSTR, 1759 UINT cchBuf); 1760 1761 HRESULT 1762 WINAPI 1763 StrRetToBufW( 1764 _Inout_ STRRET*, 1765 _In_opt_ PCUITEMID_CHILD, 1766 _Out_writes_(cchBuf) LPWSTR, 1767 UINT cchBuf); 1768 1769 #define StrRetToBuf WINELIB_NAME_AW(StrRetToBuf) 1770 1771 HRESULT 1772 WINAPI 1773 StrRetToBSTR( 1774 _Inout_ STRRET*, 1775 _In_opt_ PCUITEMID_CHILD, 1776 _Outptr_ BSTR*); 1777 1778 BOOL WINAPI IsCharSpaceA(CHAR); 1779 BOOL WINAPI IsCharSpaceW(WCHAR); 1780 #define IsCharSpace WINELIB_NAME_AW(IsCharSpace) 1781 1782 #endif /* NO_SHLWAPI_STRFCNS */ 1783 1784 1785 /* GDI functions */ 1786 #ifndef NO_SHLWAPI_GDI 1787 1788 HPALETTE WINAPI SHCreateShellPalette(_In_opt_ HDC); 1789 1790 COLORREF WINAPI ColorHLSToRGB(WORD,WORD,WORD); 1791 1792 COLORREF WINAPI ColorAdjustLuma(COLORREF,int,BOOL); 1793 1794 VOID WINAPI ColorRGBToHLS(COLORREF, _Out_ LPWORD, _Out_ LPWORD, _Out_ LPWORD); 1795 1796 #endif /* NO_SHLWAPI_GDI */ 1797 1798 /* Security functions */ 1799 BOOL WINAPI IsInternetESCEnabled(void); 1800 1801 /* Stream functions */ 1802 #ifndef NO_SHLWAPI_STREAM 1803 1804 struct IStream * 1805 WINAPI 1806 SHOpenRegStreamA( 1807 _In_ HKEY, 1808 _In_opt_ LPCSTR, 1809 _In_opt_ LPCSTR, 1810 _In_ DWORD); 1811 1812 struct IStream * 1813 WINAPI 1814 SHOpenRegStreamW( 1815 _In_ HKEY, 1816 _In_opt_ LPCWSTR, 1817 _In_opt_ LPCWSTR, 1818 _In_ DWORD); 1819 1820 #define SHOpenRegStream WINELIB_NAME_AW(SHOpenRegStream2) /* Uses version 2 */ 1821 1822 struct IStream * 1823 WINAPI 1824 SHOpenRegStream2A( 1825 _In_ HKEY, 1826 _In_opt_ LPCSTR, 1827 _In_opt_ LPCSTR, 1828 _In_ DWORD); 1829 1830 struct IStream * 1831 WINAPI 1832 SHOpenRegStream2W( 1833 _In_ HKEY, 1834 _In_opt_ LPCWSTR, 1835 _In_opt_ LPCWSTR, 1836 _In_ DWORD); 1837 1838 #define SHOpenRegStream2 WINELIB_NAME_AW(SHOpenRegStream2) 1839 1840 HRESULT 1841 WINAPI 1842 SHCreateStreamOnFileA( 1843 _In_ LPCSTR, 1844 _In_ DWORD, 1845 _Outptr_ struct IStream**); 1846 1847 HRESULT 1848 WINAPI 1849 SHCreateStreamOnFileW( 1850 _In_ LPCWSTR, 1851 _In_ DWORD, 1852 _Outptr_ struct IStream**); 1853 1854 #define SHCreateStreamOnFile WINELIB_NAME_AW(SHCreateStreamOnFile) 1855 1856 struct IStream* 1857 WINAPI 1858 SHCreateMemStream( 1859 _In_reads_bytes_opt_(cbInit) const BYTE *pInit, 1860 _In_ UINT cbInit); 1861 1862 HRESULT 1863 WINAPI 1864 SHCreateStreamOnFileEx( 1865 _In_ LPCWSTR, 1866 _In_ DWORD, 1867 _In_ DWORD, 1868 _In_ BOOL, 1869 _In_opt_ struct IStream*, 1870 _Outptr_ struct IStream**); 1871 1872 HRESULT WINAPI SHCreateStreamWrapper(LPBYTE,DWORD,DWORD,struct IStream**); 1873 1874 #endif /* NO_SHLWAPI_STREAM */ 1875 1876 #ifndef NO_SHLWAPI_SHARED 1877 1878 // These functions are only included in this file starting with the Windows 7 platform SDK 1879 1880 HANDLE 1881 WINAPI 1882 SHAllocShared( 1883 _In_opt_ const void *pvData, 1884 _In_ DWORD dwSize, 1885 _In_ DWORD dwDestinationProcessId 1886 ); 1887 1888 PVOID 1889 WINAPI 1890 SHLockShared( 1891 _In_ HANDLE hData, 1892 _In_ DWORD dwProcessId 1893 ); 1894 1895 BOOL 1896 WINAPI 1897 SHUnlockShared( 1898 _In_ void *pvData 1899 ); 1900 1901 BOOL 1902 WINAPI 1903 SHFreeShared( 1904 _In_ HANDLE hData, 1905 _In_ DWORD dwProcessId 1906 ); 1907 1908 #endif /* NO_SHLWAPI_SHARED */ 1909 1910 /* SHAutoComplete flags */ 1911 #define SHACF_DEFAULT 0x00000000 1912 #define SHACF_FILESYSTEM 0x00000001 1913 #define SHACF_URLHISTORY 0x00000002 1914 #define SHACF_URLMRU 0x00000004 1915 #define SHACF_URLALL (SHACF_URLHISTORY|SHACF_URLMRU) 1916 #define SHACF_USETAB 0x00000008 1917 #define SHACF_FILESYS_ONLY 0x00000010 1918 #define SHACF_FILESYS_DIRS 0x00000020 1919 #define SHACF_AUTOSUGGEST_FORCE_ON 0x10000000 1920 #define SHACF_AUTOSUGGEST_FORCE_OFF 0x20000000 1921 #define SHACF_AUTOAPPEND_FORCE_ON 0x40000000 1922 #define SHACF_AUTOAPPEND_FORCE_OFF 0x80000000 1923 1924 HRESULT WINAPI SHAutoComplete(_In_ HWND, DWORD); 1925 1926 /* Threads */ 1927 HRESULT WINAPI SHCreateThreadRef(_Inout_ LONG*, _Outptr_ IUnknown**); 1928 HRESULT WINAPI SHGetThreadRef(_Outptr_ IUnknown**); 1929 HRESULT WINAPI SHSetThreadRef(_In_opt_ IUnknown*); 1930 HRESULT WINAPI SHReleaseThreadRef(void); 1931 1932 /* SHCreateThread flags */ 1933 #define CTF_INSIST 0x01 /* Always call */ 1934 #define CTF_THREAD_REF 0x02 /* Hold thread ref */ 1935 #define CTF_PROCESS_REF 0x04 /* Hold process ref */ 1936 #define CTF_COINIT 0x08 /* Startup COM first */ 1937 #define CTF_FREELIBANDEXIT 0x10 /* Hold DLL ref */ 1938 #define CTF_REF_COUNTED 0x20 /* Thread is ref counted */ 1939 #define CTF_WAIT_ALLOWCOM 0x40 /* Allow marshalling */ 1940 1941 BOOL 1942 WINAPI 1943 SHCreateThread( 1944 _In_ LPTHREAD_START_ROUTINE pfnThreadProc, 1945 _In_opt_ void* pData, 1946 _In_ DWORD flags, 1947 _In_opt_ LPTHREAD_START_ROUTINE pfnCallback); 1948 1949 BOOL WINAPI SHSkipJunction(_In_opt_ struct IBindCtx*, _In_ const CLSID*); 1950 1951 /* Version Information */ 1952 1953 typedef struct _DllVersionInfo { 1954 DWORD cbSize; 1955 DWORD dwMajorVersion; 1956 DWORD dwMinorVersion; 1957 DWORD dwBuildNumber; 1958 DWORD dwPlatformID; 1959 } DLLVERSIONINFO; 1960 1961 #define DLLVER_PLATFORM_WINDOWS 0x01 /* Win9x */ 1962 #define DLLVER_PLATFORM_NT 0x02 /* WinNT */ 1963 1964 typedef HRESULT (CALLBACK *DLLGETVERSIONPROC)(DLLVERSIONINFO *); 1965 1966 #ifdef __WINESRC__ 1967 /* shouldn't be here, but is nice for type checking */ 1968 HRESULT WINAPI DllGetVersion(DLLVERSIONINFO *) DECLSPEC_HIDDEN; 1969 #endif 1970 1971 typedef struct _DLLVERSIONINFO2 { 1972 DLLVERSIONINFO info1; 1973 DWORD dwFlags; /* Reserved */ 1974 ULONGLONG DECLSPEC_ALIGN(8) ullVersion; /* 16 bits each for Major, Minor, Build, QFE */ 1975 } DLLVERSIONINFO2; 1976 1977 #define DLLVER_MAJOR_MASK 0xFFFF000000000000 1978 #define DLLVER_MINOR_MASK 0x0000FFFF00000000 1979 #define DLLVER_BUILD_MASK 0x00000000FFFF0000 1980 #define DLLVER_QFE_MASK 0x000000000000FFFF 1981 1982 #define MAKEDLLVERULL(mjr, mnr, bld, qfe) (((ULONGLONG)(mjr)<< 48)| \ 1983 ((ULONGLONG)(mnr)<< 32) | ((ULONGLONG)(bld)<< 16) | (ULONGLONG)(qfe)) 1984 1985 HRESULT WINAPI DllInstall(BOOL, _In_opt_ LPCWSTR) DECLSPEC_HIDDEN; 1986 1987 1988 #if (_WIN32_IE >= 0x0600) 1989 #define SHGVSPB_PERUSER 0x00000001 1990 #define SHGVSPB_ALLUSERS 0x00000002 1991 #define SHGVSPB_PERFOLDER 0x00000004 1992 #define SHGVSPB_ALLFOLDERS 0x00000008 1993 #define SHGVSPB_INHERIT 0x00000010 1994 #define SHGVSPB_ROAM 0x00000020 1995 #define SHGVSPB_NOAUTODEFAULTS 0x80000000 1996 1997 #define SHGVSPB_FOLDER (SHGVSPB_PERUSER | SHGVSPB_PERFOLDER) 1998 #define SHGVSPB_FOLDERNODEFAULTS (SHGVSPB_PERUSER | SHGVSPB_PERFOLDER | SHGVSPB_NOAUTODEFAULTS) 1999 #define SHGVSPB_USERDEFAULTS (SHGVSPB_PERUSER | SHGVSPB_ALLFOLDERS) 2000 #define SHGVSPB_GLOBALDEAFAULTS (SHGVSPB_ALLUSERS | SHGVSPB_ALLFOLDERS) 2001 2002 HRESULT 2003 WINAPI 2004 SHGetViewStatePropertyBag( 2005 _In_opt_ PCIDLIST_ABSOLUTE pidl, 2006 _In_opt_ LPCWSTR bag_name, 2007 _In_ DWORD flags, 2008 _In_ REFIID riid, 2009 _Outptr_ void **ppv); 2010 2011 #endif /* (_WIN32_IE >= 0x0600) */ 2012 2013 2014 /* IsOS definitions */ 2015 2016 #define OS_WIN32SORGREATER 0x00 2017 #define OS_NT 0x01 2018 #define OS_WIN95ORGREATER 0x02 2019 #define OS_NT4ORGREATER 0x03 2020 #define OS_WIN2000ORGREATER_ALT 0x04 2021 #define OS_WIN98ORGREATER 0x05 2022 #define OS_WIN98_GOLD 0x06 2023 #define OS_WIN2000ORGREATER 0x07 2024 #define OS_WIN2000PRO 0x08 2025 #define OS_WIN2000SERVER 0x09 2026 #define OS_WIN2000ADVSERVER 0x0A 2027 #define OS_WIN2000DATACENTER 0x0B 2028 #define OS_WIN2000TERMINAL 0x0C 2029 #define OS_EMBEDDED 0x0D 2030 #define OS_TERMINALCLIENT 0x0E 2031 #define OS_TERMINALREMOTEADMIN 0x0F 2032 #define OS_WIN95_GOLD 0x10 2033 #define OS_MEORGREATER 0x11 2034 #define OS_XPORGREATER 0x12 2035 #define OS_HOME 0x13 2036 #define OS_PROFESSIONAL 0x14 2037 #define OS_DATACENTER 0x15 2038 #define OS_ADVSERVER 0x16 2039 #define OS_SERVER 0x17 2040 #define OS_TERMINALSERVER 0x18 2041 #define OS_PERSONALTERMINALSERVER 0x19 2042 #define OS_FASTUSERSWITCHING 0x1A 2043 #define OS_WELCOMELOGONUI 0x1B 2044 #define OS_DOMAINMEMBER 0x1C 2045 #define OS_ANYSERVER 0x1D 2046 #define OS_WOW6432 0x1E 2047 #define OS_WEBSERVER 0x1F 2048 #define OS_SMALLBUSINESSSERVER 0x20 2049 #define OS_TABLETPC 0x21 2050 #define OS_SERVERADMINUI 0x22 2051 #define OS_MEDIACENTER 0x23 2052 #define OS_APPLIANCE 0x24 2053 2054 BOOL WINAPI IsOS(DWORD); 2055 2056 /* SHSetTimerQueueTimer definitions */ 2057 #define TPS_EXECUTEIO 0x00000001 2058 #define TPS_LONGEXECTIME 0x00000008 2059 2060 /* SHFormatDateTimeA/SHFormatDateTimeW flags */ 2061 #define FDTF_SHORTTIME 0x00000001 2062 #define FDTF_SHORTDATE 0x00000002 2063 #define FDTF_DEFAULT (FDTF_SHORTDATE | FDTF_SHORTTIME) 2064 #define FDTF_LONGDATE 0x00000004 2065 #define FDTF_LONGTIME 0x00000008 2066 #define FDTF_RELATIVE 0x00000010 2067 #define FDTF_LTRDATE 0x00000100 2068 #define FDTF_RTLDATE 0x00000200 2069 #define FDTF_NOAUTOREADINGORDER 0x00000400 2070 2071 2072 typedef struct 2073 { 2074 const IID *piid; 2075 #if defined(__REACTOS__) || (WINVER >= _WIN32_WINNT_WIN10) 2076 DWORD dwOffset; 2077 #else 2078 int dwOffset; 2079 #endif 2080 } QITAB, *LPQITAB; 2081 2082 HRESULT 2083 WINAPI 2084 QISearch( 2085 _Inout_ void* base, 2086 _In_ const QITAB *pqit, 2087 _In_ REFIID riid, 2088 _Outptr_ void **ppv); 2089 2090 #define OFFSETOFCLASS(base, derived) \ 2091 ((DWORD)(DWORD_PTR)(static_cast<base*>((derived*)8))-8) 2092 2093 #include <poppack.h> 2094 2095 #ifdef __cplusplus 2096 } /* extern "C" */ 2097 #endif /* defined(__cplusplus) */ 2098 2099 #endif /* __WINE_SHLWAPI_H */ 2100