reactos/sdk/include/psdk/shlwapi.h

/*
 * SHLWAPI.DLL functions
 *
 * Copyright (C) 2000 Juergen Schmied
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
 */

#ifndef __WINE_SHLWAPI_H
#define __WINE_SHLWAPI_H

#include <specstrings.h>
#include <objbase.h>
#include <shtypes.h>

#ifdef __cplusplus
extern "C" {
#endif /* defined(__cplusplus) */

#include <pshpack8.h>

#ifndef NO_SHLWAPI_REG

/* Registry functions */

DWORD WINAPI SHDeleteEmptyKeyA(_In_ HKEY, _In_opt_ LPCSTR);
DWORD WINAPI SHDeleteEmptyKeyW(_In_ HKEY, _In_opt_ LPCWSTR);
#define SHDeleteEmptyKey WINELIB_NAME_AW(SHDeleteEmptyKey)

DWORD WINAPI SHDeleteKeyA(_In_ HKEY, _In_opt_ LPCSTR);
DWORD WINAPI SHDeleteKeyW(_In_ HKEY, _In_opt_ LPCWSTR);
#define SHDeleteKey WINELIB_NAME_AW(SHDeleteKey)

DWORD WINAPI SHDeleteValueA(_In_ HKEY, _In_opt_ LPCSTR, _In_ LPCSTR);
DWORD WINAPI SHDeleteValueW(_In_ HKEY, _In_opt_ LPCWSTR, _In_ LPCWSTR);
#define SHDeleteValue WINELIB_NAME_AW(SHDeleteValue)

DWORD
WINAPI
SHGetValueA(
  _In_ HKEY,
  _In_opt_ LPCSTR,
  _In_opt_ LPCSTR,
  _Out_opt_ LPDWORD,
  _Out_writes_bytes_opt_(*pcbData) LPVOID,
  _Inout_opt_ LPDWORD pcbData);

DWORD
WINAPI
SHGetValueW(
  _In_ HKEY,
  _In_opt_ LPCWSTR,
  _In_opt_ LPCWSTR,
  _Out_opt_ LPDWORD,
  _Out_writes_bytes_opt_(*pcbData) LPVOID,
  _Inout_opt_ LPDWORD pcbData);

#define SHGetValue WINELIB_NAME_AW(SHGetValue)

DWORD
WINAPI
SHSetValueA(
  _In_ HKEY,
  _In_opt_ LPCSTR,
  _In_opt_ LPCSTR,
  _In_ DWORD,
  _In_reads_bytes_opt_(cbData) LPCVOID,
  _In_ DWORD cbData);

DWORD
WINAPI
SHSetValueW(
  _In_ HKEY,
  _In_opt_ LPCWSTR,
  _In_opt_ LPCWSTR,
  _In_ DWORD,
  _In_reads_bytes_opt_(cbData) LPCVOID,
  _In_ DWORD cbData);

#define SHSetValue WINELIB_NAME_AW(SHSetValue)

DWORD
WINAPI
SHQueryValueExA(
  _In_ HKEY,
  _In_opt_ LPCSTR,
  _Reserved_ LPDWORD,
  _Out_opt_ LPDWORD,
  _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID,
  _Inout_opt_ LPDWORD pcbData);

DWORD
WINAPI
SHQueryValueExW(
  _In_ HKEY,
  _In_opt_ LPCWSTR,
  _Reserved_ LPDWORD,
  _Out_opt_ LPDWORD,
  _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID,
  _Inout_opt_ LPDWORD pcbData);

#define SHQueryValueEx WINELIB_NAME_AW(SHQueryValueEx)

LONG
WINAPI
SHEnumKeyExA(
  _In_ HKEY,
  _In_ DWORD,
  _Out_writes_(*pcchName) LPSTR,
  _Inout_ LPDWORD pcchName);

LONG
WINAPI
SHEnumKeyExW(
  _In_ HKEY,
  _In_ DWORD,
  _Out_writes_(*pcchName) LPWSTR,
  _Inout_ LPDWORD pcchName);

#define SHEnumKeyEx WINELIB_NAME_AW(SHEnumKeyEx)

LONG
WINAPI
SHEnumValueA(
  _In_ HKEY,
  _In_ DWORD,
  _Out_writes_opt_(*pcchValueName) LPSTR,
  _Inout_opt_ LPDWORD pcchValueName,
  _Out_opt_ LPDWORD,
  _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID,
  _Inout_opt_ LPDWORD pcbData);

LONG
WINAPI
SHEnumValueW(
  _In_ HKEY,
  _In_ DWORD,
  _Out_writes_opt_(*pcchValueName) LPWSTR,
  _Inout_opt_ LPDWORD pcchValueName,
  _Out_opt_ LPDWORD,
  _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID,
  _Inout_opt_ LPDWORD pcbData);

#define SHEnumValue WINELIB_NAME_AW(SHEnumValue)

LONG
WINAPI
SHQueryInfoKeyA(
  _In_ HKEY,
  _Out_opt_ LPDWORD,
  _Out_opt_ LPDWORD,
  _Out_opt_ LPDWORD,
  _Out_opt_ LPDWORD);

LONG
WINAPI
SHQueryInfoKeyW(
  _In_ HKEY,
  _Out_opt_ LPDWORD,
  _Out_opt_ LPDWORD,
  _Out_opt_ LPDWORD,
  _Out_opt_ LPDWORD);

#define SHQueryInfoKey WINELIB_NAME_AW(SHQueryInfoKey)

DWORD
WINAPI
SHRegGetPathA(
  _In_ HKEY,
  _In_opt_ LPCSTR,
  _In_opt_ LPCSTR,
  _Out_writes_(MAX_PATH) LPSTR,
  _In_ DWORD);

DWORD
WINAPI
SHRegGetPathW(
  _In_ HKEY,
  _In_opt_ LPCWSTR,
  _In_opt_ LPCWSTR,
  _Out_writes_(MAX_PATH) LPWSTR,
  _In_ DWORD);

#define SHRegGetPath WINELIB_NAME_AW(SHRegGetPath)

DWORD
WINAPI
SHRegSetPathA(
  _In_ HKEY,
  _In_opt_ LPCSTR,
  _In_opt_ LPCSTR,
  _In_ LPCSTR,
  _In_ DWORD);

DWORD
WINAPI
SHRegSetPathW(
  _In_ HKEY,
  _In_opt_ LPCWSTR,
  _In_opt_ LPCWSTR,
  _In_ LPCWSTR,
  _In_ DWORD);

#define SHRegSetPath WINELIB_NAME_AW(SHRegSetPath)

DWORD
WINAPI
SHCopyKeyA(
  _In_ HKEY,
  _In_opt_ LPCSTR,
  _In_ HKEY,
  _Reserved_ DWORD);

DWORD
WINAPI
SHCopyKeyW(
  _In_ HKEY,
  _In_opt_ LPCWSTR,
  _In_ HKEY,
  _Reserved_ DWORD);

#define SHCopyKey WINELIB_NAME_AW(SHCopyKey)

HKEY WINAPI  SHRegDuplicateHKey(_In_ HKEY);

/* SHRegGetValue flags */
typedef INT SRRF;

#define SRRF_RT_REG_NONE 0x1
#define SRRF_RT_REG_SZ 0x2
#define SRRF_RT_REG_EXPAND_SZ 0x4
#define SRRF_RT_REG_BINARY 0x8
#define SRRF_RT_REG_DWORD 0x10
#define SRRF_RT_REG_MULTI_SZ 0x20
#define SRRF_RT_REG_QWORD 0x40

#define SRRF_RT_DWORD (SRRF_RT_REG_BINARY|SRRF_RT_REG_DWORD)
#define SRRF_RT_QWORD (SRRF_RT_REG_BINARY|SRRF_RT_REG_QWORD)
#define SRRF_RT_ANY 0xffff

#define SRRF_RM_ANY 0
#define SRRF_RM_NORMAL 0x10000
#define SRRF_RM_SAFE 0x20000
#define SRRF_RM_SAFENETWORK 0x40000

#define SRRF_NOEXPAND 0x10000000
#define SRRF_ZEROONFAILURE 0x20000000
#define SRRF_NOVIRT 0x40000000

LSTATUS
WINAPI
SHRegGetValueA(
  _In_ HKEY hkey,
  _In_opt_ LPCSTR pszSubKey,
  _In_opt_ LPCSTR pszValue,
  _In_ SRRF srrfFlags,
  _Out_opt_ LPDWORD pdwType,
  _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID pvData,
  _Inout_opt_ LPDWORD pcbData);

LSTATUS
WINAPI
SHRegGetValueW(
  _In_ HKEY hkey,
  _In_opt_ LPCWSTR pszSubKey,
  _In_opt_ LPCWSTR pszValue,
  _In_ SRRF srrfFlags,
  _Out_opt_ LPDWORD pdwType,
  _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID pvData,
  _Inout_opt_ LPDWORD pcbData);

#define SHRegGetValue WINELIB_NAME_AW(SHRegGetValue)

/* Undocumented registry functions */

DWORD WINAPI SHDeleteOrphanKeyA(HKEY,LPCSTR);
DWORD WINAPI SHDeleteOrphanKeyW(HKEY,LPCWSTR);
#define SHDeleteOrphanKey WINELIB_NAME_AW(SHDeleteOrphanKey)


/* User registry functions */

typedef enum
{
  SHREGDEL_DEFAULT = 0,
  SHREGDEL_HKCU    = 0x1,
  SHREGDEL_HKLM    = 0x10,
  SHREGDEL_BOTH    = SHREGDEL_HKLM | SHREGDEL_HKCU
} SHREGDEL_FLAGS;

typedef enum
{
  SHREGENUM_DEFAULT = 0,
  SHREGENUM_HKCU    = 0x1,
  SHREGENUM_HKLM    = 0x10,
  SHREGENUM_BOTH    = SHREGENUM_HKLM | SHREGENUM_HKCU
} SHREGENUM_FLAGS;

#define SHREGSET_HKCU       0x1 /* Apply to HKCU if empty */
#define SHREGSET_FORCE_HKCU 0x2 /* Always apply to HKCU */
#define SHREGSET_HKLM       0x4 /* Apply to HKLM if empty */
#define SHREGSET_FORCE_HKLM 0x8 /* Always apply to HKLM */
#define SHREGSET_DEFAULT    (SHREGSET_FORCE_HKCU | SHREGSET_HKLM)

typedef HANDLE HUSKEY;
typedef HUSKEY *PHUSKEY;

LONG
WINAPI
SHRegCreateUSKeyA(
  _In_ LPCSTR,
  _In_ REGSAM,
  _In_opt_ HUSKEY,
  _Out_ PHUSKEY,
  _In_ DWORD);

LONG
WINAPI
SHRegCreateUSKeyW(
  _In_ LPCWSTR,
  _In_ REGSAM,
  _In_opt_ HUSKEY,
  _Out_ PHUSKEY,
  _In_ DWORD);

#define SHRegCreateUSKey WINELIB_NAME_AW(SHRegCreateUSKey)

LONG
WINAPI
SHRegOpenUSKeyA(
  _In_ LPCSTR,
  _In_ REGSAM,
  _In_opt_ HUSKEY,
  _Out_ PHUSKEY,
  _In_ BOOL);

LONG
WINAPI
SHRegOpenUSKeyW(
  _In_ LPCWSTR,
  _In_ REGSAM,
  _In_opt_ HUSKEY,
  _Out_ PHUSKEY,
  _In_ BOOL);

#define SHRegOpenUSKey WINELIB_NAME_AW(SHRegOpenUSKey)

LONG
WINAPI
SHRegQueryUSValueA(
  _In_ HUSKEY,
  _In_opt_ LPCSTR,
  _Inout_opt_ LPDWORD,
  _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID,
  _Inout_opt_ LPDWORD pcbData,
  _In_ BOOL,
  _In_reads_bytes_opt_(dwDefaultDataSize) LPVOID,
  _In_opt_ DWORD dwDefaultDataSize);

LONG
WINAPI
SHRegQueryUSValueW(
  _In_ HUSKEY,
  _In_opt_ LPCWSTR,
  _Inout_opt_ LPDWORD,
  _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID,
  _Inout_opt_ LPDWORD pcbData,
  _In_ BOOL,
  _In_reads_bytes_opt_(dwDefaultDataSize) LPVOID,
  _In_opt_ DWORD dwDefaultDataSize);

#define SHRegQueryUSValue WINELIB_NAME_AW(SHRegQueryUSValue)

LONG
WINAPI
SHRegWriteUSValueA(
  _In_ HUSKEY,
  _In_ LPCSTR,
  _In_ DWORD,
  _In_reads_bytes_(cbData) LPVOID,
  _In_ DWORD cbData,
  _In_ DWORD);

LONG
WINAPI
SHRegWriteUSValueW(
  _In_ HUSKEY,
  _In_ LPCWSTR,
  _In_ DWORD,
  _In_reads_bytes_(cbData) LPVOID,
  _In_ DWORD cbData,
  _In_ DWORD);

#define SHRegWriteUSValue WINELIB_NAME_AW(SHRegWriteUSValue)

LONG
WINAPI
SHRegDeleteUSValueA(
  _In_ HUSKEY,
  _In_ LPCSTR,
  _In_ SHREGDEL_FLAGS);

LONG
WINAPI
SHRegDeleteUSValueW(
  _In_ HUSKEY,
  _In_ LPCWSTR,
  _In_ SHREGDEL_FLAGS);

#define SHRegDeleteUSValue WINELIB_NAME_AW(SHRegDeleteUSValue)

LONG
WINAPI
SHRegDeleteEmptyUSKeyA(
  _In_ HUSKEY,
  _In_ LPCSTR,
  _In_ SHREGDEL_FLAGS);

LONG
WINAPI
SHRegDeleteEmptyUSKeyW(
  _In_ HUSKEY,
  _In_ LPCWSTR,
  _In_ SHREGDEL_FLAGS);

#define SHRegDeleteEmptyUSKey WINELIB_NAME_AW(SHRegDeleteEmptyUSKey)

LONG
WINAPI
SHRegEnumUSKeyA(
  _In_ HUSKEY,
  _In_ DWORD,
  _Out_writes_to_(*pcchName, *pcchName) LPSTR,
  _Inout_ LPDWORD pcchName,
  _In_ SHREGENUM_FLAGS);

LONG
WINAPI
SHRegEnumUSKeyW(
  _In_ HUSKEY,
  _In_ DWORD,
  _Out_writes_to_(*pcchName, *pcchName) LPWSTR,
  _Inout_ LPDWORD pcchName,
  _In_ SHREGENUM_FLAGS);

#define SHRegEnumUSKey WINELIB_NAME_AW(SHRegEnumUSKey)

LONG
WINAPI
SHRegEnumUSValueA(
  _In_ HUSKEY,
  _In_ DWORD,
  _Out_writes_to_(*pcchValueName, *pcchValueName) LPSTR,
  _Inout_ LPDWORD pcchValueName,
  _Out_opt_ LPDWORD,
  _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID,
  _Inout_opt_ LPDWORD pcbData,
  _In_ SHREGENUM_FLAGS);

LONG
WINAPI
SHRegEnumUSValueW(
  _In_ HUSKEY,
  _In_ DWORD,
  _Out_writes_to_(*pcchValueName, *pcchValueName) LPWSTR,
  _Inout_ LPDWORD pcchValueName,
  _Out_opt_ LPDWORD,
  _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID,
  _Inout_opt_ LPDWORD pcbData,
  _In_ SHREGENUM_FLAGS);

#define SHRegEnumUSValue WINELIB_NAME_AW(SHRegEnumUSValue)

LONG
WINAPI
SHRegQueryInfoUSKeyA(
  _In_ HUSKEY,
  _Out_opt_ LPDWORD,
  _Out_opt_ LPDWORD,
  _Out_opt_ LPDWORD,
  _Out_opt_ LPDWORD,
  _In_ SHREGENUM_FLAGS);

LONG
WINAPI
SHRegQueryInfoUSKeyW(
  _In_ HUSKEY,
  _Out_opt_ LPDWORD,
  _Out_opt_ LPDWORD,
  _Out_opt_ LPDWORD,
  _Out_opt_ LPDWORD,
  _In_ SHREGENUM_FLAGS);

#define SHRegQueryInfoUSKey WINELIB_NAME_AW(SHRegQueryInfoUSKey)

LONG WINAPI SHRegCloseUSKey(_In_ HUSKEY);

LONG
WINAPI
SHRegGetUSValueA(
  _In_ LPCSTR,
  _In_opt_ LPCSTR,
  _Inout_opt_ LPDWORD,
  _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID,
  _Inout_opt_ LPDWORD pcbData,
  _In_ BOOL,
  _In_reads_bytes_opt_(dwDefaultDataSize) LPVOID,
  _In_ DWORD dwDefaultDataSize);

LONG
WINAPI
SHRegGetUSValueW(
  _In_ LPCWSTR,
  _In_opt_ LPCWSTR,
  _Inout_opt_ LPDWORD,
  _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID,
  _Inout_opt_ LPDWORD pcbData,
  _In_ BOOL,
  _In_reads_bytes_opt_(dwDefaultDataSize) LPVOID,
  _In_ DWORD dwDefaultDataSize);

#define SHRegGetUSValue WINELIB_NAME_AW(SHRegGetUSValue)

LONG
WINAPI
SHRegSetUSValueA(
  _In_ LPCSTR,
  _In_ LPCSTR,
  _In_ DWORD,
  _In_reads_bytes_opt_(cbData) LPVOID,
  _In_opt_ DWORD cbData,
  _In_opt_ DWORD);

LONG
WINAPI
SHRegSetUSValueW(
  _In_ LPCWSTR,
  _In_ LPCWSTR,
  _In_ DWORD,
  _In_reads_bytes_opt_(cbData) LPVOID,
  _In_opt_ DWORD cbData,
  _In_opt_ DWORD);

#define SHRegSetUSValue WINELIB_NAME_AW(SHRegSetUSValue)

BOOL
WINAPI
SHRegGetBoolUSValueA(
  _In_ LPCSTR,
  _In_opt_ LPCSTR,
  _In_ BOOL,
  _In_ BOOL);

BOOL
WINAPI
SHRegGetBoolUSValueW(
  _In_ LPCWSTR,
  _In_opt_ LPCWSTR,
  _In_ BOOL,
  _In_ BOOL);

#define SHRegGetBoolUSValue WINELIB_NAME_AW(SHRegGetBoolUSValue)

int WINAPI SHRegGetIntW(_In_ HKEY, _In_opt_ LPCWSTR, _In_ int);

/* IQueryAssociation and helpers */
enum
{
    ASSOCF_NONE                 = 0x0000,
    ASSOCF_INIT_NOREMAPCLSID    = 0x0001, /* Don't map clsid->progid */
    ASSOCF_INIT_BYEXENAME       = 0x0002, /* .exe name given */
    ASSOCF_OPEN_BYEXENAME       = 0x0002, /* Synonym */
    ASSOCF_INIT_DEFAULTTOSTAR   = 0x0004, /* Use * as base */
    ASSOCF_INIT_DEFAULTTOFOLDER = 0x0008, /* Use folder as base */
    ASSOCF_NOUSERSETTINGS       = 0x0010, /* No HKCU reads */
    ASSOCF_NOTRUNCATE           = 0x0020, /* Don't truncate return */
    ASSOCF_VERIFY               = 0x0040, /* Verify data */
    ASSOCF_REMAPRUNDLL          = 0x0080, /* Get rundll args */
    ASSOCF_NOFIXUPS             = 0x0100, /* Don't fixup errors */
    ASSOCF_IGNOREBASECLASS      = 0x0200, /* Don't read baseclass */
    ASSOCF_INIT_IGNOREUNKNOWN   = 0x0400, /* Fail for unknown progid */
    ASSOCF_INIT_FIXED_PROGID    = 0x0800, /* Used passed string as progid, don't try to map it */
    ASSOCF_IS_PROTOCOL          = 0x1000, /* Treat as protocol, that should be mapped */
    ASSOCF_INIT_FOR_FILE        = 0x2000, /* progid is for file extension association */
};

typedef DWORD ASSOCF;

typedef enum
{
    ASSOCSTR_COMMAND = 1,     /* Verb command */
    ASSOCSTR_EXECUTABLE,      /* .exe from command string */
    ASSOCSTR_FRIENDLYDOCNAME, /* Friendly doc type name */
    ASSOCSTR_FRIENDLYAPPNAME, /* Friendly .exe name */
    ASSOCSTR_NOOPEN,          /* noopen value */
    ASSOCSTR_SHELLNEWVALUE,   /* Use shellnew key */
    ASSOCSTR_DDECOMMAND,      /* DDE command template */
    ASSOCSTR_DDEIFEXEC,       /* DDE command for process create */
    ASSOCSTR_DDEAPPLICATION,  /* DDE app name */
    ASSOCSTR_DDETOPIC,        /* DDE topic */
    ASSOCSTR_INFOTIP,         /* Infotip */
    ASSOCSTR_QUICKTIP,        /* Quick infotip */
    ASSOCSTR_TILEINFO,        /* Properties for tileview */
    ASSOCSTR_CONTENTTYPE,     /* Mimetype */
    ASSOCSTR_DEFAULTICON,     /* Icon */
    ASSOCSTR_SHELLEXTENSION,  /* GUID for shell extension handler */
    ASSOCSTR_MAX
} ASSOCSTR;

typedef enum
{
    ASSOCKEY_SHELLEXECCLASS = 1, /* Key for ShellExec */
    ASSOCKEY_APP,                /* Application */
    ASSOCKEY_CLASS,              /* Progid or class */
    ASSOCKEY_BASECLASS,          /* Base class */
    ASSOCKEY_MAX
} ASSOCKEY;

typedef enum
{
    ASSOCDATA_MSIDESCRIPTOR = 1, /* Component descriptor */
    ASSOCDATA_NOACTIVATEHANDLER, /* Don't activate */
    ASSOCDATA_QUERYCLASSSTORE,   /* Look in Class Store */
    ASSOCDATA_HASPERUSERASSOC,   /* Use user association */
    ASSOCDATA_EDITFLAGS,         /* Edit flags */
    ASSOCDATA_VALUE,             /* pszExtra is value */
    ASSOCDATA_MAX
} ASSOCDATA;

typedef enum
{
    ASSOCENUM_NONE
} ASSOCENUM;

typedef struct IQueryAssociations *LPQUERYASSOCIATIONS;

#define INTERFACE IQueryAssociations
DECLARE_INTERFACE_(IQueryAssociations,IUnknown)
{
    /*** IUnknown methods ***/
    STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE;
    STDMETHOD_(ULONG,AddRef)(THIS) PURE;
    STDMETHOD_(ULONG,Release)(THIS) PURE;
    /*** IQueryAssociations methods ***/
    STDMETHOD(Init)(THIS_ _In_ ASSOCF flags, _In_opt_ LPCWSTR pszAssoc, _In_opt_ HKEY hkProgid, _In_opt_ HWND hwnd) PURE;
    STDMETHOD(GetString)(THIS_ _In_ ASSOCF flags, _In_ ASSOCSTR str, _In_opt_ LPCWSTR pszExtra, _Out_writes_opt_(*pcchOut) LPWSTR pszOut, _Inout_ DWORD *pcchOut) PURE;
    STDMETHOD(GetKey)(THIS_ _In_ ASSOCF flags, _In_ ASSOCKEY key, _In_opt_ LPCWSTR pszExtra, _Out_ HKEY *phkeyOut) PURE;
    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;
    STDMETHOD(GetEnum)(THIS_ _In_ ASSOCF flags, _In_ ASSOCENUM assocenum, _In_opt_ LPCWSTR pszExtra, _In_ REFIID riid, _Outptr_ LPVOID *ppvOut) PURE;
};
#undef INTERFACE

#if !defined(__cplusplus) || defined(CINTERFACE)
#define IQueryAssociations_QueryInterface(p,a,b)   (p)->lpVtbl->QueryInterface(p,a,b)
#define IQueryAssociations_AddRef(p)               (p)->lpVtbl->AddRef(p)
#define IQueryAssociations_Release(p)              (p)->lpVtbl->Release(p)
#define IQueryAssociations_Init(p,a,b,c,d)         (p)->lpVtbl->Init(p,a,b,c,d)
#define IQueryAssociations_GetString(p,a,b,c,d,e)  (p)->lpVtbl->GetString(p,a,b,c,d,e)
#define IQueryAssociations_GetKey(p,a,b,c,d)       (p)->lpVtbl->GetKey(p,a,b,c,d)
#define IQueryAssociations_GetData(p,a,b,c,d,e)    (p)->lpVtbl->GetData(p,a,b,c,d,e)
#define IQueryAssociations_GetEnum(p,a,b,c,d,e)    (p)->lpVtbl->GetEnum(p,a,b,c,d,e)
#endif

HRESULT WINAPI AssocCreate(_In_ CLSID, _In_ REFIID, _Outptr_ LPVOID*);

HRESULT
WINAPI
AssocQueryStringA(
  _In_ ASSOCF,
  _In_ ASSOCSTR,
  _In_ LPCSTR,
  _In_opt_ LPCSTR,
  _Out_writes_opt_(*pcchOut) LPSTR,
  _Inout_ LPDWORD pcchOut);

HRESULT
WINAPI
AssocQueryStringW(
  _In_ ASSOCF,
  _In_ ASSOCSTR,
  _In_ LPCWSTR,
  _In_opt_ LPCWSTR,
  _Out_writes_opt_(*pcchOut) LPWSTR,
  _Inout_ LPDWORD pcchOut);

#define AssocQueryString WINELIB_NAME_AW(AssocQueryString)

HRESULT
WINAPI
AssocQueryStringByKeyA(
  _In_ ASSOCF,
  _In_ ASSOCSTR,
  _In_ HKEY,
  _In_opt_ LPCSTR,
  _Out_writes_opt_(*pcchOut) LPSTR,
  _Inout_ LPDWORD pcchOut);

HRESULT
WINAPI
AssocQueryStringByKeyW(
  _In_ ASSOCF,
  _In_ ASSOCSTR,
  _In_ HKEY,
  _In_opt_ LPCWSTR,
  _Out_writes_opt_(*pcchOut) LPWSTR,
  _Inout_ LPDWORD pcchOut);

#define AssocQueryStringByKey WINELIB_NAME_AW(AssocQueryStringByKey)

HRESULT
WINAPI
AssocQueryKeyA(
  _In_ ASSOCF,
  _In_ ASSOCKEY,
  _In_ LPCSTR,
  _In_opt_ LPCSTR,
  _Out_ PHKEY);

HRESULT
WINAPI
AssocQueryKeyW(
  _In_ ASSOCF,
  _In_ ASSOCKEY,
  _In_ LPCWSTR,
  _In_opt_ LPCWSTR,
  _Out_ PHKEY);

#define AssocQueryKey WINELIB_NAME_AW(AssocQueryKey)

BOOL WINAPI AssocIsDangerous(_In_ LPCWSTR);

#endif /* NO_SHLWAPI_REG */

void WINAPI IUnknown_Set(_Inout_ IUnknown **ppunk, _In_opt_ IUnknown *punk);
void WINAPI IUnknown_AtomicRelease(_Inout_opt_ IUnknown **punk);
HRESULT WINAPI IUnknown_GetWindow(_In_ IUnknown *punk, _Out_ HWND *phwnd);

HRESULT
WINAPI
IUnknown_SetSite(
  _In_ IUnknown *punk,
  _In_opt_ IUnknown *punkSite);

HRESULT
WINAPI
IUnknown_GetSite(
  _In_ IUnknown *punk,
  _In_ REFIID riid,
  _Outptr_ void **ppv);

HRESULT
WINAPI
IUnknown_QueryService(
  _In_opt_ IUnknown *punk,
  _In_ REFGUID guidService,
  _In_ REFIID riid,
  _Outptr_ void **ppvOut);

/* Path functions */
#ifndef NO_SHLWAPI_PATH

/* GetPathCharType return flags */
#define GCT_INVALID     0x0
#define GCT_LFNCHAR     0x1
#define GCT_SHORTCHAR   0x2
#define GCT_WILD        0x4
#define GCT_SEPARATOR   0x8

LPSTR  WINAPI PathAddBackslashA(_Inout_updates_(MAX_PATH) LPSTR);
LPWSTR WINAPI PathAddBackslashW(_Inout_updates_(MAX_PATH) LPWSTR);
#define PathAddBackslash WINELIB_NAME_AW(PathAddBackslash)

BOOL
WINAPI
PathAddExtensionA(
  _Inout_updates_(MAX_PATH) LPSTR,
  _In_opt_ LPCSTR);

BOOL
WINAPI
PathAddExtensionW(
  _Inout_updates_(MAX_PATH) LPWSTR,
  _In_opt_ LPCWSTR);

#define PathAddExtension WINELIB_NAME_AW(PathAddExtension)

BOOL WINAPI PathAppendA(_Inout_updates_(MAX_PATH) LPSTR, _In_ LPCSTR);
BOOL WINAPI PathAppendW(_Inout_updates_(MAX_PATH) LPWSTR, _In_ LPCWSTR);
#define PathAppend WINELIB_NAME_AW(PathAppend)

LPSTR  WINAPI PathBuildRootA(_Out_writes_(4) LPSTR, int);
LPWSTR WINAPI PathBuildRootW(_Out_writes_(4) LPWSTR, int);
#define PathBuildRoot WINELIB_NAME_AW(PathBuiltRoot)

BOOL WINAPI PathCanonicalizeA(_Out_writes_(MAX_PATH) LPSTR, _In_ LPCSTR);
BOOL WINAPI PathCanonicalizeW(_Out_writes_(MAX_PATH) LPWSTR, _In_ LPCWSTR);
#define PathCanonicalize WINELIB_NAME_AW(PathCanonicalize)

LPSTR
WINAPI
PathCombineA(
  _Out_writes_(MAX_PATH) LPSTR,
  _In_opt_ LPCSTR,
  _In_opt_ LPCSTR);

LPWSTR
WINAPI
PathCombineW(
  _Out_writes_(MAX_PATH) LPWSTR,
  _In_opt_ LPCWSTR,
  _In_opt_ LPCWSTR);

#define PathCombine WINELIB_NAME_AW(PathCombine)

BOOL
WINAPI
PathCompactPathA(
  _In_opt_ HDC,
  _Inout_updates_(MAX_PATH) LPSTR,
  _In_ UINT);

BOOL
WINAPI
PathCompactPathW(
  _In_opt_ HDC,
  _Inout_updates_(MAX_PATH) LPWSTR,
  _In_ UINT);

#define PathCompactPath WINELIB_NAME_AW(PathCompactPath)

BOOL
WINAPI
PathCompactPathExA(
  _Out_writes_(cchMax) LPSTR,
  _In_ LPCSTR,
  _In_ UINT cchMax,
  _In_ DWORD);

BOOL
WINAPI
PathCompactPathExW(
  _Out_writes_(cchMax) LPWSTR,
  _In_ LPCWSTR,
  _In_ UINT cchMax,
  _In_ DWORD);

#define PathCompactPathEx WINELIB_NAME_AW(PathCompactPathEx)

int
WINAPI
PathCommonPrefixA(
  _In_ LPCSTR,
  _In_ LPCSTR,
  _Out_writes_opt_(MAX_PATH) LPSTR);

int
WINAPI
PathCommonPrefixW(
  _In_ LPCWSTR,
  _In_ LPCWSTR,
  _Out_writes_opt_(MAX_PATH) LPWSTR);

#define PathCommonPrefix WINELIB_NAME_AW(PathCommonPrefix)

HRESULT
WINAPI
PathCreateFromUrlA(
  _In_ LPCSTR,
  _Out_writes_to_(*pcchPath, *pcchPath) LPSTR,
  _Inout_ LPDWORD pcchPath,
  DWORD);

HRESULT
WINAPI
PathCreateFromUrlW(
  _In_ LPCWSTR pszUrl,
  _Out_writes_to_(*pcchPath, *pcchPath) LPWSTR pszPath,
  _Inout_ LPDWORD pcchPath,
  DWORD dwFlags);

#define PathCreateFromUrl WINELIB_NAME_AW(PathCreateFromUrl)

HRESULT WINAPI PathCreateFromUrlAlloc(_In_ LPCWSTR pszUrl, _Outptr_ LPWSTR* pszPath, DWORD dwReserved);

BOOL WINAPI PathFileExistsA(_In_ LPCSTR pszPath);
BOOL WINAPI PathFileExistsW(_In_ LPCWSTR pszPath);
#define PathFileExists WINELIB_NAME_AW(PathFileExists)

BOOL WINAPI PathFileExistsAndAttributesA(LPCSTR lpszPath,DWORD* dwAttr);
BOOL WINAPI PathFileExistsAndAttributesW(LPCWSTR lpszPath,DWORD* dwAttr);
#define PathFileExistsAndAttributes WINELIB_NAME_AW(PathFileExistsAndAttributes)

LPSTR  WINAPI PathFindExtensionA(_In_ LPCSTR pszPath);
LPWSTR WINAPI PathFindExtensionW(_In_ LPCWSTR pszPath);
#define PathFindExtension WINELIB_NAME_AW(PathFindExtension)

LPSTR  WINAPI PathFindFileNameA(_In_ LPCSTR pszPath);
LPWSTR WINAPI PathFindFileNameW(_In_ LPCWSTR pszPath);
#define PathFindFileName WINELIB_NAME_AW(PathFindFileName)

LPSTR  WINAPI PathFindNextComponentA(_In_ LPCSTR);
LPWSTR WINAPI PathFindNextComponentW(_In_ LPCWSTR);
#define PathFindNextComponent WINELIB_NAME_AW(PathFindNextComponent)

BOOL WINAPI PathFindOnPathA(_Inout_updates_(MAX_PATH) LPSTR, _In_opt_ LPCSTR*);
BOOL WINAPI PathFindOnPathW(_Inout_updates_(MAX_PATH) LPWSTR, _In_opt_ LPCWSTR*);
#define PathFindOnPath WINELIB_NAME_AW(PathFindOnPath)

LPSTR  WINAPI PathGetArgsA(_In_ LPCSTR pszPath);
LPWSTR WINAPI PathGetArgsW(_In_ LPCWSTR pszPath);
#define PathGetArgs WINELIB_NAME_AW(PathGetArgs)

UINT WINAPI PathGetCharTypeA(_In_ UCHAR ch);
UINT WINAPI PathGetCharTypeW(_In_ WCHAR ch);
#define PathGetCharType WINELIB_NAME_AW(PathGetCharType)

int WINAPI PathGetDriveNumberA(_In_ LPCSTR);
int WINAPI PathGetDriveNumberW(_In_ LPCWSTR);
#define PathGetDriveNumber WINELIB_NAME_AW(PathGetDriveNumber)

BOOL WINAPI PathIsDirectoryA(_In_ LPCSTR);
BOOL WINAPI PathIsDirectoryW(_In_ LPCWSTR);
#define PathIsDirectory WINELIB_NAME_AW(PathIsDirectory)

BOOL WINAPI PathIsDirectoryEmptyA(_In_ LPCSTR);
BOOL WINAPI PathIsDirectoryEmptyW(_In_ LPCWSTR);
#define PathIsDirectoryEmpty WINELIB_NAME_AW(PathIsDirectoryEmpty)

BOOL WINAPI PathIsFileSpecA(_In_ LPCSTR);
BOOL WINAPI PathIsFileSpecW(_In_ LPCWSTR);
#define PathIsFileSpec WINELIB_NAME_AW(PathIsFileSpec);

BOOL WINAPI PathIsPrefixA(_In_ LPCSTR, _In_ LPCSTR);
BOOL WINAPI PathIsPrefixW(_In_ LPCWSTR, _In_ LPCWSTR);
#define PathIsPrefix WINELIB_NAME_AW(PathIsPrefix)

BOOL WINAPI PathIsRelativeA(_In_ LPCSTR);
BOOL WINAPI PathIsRelativeW(_In_ LPCWSTR);
#define PathIsRelative WINELIB_NAME_AW(PathIsRelative)

BOOL WINAPI PathIsRootA(_In_ LPCSTR);
BOOL WINAPI PathIsRootW(_In_ LPCWSTR);
#define PathIsRoot WINELIB_NAME_AW(PathIsRoot)

BOOL WINAPI PathIsSameRootA(_In_ LPCSTR, _In_ LPCSTR);
BOOL WINAPI PathIsSameRootW(_In_ LPCWSTR, _In_ LPCWSTR);
#define PathIsSameRoot WINELIB_NAME_AW(PathIsSameRoot)

BOOL WINAPI PathIsUNCA(_In_ LPCSTR);
BOOL WINAPI PathIsUNCW(_In_ LPCWSTR);
#define PathIsUNC WINELIB_NAME_AW(PathIsUNC)

BOOL WINAPI PathIsUNCServerA(_In_ LPCSTR);
BOOL WINAPI PathIsUNCServerW(_In_ LPCWSTR);
#define PathIsUNCServer WINELIB_NAME_AW(PathIsUNCServer)

BOOL WINAPI PathIsUNCServerShareA(_In_ LPCSTR);
BOOL WINAPI PathIsUNCServerShareW(_In_ LPCWSTR);
#define PathIsUNCServerShare WINELIB_NAME_AW(PathIsUNCServerShare)

BOOL WINAPI PathIsContentTypeA(_In_ LPCSTR, _In_ LPCSTR);
BOOL WINAPI PathIsContentTypeW(_In_ LPCWSTR, _In_ LPCWSTR);
#define PathIsContentType WINELIB_NAME_AW(PathIsContentType)

BOOL WINAPI PathIsURLA(_In_ LPCSTR);
BOOL WINAPI PathIsURLW(_In_ LPCWSTR);
#define PathIsURL WINELIB_NAME_AW(PathIsURL)

BOOL WINAPI PathMakePrettyA(_Inout_ LPSTR);
BOOL WINAPI PathMakePrettyW(_Inout_ LPWSTR);
#define PathMakePretty WINELIB_NAME_AW(PathMakePretty)

BOOL WINAPI PathMatchSpecA(_In_ LPCSTR, _In_ LPCSTR);
BOOL WINAPI PathMatchSpecW(_In_ LPCWSTR, _In_ LPCWSTR);
#define PathMatchSpec WINELIB_NAME_AW(PathMatchSpec)

int WINAPI PathParseIconLocationA(_Inout_ LPSTR);
int WINAPI PathParseIconLocationW(_Inout_ LPWSTR);
#define PathParseIconLocation WINELIB_NAME_AW(PathParseIconLocation)

VOID WINAPI PathQuoteSpacesA(_Inout_updates_(MAX_PATH) LPSTR);
VOID WINAPI PathQuoteSpacesW(_Inout_updates_(MAX_PATH) LPWSTR);
#define PathQuoteSpaces WINELIB_NAME_AW(PathQuoteSpaces)

BOOL
WINAPI
PathRelativePathToA(
  _Out_writes_(MAX_PATH) LPSTR,
  _In_ LPCSTR,
  _In_ DWORD,
  _In_ LPCSTR,
  _In_ DWORD);

BOOL
WINAPI
PathRelativePathToW(
  _Out_writes_(MAX_PATH) LPWSTR,
  _In_ LPCWSTR,
  _In_ DWORD,
  _In_ LPCWSTR,
  _In_ DWORD);

#define PathRelativePathTo WINELIB_NAME_AW(PathRelativePathTo)

VOID WINAPI PathRemoveArgsA(_Inout_ LPSTR);
VOID WINAPI PathRemoveArgsW(_Inout_ LPWSTR);
#define PathRemoveArgs WINELIB_NAME_AW(PathRemoveArgs)

LPSTR  WINAPI PathRemoveBackslashA(_Inout_ LPSTR);
LPWSTR WINAPI PathRemoveBackslashW(_Inout_ LPWSTR);
#define PathRemoveBackslash WINELIB_NAME_AW(PathRemoveBackslash)

VOID WINAPI PathRemoveBlanksA(_Inout_ LPSTR);
VOID WINAPI PathRemoveBlanksW(_Inout_ LPWSTR);
#define PathRemoveBlanks WINELIB_NAME_AW(PathRemoveBlanks)

VOID WINAPI PathRemoveExtensionA(_Inout_ LPSTR);
VOID WINAPI PathRemoveExtensionW(_Inout_ LPWSTR);
#define PathRemoveExtension WINELIB_NAME_AW(PathRemoveExtension)

BOOL WINAPI PathRemoveFileSpecA(_Inout_ LPSTR);
BOOL WINAPI PathRemoveFileSpecW(_Inout_ LPWSTR);
#define PathRemoveFileSpec WINELIB_NAME_AW(PathRemoveFileSpec)

BOOL
WINAPI
PathRenameExtensionA(
  _Inout_updates_(MAX_PATH) LPSTR,
  _In_ LPCSTR);

BOOL
WINAPI
PathRenameExtensionW(
  _Inout_updates_(MAX_PATH) LPWSTR,
  _In_ LPCWSTR);

#define PathRenameExtension WINELIB_NAME_AW(PathRenameExtension)

BOOL
WINAPI
PathSearchAndQualifyA(
  _In_ LPCSTR,
  _Out_writes_(cchBuf) LPSTR,
  _In_ UINT cchBuf);

BOOL
WINAPI
PathSearchAndQualifyW(
  _In_ LPCWSTR,
  _Out_writes_(cchBuf) LPWSTR,
  _In_ UINT cchBuf);

#define PathSearchAndQualify WINELIB_NAME_AW(PathSearchAndQualify)

VOID WINAPI PathSetDlgItemPathA(_In_ HWND, int, LPCSTR);
VOID WINAPI PathSetDlgItemPathW(_In_ HWND, int, LPCWSTR);
#define PathSetDlgItemPath WINELIB_NAME_AW(PathSetDlgItemPath)

LPSTR  WINAPI PathSkipRootA(_In_ LPCSTR);
LPWSTR WINAPI PathSkipRootW(_In_ LPCWSTR);
#define PathSkipRoot WINELIB_NAME_AW(PathSkipRoot)

VOID WINAPI PathStripPathA(_Inout_ LPSTR);
VOID WINAPI PathStripPathW(_Inout_ LPWSTR);
#define PathStripPath WINELIB_NAME_AW(PathStripPath)

BOOL WINAPI PathStripToRootA(_Inout_ LPSTR);
BOOL WINAPI PathStripToRootW(_Inout_ LPWSTR);
#define PathStripToRoot WINELIB_NAME_AW(PathStripToRoot)

VOID WINAPI PathUnquoteSpacesA(_Inout_ LPSTR);
VOID WINAPI PathUnquoteSpacesW(_Inout_ LPWSTR);
#define PathUnquoteSpaces WINELIB_NAME_AW(PathUnquoteSpaces)

BOOL WINAPI PathMakeSystemFolderA(_In_ LPCSTR);
BOOL WINAPI PathMakeSystemFolderW(_In_ LPCWSTR);
#define PathMakeSystemFolder WINELIB_NAME_AW(PathMakeSystemFolder)

BOOL WINAPI PathUnmakeSystemFolderA(_In_ LPCSTR);
BOOL WINAPI PathUnmakeSystemFolderW(_In_ LPCWSTR);
#define PathUnmakeSystemFolder WINELIB_NAME_AW(PathUnmakeSystemFolder)

BOOL WINAPI PathIsSystemFolderA(_In_opt_ LPCSTR, _In_ DWORD);
BOOL WINAPI PathIsSystemFolderW(_In_opt_ LPCWSTR, _In_ DWORD);
#define PathIsSystemFolder WINELIB_NAME_AW(PathIsSystemFolder)

BOOL WINAPI PathIsNetworkPathA(_In_ LPCSTR);
BOOL WINAPI PathIsNetworkPathW(_In_ LPCWSTR);
#define PathIsNetworkPath WINELIB_NAME_AW(PathIsNetworkPath)

BOOL WINAPI PathIsLFNFileSpecA(_In_ LPCSTR);
BOOL WINAPI PathIsLFNFileSpecW(_In_ LPCWSTR);
#define PathIsLFNFileSpec WINELIB_NAME_AW(PathIsLFNFileSpec)

LPCSTR
WINAPI
PathFindSuffixArrayA(
  _In_ LPCSTR,
  _In_reads_(iArraySize) LPCSTR *,
  int iArraySize);

LPCWSTR
WINAPI
PathFindSuffixArrayW(
  _In_ LPCWSTR,
  _In_reads_(iArraySize) LPCWSTR *,
  int iArraySize);

#define PathFindSuffixArray WINELIB_NAME_AW(PathFindSuffixArray)

VOID WINAPI PathUndecorateA(_Inout_ LPSTR);
VOID WINAPI PathUndecorateW(_Inout_ LPWSTR);
#define PathUndecorate WINELIB_NAME_AW(PathUndecorate)

BOOL
WINAPI
PathUnExpandEnvStringsA(
  _In_ LPCSTR,
  _Out_writes_(cchBuf) LPSTR,
  _In_ UINT cchBuf);

BOOL
WINAPI
PathUnExpandEnvStringsW(
  _In_ LPCWSTR,
  _Out_writes_(cchBuf) LPWSTR,
  _In_ UINT cchBuf);

#define PathUnExpandEnvStrings WINELIB_NAME_AW(PathUnExpandEnvStrings)

/* Url functions */
typedef enum {
    URL_SCHEME_INVALID     = -1,
    URL_SCHEME_UNKNOWN     =  0,
    URL_SCHEME_FTP,
    URL_SCHEME_HTTP,
    URL_SCHEME_GOPHER,
    URL_SCHEME_MAILTO,
    URL_SCHEME_NEWS,
    URL_SCHEME_NNTP,
    URL_SCHEME_TELNET,
    URL_SCHEME_WAIS,
    URL_SCHEME_FILE,
    URL_SCHEME_MK,
    URL_SCHEME_HTTPS,
    URL_SCHEME_SHELL,
    URL_SCHEME_SNEWS,
    URL_SCHEME_LOCAL,
    URL_SCHEME_JAVASCRIPT,
    URL_SCHEME_VBSCRIPT,
    URL_SCHEME_ABOUT,
    URL_SCHEME_RES,
    URL_SCHEME_MSSHELLROOTED,
    URL_SCHEME_MSSHELLIDLIST,
    URL_SCHEME_MSHELP,
    URL_SCHEME_MSSHELLDEVICE,
    URL_SCHEME_WILDCARD,
    URL_SCHEME_SEARCH_MS,
    URL_SCHEME_SEARCH,
    URL_SCHEME_KNOWNFOLDER,
    URL_SCHEME_MAXVALUE
} URL_SCHEME;

/* These are used by UrlGetPart routine */
typedef enum {
    URL_PART_NONE    = 0,
    URL_PART_SCHEME  = 1,
    URL_PART_HOSTNAME,
    URL_PART_USERNAME,
    URL_PART_PASSWORD,
    URL_PART_PORT,
    URL_PART_QUERY
} URL_PART;

#define URL_PARTFLAG_KEEPSCHEME  0x00000001

/* These are used by the UrlIs... routines */
typedef enum {
    URLIS_URL,
    URLIS_OPAQUE,
    URLIS_NOHISTORY,
    URLIS_FILEURL,
    URLIS_APPLIABLE,
    URLIS_DIRECTORY,
    URLIS_HASQUERY
} URLIS;

/* This is used by the UrlApplyScheme... routines */
#define URL_APPLY_FORCEAPPLY         0x00000008
#define URL_APPLY_GUESSFILE          0x00000004
#define URL_APPLY_GUESSSCHEME        0x00000002
#define URL_APPLY_DEFAULT            0x00000001

/* The following are used by UrlEscape..., UrlUnEscape...,
 * UrlCanonicalize..., and UrlCombine... routines
 */
#define URL_WININET_COMPATIBILITY    0x80000000
#define URL_PLUGGABLE_PROTOCOL       0x40000000
#define URL_ESCAPE_UNSAFE            0x20000000
#define URL_UNESCAPE                 0x10000000

#define URL_DONT_SIMPLIFY            0x08000000
#define URL_NO_META                  URL_DONT_SIMPLIFY
#define URL_ESCAPE_SPACES_ONLY       0x04000000
#define URL_DONT_ESCAPE_EXTRA_INFO   0x02000000
#define URL_DONT_UNESCAPE_EXTRA_INFO URL_DONT_ESCAPE_EXTRA_INFO
#define URL_BROWSER_MODE             URL_DONT_ESCAPE_EXTRA_INFO

#define URL_INTERNAL_PATH            0x00800000  /* Will escape #'s in paths */
#define URL_UNESCAPE_HIGH_ANSI_ONLY  0x00400000
#define URL_CONVERT_IF_DOSPATH       0x00200000
#define URL_UNESCAPE_INPLACE         0x00100000

#define URL_FILE_USE_PATHURL         0x00010000
#define URL_ESCAPE_AS_UTF8           0x00040000

#define URL_ESCAPE_SEGMENT_ONLY      0x00002000
#define URL_ESCAPE_PERCENT           0x00001000

HRESULT
WINAPI
UrlApplySchemeA(
  _In_ LPCSTR,
  _Out_writes_(*pcchOut) LPSTR,
  _Inout_ LPDWORD pcchOut,
  DWORD);

HRESULT
WINAPI
UrlApplySchemeW(
  _In_ LPCWSTR,
  _Out_writes_(*pcchOut) LPWSTR,
  _Inout_ LPDWORD pcchOut,
  DWORD);

#define UrlApplyScheme WINELIB_NAME_AW(UrlApplyScheme)

HRESULT
WINAPI
UrlCanonicalizeA(
  _In_ LPCSTR,
  _Out_writes_to_(*pcchCanonicalized, *pcchCanonicalized) LPSTR,
  _Inout_ LPDWORD pcchCanonicalized,
  DWORD);

HRESULT
WINAPI
UrlCanonicalizeW(
  _In_ LPCWSTR,
  _Out_writes_to_(*pcchCanonicalized, *pcchCanonicalized) LPWSTR,
  _Inout_ LPDWORD pcchCanonicalized,
  DWORD);

#define UrlCanonicalize WINELIB_NAME_AW(UrlCanonicalize)

HRESULT
WINAPI
UrlCombineA(
  _In_ LPCSTR,
  _In_ LPCSTR,
  _Out_writes_to_opt_(*pcchCombined, *pcchCombined) LPSTR,
  _Inout_ LPDWORD pcchCombined,
  DWORD);

HRESULT
WINAPI
UrlCombineW(
  _In_ LPCWSTR,
  _In_ LPCWSTR,
  _Out_writes_to_opt_(*pcchCombined, *pcchCombined) LPWSTR,
  _Inout_ LPDWORD pcchCombined,
  DWORD);

#define UrlCombine WINELIB_NAME_AW(UrlCombine)

INT WINAPI UrlCompareA(_In_ LPCSTR, _In_ LPCSTR, BOOL);
INT WINAPI UrlCompareW(_In_ LPCWSTR, _In_ LPCWSTR, BOOL);
#define UrlCompare WINELIB_NAME_AW(UrlCompare)

HRESULT
WINAPI
UrlEscapeA(
  _In_ LPCSTR,
  _Out_writes_to_(*pcchEscaped, *pcchEscaped) LPSTR,
  _Inout_ LPDWORD pcchEscaped,
  DWORD);

HRESULT
WINAPI
UrlEscapeW(
  _In_ LPCWSTR,
  _Out_writes_to_(*pcchEscaped, *pcchEscaped) LPWSTR,
  _Inout_ LPDWORD pcchEscaped,
  DWORD);

#define UrlEscape WINELIB_NAME_AW(UrlEscape)

#define UrlEscapeSpacesA(x,y,z) UrlCanonicalizeA(x, y, z, \
                         URL_DONT_ESCAPE_EXTRA_INFO|URL_ESCAPE_SPACES_ONLY)
