sdk/include/psdk/shlwapi.h

   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,
 266   _In_opt_ LPCSTR,
 267   _In_opt_ LPCSTR,
 268   _In_ SRRF,
 269   _Out_opt_ LPDWORD,
 270   _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID,
 271   _Inout_opt_ LPDWORD pcbData);
 272
 273 LSTATUS
 274 WINAPI
 275 SHRegGetValueW(
 276   _In_ HKEY,
 277   _In_opt_ LPCWSTR,
 278   _In_opt_ LPCWSTR,
 279   _In_ SRRF,
 280   _Out_opt_ LPDWORD,
 281   _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID,
 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,
 889   _Out_writes_to_(*pcchPath, *pcchPath) LPWSTR,
 890   _Inout_ LPDWORD pcchPath,
 891   DWORD);
 892
 893 #define PathCreateFromUrl WINELIB_NAME_AW(PathCreateFromUrl)
 894
 895 HRESULT WINAPI PathCreateFromUrlAlloc(_In_ LPCWSTR, _Outptr_ LPWSTR*, DWORD);
 896
 897 BOOL WINAPI PathFileExistsA(_In_ LPCSTR);
 898 BOOL WINAPI PathFileExistsW(_In_ LPCWSTR);
 899 #define PathFileExists WINELIB_NAME_AW(PathFileExists)
 900
 901 BOOL WINAPI PathFileExistsAndAttributesA(LPCSTR,DWORD*);
 902 BOOL WINAPI PathFileExistsAndAttributesW(LPCWSTR,DWORD*);
 903 #define PathFileExistsAndAttributes WINELIB_NAME_AW(PathFileExistsAndAttributes)
 904
 905 LPSTR  WINAPI PathFindExtensionA(_In_ LPCSTR);
 906 LPWSTR WINAPI PathFindExtensionW(_In_ LPCWSTR);
 907 #define PathFindExtension WINELIB_NAME_AW(PathFindExtension)
 908
 909 LPSTR  WINAPI PathFindFileNameA(_In_ LPCSTR);
 910 LPWSTR WINAPI PathFindFileNameW(_In_ LPCWSTR);
 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);
 922 LPWSTR WINAPI PathGetArgsW(_In_ LPCWSTR);
 923 #define PathGetArgs WINELIB_NAME_AW(PathGetArgs)
 924
 925 UINT WINAPI PathGetCharTypeA(_In_ UCHAR);
 926 UINT WINAPI PathGetCharTypeW(_In_ WCHAR);
 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, _In_ LPCSTR);
1636 int WINAPI StrSpnW(_In_ LPCWSTR, _In_ LPCWSTR);
1637 #define StrSpn WINELIB_NAME_AW(StrSpn)
1638
1639 LPSTR  WINAPI StrStrA(_In_ LPCSTR, _In_ LPCSTR);
1640 LPWSTR WINAPI StrStrW(_In_ LPCWSTR, _In_ LPCWSTR);
1641 #define StrStr WINELIB_NAME_AW(StrStr)
1642
1643 LPSTR  WINAPI StrStrIA(_In_ LPCSTR, _In_ LPCSTR);
1644 LPWSTR WINAPI StrStrIW(_In_ LPCWSTR, _In_ LPCWSTR);
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_ LPCITEMIDLIST,
1742   _Outptr_ LPSTR*);
1743
1744 HRESULT
1745 WINAPI
1746 StrRetToStrW(
1747   _Inout_ STRRET*,
1748   _In_opt_ LPCITEMIDLIST,
1749   _Outptr_ LPWSTR*);
1750
1751 #define StrRetToStr WINELIB_NAME_AW(StrRetToStr)
1752
1753 HRESULT
1754 WINAPI
1755 StrRetToBufA(
1756   _Inout_ STRRET*,
1757   _In_opt_ LPCITEMIDLIST,
1758   _Out_writes_(cchBuf) LPSTR,
1759   UINT cchBuf);
1760
1761 HRESULT
1762 WINAPI
1763 StrRetToBufW(
1764   _Inout_ STRRET*,
1765   _In_opt_ LPCITEMIDLIST,
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_ LPCITEMIDLIST,
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,
1945   _In_opt_ void*,
1946   _In_ DWORD,
1947   _In_opt_ LPTHREAD_START_ROUTINE);
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_ LPCITEMIDLIST pidl,
2006   _In_opt_ LPWSTR bag_name,
2007   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     int        dwOffset;
2076 } QITAB, *LPQITAB;
2077
2078 HRESULT
2079 WINAPI
2080 QISearch(
2081   _Inout_ void* base,
2082   _In_ const QITAB *pqit,
2083   _In_ REFIID riid,
2084   _Outptr_ void **ppv);
2085
2086 #define OFFSETOFCLASS(base, derived) \
2087     ((DWORD)(DWORD_PTR)(static_cast<base*>((derived*)8))-8)
2088
2089 #include <poppack.h>
2090
2091 #ifdef __cplusplus
2092 } /* extern "C" */
2093 #endif /* defined(__cplusplus) */
2094
2095 #endif /* __WINE_SHLWAPI_H */