#define UrlEscapeSpacesW(x,y,z) UrlCanonicalizeW(x, y, z, \
                         URL_DONT_ESCAPE_EXTRA_INFO|URL_ESCAPE_SPACES_ONLY)
#define UrlEscapeSpaces WINELIB_NAME_AW(UrlEscapeSpaces)

LPCSTR  WINAPI UrlGetLocationA(_In_ LPCSTR);
LPCWSTR WINAPI UrlGetLocationW(_In_ LPCWSTR);
#define UrlGetLocation WINELIB_NAME_AW(UrlGetLocation)

HRESULT
WINAPI
UrlGetPartA(
  _In_ LPCSTR,
  _Out_writes_(*pcchOut) LPSTR,
  _Inout_ LPDWORD pcchOut,
  DWORD,
  DWORD);

HRESULT
WINAPI
UrlGetPartW(
  _In_ LPCWSTR,
  _Out_writes_(*pcchOut) LPWSTR,
  _Inout_ LPDWORD pcchOut,
  DWORD,
  DWORD);

#define UrlGetPart WINELIB_NAME_AW(UrlGetPart)

HRESULT
WINAPI
HashData(
  _In_reads_bytes_(cbData) const unsigned char *,
  DWORD cbData,
  _Out_writes_bytes_(cbHash) unsigned char *lpDest,
  DWORD cbHash);

HRESULT
WINAPI
UrlHashA(
  _In_ LPCSTR,
  _Out_writes_bytes_(cbHash) unsigned char *,
  DWORD cbHash);

HRESULT
WINAPI
UrlHashW(
  _In_ LPCWSTR,
  _Out_writes_bytes_(cbHash) unsigned char *,
  DWORD cbHash);

#define UrlHash WINELIB_NAME_AW(UrlHash)

BOOL    WINAPI UrlIsA(_In_ LPCSTR, URLIS);
BOOL    WINAPI UrlIsW(_In_ LPCWSTR, URLIS);
#define UrlIs WINELIB_NAME_AW(UrlIs)

BOOL    WINAPI UrlIsNoHistoryA(_In_ LPCSTR);
BOOL    WINAPI UrlIsNoHistoryW(_In_ LPCWSTR);
#define UrlIsNoHistory WINELIB_NAME_AW(UrlIsNoHistory)

BOOL    WINAPI UrlIsOpaqueA(_In_ LPCSTR);
BOOL    WINAPI UrlIsOpaqueW(_In_ LPCWSTR);
#define UrlIsOpaque WINELIB_NAME_AW(UrlIsOpaque)

#define UrlIsFileUrlA(x) UrlIsA(x, URLIS_FILEURL)
#define UrlIsFileUrlW(x) UrlIsW(x, URLIS_FILEURL)
#define UrlIsFileUrl WINELIB_NAME_AW(UrlIsFileUrl)

HRESULT
WINAPI
UrlUnescapeA(
  _Inout_ LPSTR,
  _Out_writes_to_opt_(*pcchUnescaped, *pcchUnescaped) LPSTR,
  _Inout_opt_ LPDWORD pcchUnescaped,
  DWORD);

HRESULT
WINAPI
UrlUnescapeW(
  _Inout_ LPWSTR,
  _Out_writes_to_opt_(*pcchUnescaped, *pcchUnescaped) LPWSTR,
  _Inout_opt_ LPDWORD pcchUnescaped,
  DWORD);

#define UrlUnescape WINELIB_NAME_AW(UrlUnescape)

#define UrlUnescapeInPlaceA(x,y) UrlUnescapeA(x, NULL, NULL, \
                                              y | URL_UNESCAPE_INPLACE)
#define UrlUnescapeInPlaceW(x,y) UrlUnescapeW(x, NULL, NULL, \
                                              y | URL_UNESCAPE_INPLACE)
#define UrlUnescapeInPlace WINELIB_NAME_AW(UrlUnescapeInPlace)

HRESULT
WINAPI
UrlCreateFromPathA(
  _In_ LPCSTR,
  _Out_writes_to_(*pcchUrl, *pcchUrl) LPSTR,
  _Inout_ LPDWORD pcchUrl,
  DWORD);

HRESULT
WINAPI
UrlCreateFromPathW(
  _In_ LPCWSTR,
  _Out_writes_to_(*pcchUrl, *pcchUrl) LPWSTR,
  _Inout_ LPDWORD pcchUrl,
  DWORD);

#define UrlCreateFromPath WINELIB_NAME_AW(UrlCreateFromPath)

typedef struct tagPARSEDURLA {
    DWORD cbSize;
    LPCSTR pszProtocol;
    UINT cchProtocol;
    LPCSTR pszSuffix;
    UINT cchSuffix;
    UINT nScheme;
} PARSEDURLA, *PPARSEDURLA;

typedef struct tagPARSEDURLW {
    DWORD cbSize;
    LPCWSTR pszProtocol;
    UINT cchProtocol;
    LPCWSTR pszSuffix;
    UINT cchSuffix;
    UINT nScheme;
} PARSEDURLW, *PPARSEDURLW;

HRESULT WINAPI ParseURLA(_In_ LPCSTR pszUrl, _Inout_ PARSEDURLA *ppu);
HRESULT WINAPI ParseURLW(_In_ LPCWSTR pszUrl, _Inout_ PARSEDURLW *ppu);
#define ParseURL WINELIB_NAME_AW(ParseUrl)

#endif /* NO_SHLWAPI_PATH */


/* String functions */
#ifndef NO_SHLWAPI_STRFCNS

/* StrToIntEx flags */
#define STIF_DEFAULT     0x0L
#define STIF_SUPPORT_HEX 0x1L

BOOL WINAPI ChrCmpIA (WORD,WORD);
BOOL WINAPI ChrCmpIW (WCHAR,WCHAR);
#define ChrCmpI WINELIB_NAME_AW(ChrCmpI)

INT WINAPI StrCSpnA(_In_ LPCSTR, _In_ LPCSTR);
INT WINAPI StrCSpnW(_In_ LPCWSTR, _In_ LPCWSTR);
#define StrCSpn WINELIB_NAME_AW(StrCSpn)

INT WINAPI StrCSpnIA(_In_ LPCSTR, _In_ LPCSTR);
INT WINAPI StrCSpnIW(_In_ LPCWSTR, _In_ LPCWSTR);
#define StrCSpnI WINELIB_NAME_AW(StrCSpnI)

#define StrCatA lstrcatA
LPWSTR WINAPI StrCatW(_Inout_ LPWSTR, _In_ LPCWSTR);
#define StrCat WINELIB_NAME_AW(StrCat)

LPSTR
WINAPI
StrCatBuffA(
  _Inout_updates_(cchDestBuffSize) LPSTR,
  _In_ LPCSTR,
  INT cchDestBuffSize);

LPWSTR
WINAPI
StrCatBuffW(
  _Inout_updates_(cchDestBuffSize) LPWSTR,
  _In_ LPCWSTR,
  INT cchDestBuffSize);

#define StrCatBuff WINELIB_NAME_AW(StrCatBuff)

DWORD
WINAPI
StrCatChainW(
  _Out_writes_(cchDst) LPWSTR,
  DWORD cchDst,
  DWORD,
  _In_ LPCWSTR);

LPSTR WINAPI StrChrA(_In_ LPCSTR, WORD);
LPWSTR WINAPI StrChrW(_In_ LPCWSTR, WCHAR);
#define StrChr WINELIB_NAME_AW(StrChr)

LPSTR WINAPI StrChrIA(_In_ LPCSTR, WORD);
LPWSTR WINAPI StrChrIW(_In_ LPCWSTR, WCHAR);
#define StrChrI WINELIB_NAME_AW(StrChrI)

#define StrCmpA lstrcmpA
int WINAPI StrCmpW(_In_ LPCWSTR, _In_ LPCWSTR);
#define StrCmp WINELIB_NAME_AW(StrCmp)

#define StrCmpIA lstrcmpiA
int WINAPI StrCmpIW(_In_ LPCWSTR, _In_ LPCWSTR);
#define StrCmpI WINELIB_NAME_AW(StrCmpI)

#define StrCpyA lstrcpyA
LPWSTR WINAPI StrCpyW(_Out_ LPWSTR, _In_ LPCWSTR);
#define StrCpy WINELIB_NAME_AW(StrCpy)

#define StrCpyNA lstrcpynA
LPWSTR WINAPI StrCpyNW(_Out_writes_(cchMax) LPWSTR, _In_ LPCWSTR, int cchMax);
#define StrCpyN WINELIB_NAME_AW(StrCpyN)
#define StrNCpy WINELIB_NAME_AW(StrCpyN)

INT WINAPI StrCmpLogicalW(_In_ LPCWSTR, _In_ LPCWSTR);

INT WINAPI StrCmpNA(_In_ LPCSTR, _In_ LPCSTR, INT);
INT WINAPI StrCmpNW(_In_ LPCWSTR, _In_ LPCWSTR, INT);
#define StrCmpN WINELIB_NAME_AW(StrCmpN)
#define StrNCmp WINELIB_NAME_AW(StrCmpN)

INT WINAPI StrCmpNIA(_In_ LPCSTR, _In_ LPCSTR, INT);
INT WINAPI StrCmpNIW(_In_ LPCWSTR, _In_ LPCWSTR, INT);
#define StrCmpNI WINELIB_NAME_AW(StrCmpNI)
#define StrNCmpI WINELIB_NAME_AW(StrCmpNI)

LPSTR WINAPI StrDupA(_In_ LPCSTR);
LPWSTR WINAPI StrDupW(_In_ LPCWSTR);
#define StrDup WINELIB_NAME_AW(StrDup)

HRESULT WINAPI SHStrDupA(_In_ LPCSTR, _Outptr_ WCHAR**);
HRESULT WINAPI SHStrDupW(_In_ LPCWSTR, _Outptr_ WCHAR**);
#define SHStrDup WINELIB_NAME_AW(SHStrDup)

LPSTR
WINAPI
StrFormatByteSizeA(
  DWORD,
  _Out_writes_(cchBuf) LPSTR,
  UINT cchBuf);

/* A/W Pairing is broken for this function */

LPSTR
WINAPI
StrFormatByteSize64A(
  LONGLONG,
  _Out_writes_(cchBuf) LPSTR,
  UINT cchBuf);

LPWSTR
WINAPI
StrFormatByteSizeW(
  LONGLONG,
  _Out_writes_(cchBuf) LPWSTR,
  UINT cchBuf);

#ifndef WINE_NO_UNICODE_MACROS
#ifdef UNICODE
#define StrFormatByteSize StrFormatByteSizeW
#else
#define StrFormatByteSize StrFormatByteSize64A
#endif
#endif

LPSTR
WINAPI
StrFormatKBSizeA(
  LONGLONG,
  _Out_writes_(cchBuf) LPSTR,
  UINT cchBuf);

LPWSTR
WINAPI
StrFormatKBSizeW(
  LONGLONG,
  _Out_writes_(cchBuf) LPWSTR,
  UINT cchBuf);

#define StrFormatKBSize WINELIB_NAME_AW(StrFormatKBSize)

int
WINAPI
StrFromTimeIntervalA(
  _Out_writes_(cchMax) LPSTR,
  UINT cchMax,
  DWORD,
  int);

int
WINAPI
StrFromTimeIntervalW(
  _Out_writes_(cchMax) LPWSTR,
  UINT cchMax,
  DWORD,
  int);

#define StrFromTimeInterval WINELIB_NAME_AW(StrFromTimeInterval)

BOOL WINAPI StrIsIntlEqualA(BOOL, _In_ LPCSTR, _In_ LPCSTR, int);
BOOL WINAPI StrIsIntlEqualW(BOOL, _In_ LPCWSTR, _In_ LPCWSTR, int);
#define StrIsIntlEqual WINELIB_NAME_AW(StrIsIntlEqual)

#define StrIntlEqNA(a,b,c) StrIsIntlEqualA(TRUE,a,b,c)
#define StrIntlEqNW(a,b,c) StrIsIntlEqualW(TRUE,a,b,c)

#define StrIntlEqNIA(a,b,c) StrIsIntlEqualA(FALSE,a,b,c)
#define StrIntlEqNIW(a,b,c) StrIsIntlEqualW(FALSE,a,b,c)

LPSTR  WINAPI StrNCatA(_Inout_updates_(cchMax) LPSTR, LPCSTR, int cchMax);
LPWSTR WINAPI StrNCatW(_Inout_updates_(cchMax) LPWSTR, LPCWSTR, int cchMax);
#define StrNCat WINELIB_NAME_AW(StrNCat)
#define StrCatN WINELIB_NAME_AW(StrNCat)

LPSTR  WINAPI StrPBrkA(_In_ LPCSTR, _In_ LPCSTR);
LPWSTR WINAPI StrPBrkW(_In_ LPCWSTR, _In_ LPCWSTR);
#define StrPBrk WINELIB_NAME_AW(StrPBrk)

LPSTR  WINAPI StrRChrA(_In_ LPCSTR, _In_opt_ LPCSTR, WORD);
LPWSTR WINAPI StrRChrW(_In_ LPCWSTR, _In_opt_ LPCWSTR, WCHAR);
#define StrRChr WINELIB_NAME_AW(StrRChr)

LPSTR  WINAPI StrRChrIA(_In_ LPCSTR, _In_opt_ LPCSTR, WORD);
LPWSTR WINAPI StrRChrIW(_In_ LPCWSTR, _In_opt_ LPCWSTR, WCHAR);
#define StrRChrI WINELIB_NAME_AW(StrRChrI)

LPSTR  WINAPI StrRStrIA(_In_ LPCSTR, _In_opt_ LPCSTR, _In_ LPCSTR);
LPWSTR WINAPI StrRStrIW(_In_ LPCWSTR, _In_opt_ LPCWSTR, _In_ LPCWSTR);
#define StrRStrI WINELIB_NAME_AW(StrRStrI)

int WINAPI StrSpnA(_In_ LPCSTR psz, _In_ LPCSTR pszSet);
int WINAPI StrSpnW(_In_ LPCWSTR psz, _In_ LPCWSTR pszSet);
#define StrSpn WINELIB_NAME_AW(StrSpn)

LPSTR  WINAPI StrStrA(_In_ LPCSTR pszFirst, _In_ LPCSTR pszSrch);
LPWSTR WINAPI StrStrW(_In_ LPCWSTR pszFirst, _In_ LPCWSTR pszSrch);
#define StrStr WINELIB_NAME_AW(StrStr)

LPSTR  WINAPI StrStrIA(_In_ LPCSTR pszFirst, _In_ LPCSTR pszSrch);
LPWSTR WINAPI StrStrIW(_In_ LPCWSTR pszFirst, _In_ LPCWSTR pszSrch);
#define StrStrI WINELIB_NAME_AW(StrStrI)

LPWSTR WINAPI StrStrNW(_In_ LPCWSTR, _In_ LPCWSTR, UINT);
LPWSTR WINAPI StrStrNIW(_In_ LPCWSTR, _In_ LPCWSTR, UINT);

int WINAPI StrToIntA(_In_ LPCSTR);
int WINAPI StrToIntW(_In_ LPCWSTR);
#define StrToInt WINELIB_NAME_AW(StrToInt)
#define StrToLong WINELIB_NAME_AW(StrToInt)

BOOL WINAPI StrToIntExA(_In_ LPCSTR, DWORD, _Out_ int*);
BOOL WINAPI StrToIntExW(_In_ LPCWSTR, DWORD, _Out_ int*);
#define StrToIntEx WINELIB_NAME_AW(StrToIntEx)

BOOL WINAPI StrToInt64ExA(_In_ LPCSTR, DWORD, _Out_ LONGLONG*);
BOOL WINAPI StrToInt64ExW(_In_ LPCWSTR, DWORD, _Out_ LONGLONG*);
#define StrToIntEx64 WINELIB_NAME_AW(StrToIntEx64)

BOOL WINAPI StrTrimA(_Inout_ LPSTR, _In_ LPCSTR);
BOOL WINAPI StrTrimW(_Inout_ LPWSTR, _In_ LPCWSTR);
#define StrTrim WINELIB_NAME_AW(StrTrim)

INT
WINAPI
wvnsprintfA(
  _Out_writes_(cchDest) LPSTR,
  _In_ INT cchDest,
  _In_ _Printf_format_string_ LPCSTR,
  _In_ __ms_va_list);

INT
WINAPI
wvnsprintfW(
  _Out_writes_(cchDest) LPWSTR,
  _In_ INT cchDest,
  _In_ _Printf_format_string_ LPCWSTR,
  _In_ __ms_va_list);

#define wvnsprintf WINELIB_NAME_AW(wvnsprintf)

INT
WINAPIV
wnsprintfA(
  _Out_writes_(cchDest) LPSTR,
  _In_ INT cchDest,
  _In_ _Printf_format_string_ LPCSTR,
  ...);

INT
WINAPIV
wnsprintfW(
  _Out_writes_(cchDest) LPWSTR,
  _In_ INT cchDest,
  _In_ _Printf_format_string_ LPCWSTR,
  ...);

#define wnsprintf WINELIB_NAME_AW(wnsprintf)

HRESULT
WINAPI
SHLoadIndirectString(
  _In_ LPCWSTR,
  _Out_writes_(cchOutBuf) LPWSTR,
  _In_ UINT cchOutBuf,
  _Reserved_ PVOID*);

BOOL
WINAPI
IntlStrEqWorkerA(
  BOOL,
  _In_reads_(nChar) LPCSTR,
  _In_reads_(nChar) LPCSTR,
  int nChar);

BOOL
WINAPI
IntlStrEqWorkerW(
  BOOL,
  _In_reads_(nChar) LPCWSTR,
  _In_reads_(nChar) LPCWSTR,
  int nChar);

#define IntlStrEqWorker WINELIB_NAME_AW(IntlStrEqWorker)

#define IntlStrEqNA(s1,s2,n) IntlStrEqWorkerA(TRUE,s1,s2,n)
#define IntlStrEqNW(s1,s2,n) IntlStrEqWorkerW(TRUE,s1,s2,n)
#define IntlStrEqN WINELIB_NAME_AW(IntlStrEqN)

#define IntlStrEqNIA(s1,s2,n) IntlStrEqWorkerA(FALSE,s1,s2,n)
#define IntlStrEqNIW(s1,s2,n) IntlStrEqWorkerW(FALSE,s1,s2,n)
#define IntlStrEqNI WINELIB_NAME_AW(IntlStrEqNI)

HRESULT
WINAPI
StrRetToStrA(
  _Inout_ STRRET*,
  _In_opt_ PCUITEMID_CHILD,
  _Outptr_ LPSTR*);

HRESULT
WINAPI
StrRetToStrW(
  _Inout_ STRRET*,
  _In_opt_ PCUITEMID_CHILD,
  _Outptr_ LPWSTR*);

#define StrRetToStr WINELIB_NAME_AW(StrRetToStr)

HRESULT
WINAPI
StrRetToBufA(
  _Inout_ STRRET*,
  _In_opt_ PCUITEMID_CHILD,
  _Out_writes_(cchBuf) LPSTR,
  UINT cchBuf);

HRESULT
WINAPI
StrRetToBufW(
  _Inout_ STRRET*,
  _In_opt_ PCUITEMID_CHILD,
  _Out_writes_(cchBuf) LPWSTR,
  UINT cchBuf);

#define StrRetToBuf WINELIB_NAME_AW(StrRetToBuf)

HRESULT
WINAPI
StrRetToBSTR(
  _Inout_ STRRET*,
  _In_opt_ PCUITEMID_CHILD,
  _Outptr_ BSTR*);

BOOL WINAPI IsCharSpaceA(CHAR);
BOOL WINAPI IsCharSpaceW(WCHAR);
#define IsCharSpace WINELIB_NAME_AW(IsCharSpace)

#endif /* NO_SHLWAPI_STRFCNS */


/* GDI functions */
#ifndef NO_SHLWAPI_GDI

HPALETTE WINAPI SHCreateShellPalette(_In_opt_ HDC);

COLORREF WINAPI ColorHLSToRGB(WORD,WORD,WORD);

COLORREF WINAPI ColorAdjustLuma(COLORREF,int,BOOL);

VOID WINAPI ColorRGBToHLS(COLORREF, _Out_ LPWORD, _Out_ LPWORD, _Out_ LPWORD);

#endif /* NO_SHLWAPI_GDI */

/* Security functions */
BOOL WINAPI IsInternetESCEnabled(void);

/* Stream functions */
#ifndef NO_SHLWAPI_STREAM

struct IStream *
WINAPI
SHOpenRegStreamA(
  _In_ HKEY,
  _In_opt_ LPCSTR,
  _In_opt_ LPCSTR,
  _In_ DWORD);

struct IStream *
WINAPI
SHOpenRegStreamW(
  _In_ HKEY,
  _In_opt_ LPCWSTR,
  _In_opt_ LPCWSTR,
  _In_ DWORD);

#define SHOpenRegStream WINELIB_NAME_AW(SHOpenRegStream2) /* Uses version 2 */

struct IStream *
WINAPI
SHOpenRegStream2A(
  _In_ HKEY,
  _In_opt_ LPCSTR,
  _In_opt_ LPCSTR,
  _In_ DWORD);

struct IStream *
WINAPI
SHOpenRegStream2W(
  _In_ HKEY,
  _In_opt_ LPCWSTR,
  _In_opt_ LPCWSTR,
  _In_ DWORD);

#define SHOpenRegStream2 WINELIB_NAME_AW(SHOpenRegStream2)

HRESULT
WINAPI
SHCreateStreamOnFileA(
  _In_ LPCSTR,
  _In_ DWORD,
  _Outptr_ struct IStream**);

HRESULT
WINAPI
SHCreateStreamOnFileW(
  _In_ LPCWSTR,
  _In_ DWORD,
  _Outptr_ struct IStream**);

#define SHCreateStreamOnFile WINELIB_NAME_AW(SHCreateStreamOnFile)

struct IStream*
WINAPI
SHCreateMemStream(
  _In_reads_bytes_opt_(cbInit) const BYTE *pInit,
  _In_ UINT cbInit);

HRESULT
WINAPI
SHCreateStreamOnFileEx(
  _In_ LPCWSTR,
  _In_ DWORD,
  _In_ DWORD,
  _In_ BOOL,
  _In_opt_ struct IStream*,
  _Outptr_ struct IStream**);

HRESULT WINAPI SHCreateStreamWrapper(LPBYTE,DWORD,DWORD,struct IStream**);

#endif /* NO_SHLWAPI_STREAM */

#ifndef NO_SHLWAPI_SHARED

// These functions are only included in this file starting with the Windows 7 platform SDK

HANDLE
WINAPI
SHAllocShared(
    _In_opt_  const void *pvData,
    _In_      DWORD dwSize,
    _In_      DWORD dwDestinationProcessId
    );

PVOID
WINAPI
SHLockShared(
    _In_  HANDLE hData,
    _In_  DWORD dwProcessId
    );

BOOL
WINAPI
SHUnlockShared(
    _In_  void *pvData
    );

BOOL
WINAPI
SHFreeShared(
    _In_  HANDLE hData,
    _In_  DWORD dwProcessId
    );

#endif /* NO_SHLWAPI_SHARED */

/* SHAutoComplete flags */
#define SHACF_DEFAULT               0x00000000
#define SHACF_FILESYSTEM            0x00000001
#define SHACF_URLHISTORY            0x00000002
#define SHACF_URLMRU                0x00000004
#define SHACF_URLALL                (SHACF_URLHISTORY|SHACF_URLMRU)
#define SHACF_USETAB                0x00000008
#define SHACF_FILESYS_ONLY          0x00000010
#define SHACF_FILESYS_DIRS          0x00000020
#define SHACF_AUTOSUGGEST_FORCE_ON  0x10000000
#define SHACF_AUTOSUGGEST_FORCE_OFF 0x20000000
#define SHACF_AUTOAPPEND_FORCE_ON   0x40000000
#define SHACF_AUTOAPPEND_FORCE_OFF  0x80000000

HRESULT WINAPI SHAutoComplete(_In_ HWND, DWORD);

/* Threads */
HRESULT WINAPI SHCreateThreadRef(_Inout_ LONG*, _Outptr_ IUnknown**);
HRESULT WINAPI SHGetThreadRef(_Outptr_ IUnknown**);
HRESULT WINAPI SHSetThreadRef(_In_opt_ IUnknown*);
HRESULT WINAPI SHReleaseThreadRef(void);

/* SHCreateThread flags */
#define CTF_INSIST          0x01 /* Always call */
#define CTF_THREAD_REF      0x02 /* Hold thread ref */
#define CTF_PROCESS_REF     0x04 /* Hold process ref */
#define CTF_COINIT          0x08 /* Startup COM first */
#define CTF_FREELIBANDEXIT  0x10 /* Hold DLL ref */
#define CTF_REF_COUNTED     0x20 /* Thread is ref counted */
#define CTF_WAIT_ALLOWCOM   0x40 /* Allow marshalling */

BOOL
WINAPI
SHCreateThread(
  _In_ LPTHREAD_START_ROUTINE pfnThreadProc,
  _In_opt_ void* pData,
  _In_ DWORD flags,
  _In_opt_ LPTHREAD_START_ROUTINE pfnCallback);

BOOL WINAPI SHSkipJunction(_In_opt_ struct IBindCtx*, _In_ const CLSID*);

/* Version Information */

typedef struct _DllVersionInfo {
    DWORD cbSize;
    DWORD dwMajorVersion;
    DWORD dwMinorVersion;
    DWORD dwBuildNumber;
    DWORD dwPlatformID;
} DLLVERSIONINFO;

#define DLLVER_PLATFORM_WINDOWS 0x01 /* Win9x */
#define DLLVER_PLATFORM_NT      0x02 /* WinNT */

typedef HRESULT (CALLBACK *DLLGETVERSIONPROC)(DLLVERSIONINFO *);

#ifdef __WINESRC__
/* shouldn't be here, but is nice for type checking */
HRESULT WINAPI DllGetVersion(DLLVERSIONINFO *) DECLSPEC_HIDDEN;
#endif

typedef struct _DLLVERSIONINFO2 {
    DLLVERSIONINFO info1;
    DWORD          dwFlags;    /* Reserved */
    ULONGLONG DECLSPEC_ALIGN(8) ullVersion; /* 16 bits each for Major, Minor, Build, QFE */
} DLLVERSIONINFO2;

#define DLLVER_MAJOR_MASK 0xFFFF000000000000
#define DLLVER_MINOR_MASK 0x0000FFFF00000000
#define DLLVER_BUILD_MASK 0x00000000FFFF0000
#define DLLVER_QFE_MASK   0x000000000000FFFF

#define MAKEDLLVERULL(mjr, mnr, bld, qfe) (((ULONGLONG)(mjr)<< 48)| \
  ((ULONGLONG)(mnr)<< 32) | ((ULONGLONG)(bld)<< 16) | (ULONGLONG)(qfe))

HRESULT WINAPI DllInstall(BOOL, _In_opt_ LPCWSTR) DECLSPEC_HIDDEN;


#if (_WIN32_IE >= 0x0600)
#define SHGVSPB_PERUSER        0x00000001
#define SHGVSPB_ALLUSERS       0x00000002
#define SHGVSPB_PERFOLDER      0x00000004
#define SHGVSPB_ALLFOLDERS     0x00000008
#define SHGVSPB_INHERIT        0x00000010
#define SHGVSPB_ROAM           0x00000020
#define SHGVSPB_NOAUTODEFAULTS 0x80000000

#define SHGVSPB_FOLDER           (SHGVSPB_PERUSER | SHGVSPB_PERFOLDER)
#define SHGVSPB_FOLDERNODEFAULTS (SHGVSPB_PERUSER | SHGVSPB_PERFOLDER | SHGVSPB_NOAUTODEFAULTS)
#define SHGVSPB_USERDEFAULTS     (SHGVSPB_PERUSER | SHGVSPB_ALLFOLDERS)
#define SHGVSPB_GLOBALDEAFAULTS  (SHGVSPB_ALLUSERS | SHGVSPB_ALLFOLDERS)

HRESULT
WINAPI
SHGetViewStatePropertyBag(
  _In_opt_ PCIDLIST_ABSOLUTE pidl,
  _In_opt_ LPCWSTR bag_name,
  _In_ DWORD flags,
  _In_ REFIID riid,
  _Outptr_ void **ppv);

#endif  /* (_WIN32_IE >= 0x0600) */


/* IsOS definitions */

#define OS_WIN32SORGREATER        0x00
#define OS_NT                     0x01
#define OS_WIN95ORGREATER         0x02
#define OS_NT4ORGREATER           0x03
#define OS_WIN2000ORGREATER_ALT   0x04
#define OS_WIN98ORGREATER         0x05
#define OS_WIN98_GOLD             0x06
#define OS_WIN2000ORGREATER       0x07
#define OS_WIN2000PRO             0x08
#define OS_WIN2000SERVER          0x09
#define OS_WIN2000ADVSERVER       0x0A
#define OS_WIN2000DATACENTER      0x0B
#define OS_WIN2000TERMINAL        0x0C
#define OS_EMBEDDED               0x0D
#define OS_TERMINALCLIENT         0x0E
#define OS_TERMINALREMOTEADMIN    0x0F
#define OS_WIN95_GOLD             0x10
#define OS_MEORGREATER            0x11
#define OS_XPORGREATER            0x12
#define OS_HOME                   0x13
#define OS_PROFESSIONAL           0x14
#define OS_DATACENTER             0x15
#define OS_ADVSERVER              0x16
#define OS_SERVER                 0x17
#define OS_TERMINALSERVER         0x18
#define OS_PERSONALTERMINALSERVER 0x19
#define OS_FASTUSERSWITCHING      0x1A
#define OS_WELCOMELOGONUI         0x1B
#define OS_DOMAINMEMBER           0x1C
#define OS_ANYSERVER              0x1D
#define OS_WOW6432                0x1E
#define OS_WEBSERVER              0x1F
#define OS_SMALLBUSINESSSERVER    0x20
#define OS_TABLETPC               0x21
#define OS_SERVERADMINUI          0x22
#define OS_MEDIACENTER            0x23
#define OS_APPLIANCE              0x24

BOOL WINAPI IsOS(DWORD);

/* SHSetTimerQueueTimer definitions */
#define TPS_EXECUTEIO    0x00000001
#define TPS_LONGEXECTIME 0x00000008

/* SHFormatDateTimeA/SHFormatDateTimeW flags */
#define FDTF_SHORTTIME          0x00000001
#define FDTF_SHORTDATE          0x00000002
#define FDTF_DEFAULT            (FDTF_SHORTDATE | FDTF_SHORTTIME)
#define FDTF_LONGDATE           0x00000004
#define FDTF_LONGTIME           0x00000008
#define FDTF_RELATIVE           0x00000010
#define FDTF_LTRDATE            0x00000100
#define FDTF_RTLDATE            0x00000200
#define FDTF_NOAUTOREADINGORDER 0x00000400


typedef struct
{
    const IID *piid;
#if defined(__REACTOS__) || (WINVER >= _WIN32_WINNT_WIN10)
    DWORD dwOffset;
#else
    int dwOffset;
#endif
} QITAB, *LPQITAB;

HRESULT
WINAPI
QISearch(
  _Inout_ void* base,
  _In_ const QITAB *pqit,
  _In_ REFIID riid,
  _Outptr_ void **ppv);

#define OFFSETOFCLASS(base, derived) \
    ((DWORD)(DWORD_PTR)(static_cast<base*>((derived*)8))-8)

#define QITABENTMULTI(Cthis, Ifoo, Iimpl) { &IID_##Ifoo, OFFSETOFCLASS(Iimpl, Cthis) }
#define QITABENT(Cthis, Ifoo) QITABENTMULTI(Cthis, Ifoo, Ifoo)

#include <poppack.h>

#ifdef __cplusplus
} /* extern "C" */
#endif /* defined(__cplusplus) */

#endif /* __WINE_SHLWAPI_H */