/***********************************************************************\
*                               shlwapi.d                               *
*                                                                       *
*                       Windows API header module                       *
*                                                                       *
*                 Translated from MinGW Windows headers                 *
*                                                                       *
*                       Placed into public domain                       *
\***********************************************************************/
module win32.shlwapi;
pragma(lib, "shlwapi.lib");

/* Changes compared to MinGW:
wnsprintf functions are not included.
// Macros unneeded for D
#define StrCmpIA lstrcmpiA;
#define StrCmpA lstrcmpA;
#define StrCpyA lstrcpyA;
#define StrCpyNA lstrcpynA;
#define MAKEDLLVERULL(major, minor, build, qfe) \
        (((ULONGLONG)(major) << 48) | \
         ((ULONGLONG)(minor) << 32) | \
         ((ULONGLONG)(build) << 16) | \
         ((ULONGLONG)(  qfe) <<  0))
*/

import win32.objbase, win32.shlobj;
private import win32.basetyps, win32.objidl, win32.unknwn, win32.windef,
  win32.winbase, win32.winreg;

const DLLVER_PLATFORM_WINDOWS = 0x00000001;
const DLLVER_PLATFORM_NT      = 0x00000002;

const URL_DONT_ESCAPE_EXTRA_INFO  = 0x02000000;
const URL_DONT_SIMPLIFY           = 0x08000000;
const URL_ESCAPE_PERCENT          = 0x00001000;
const URL_ESCAPE_SEGMENT_ONLY     = 0x00002000;
const URL_ESCAPE_SPACES_ONLY      = 0x04000000;
const URL_ESCAPE_UNSAFE           = 0x20000000;
const URL_INTERNAL_PATH           = 0x00800000;
const URL_PARTFLAG_KEEPSCHEME     = 0x00000001;
const URL_PLUGGABLE_PROTOCOL      = 0x40000000;
const URL_UNESCAPE                = 0x10000000;
const URL_UNESCAPE_HIGH_ANSI_ONLY = 0x00400000;
const URL_UNESCAPE_INPLACE        = 0x00100000;

align(1):
struct DLLVERSIONINFO
{
	DWORD cbSize = this.sizeof;
	DWORD dwMajorVersion;
	DWORD dwMinorVersion;
	DWORD dwBuildNumber;
	DWORD dwPlatformID;
}

struct DLLVERSIONINFO2
{
	DLLVERSIONINFO info1;
	DWORD dwFlags;
	ULONGLONG ullVersion;
}

enum ASSOCSTR {
	ASSOCSTR_COMMAND,
	ASSOCSTR_EXECUTABLE,
	ASSOCSTR_FRIENDLYDOCNAME,
	ASSOCSTR_FRIENDLYAPPNAME,
	ASSOCSTR_NOOPEN,
	ASSOCSTR_SHELLNEWVALUE,
	ASSOCSTR_DDECOMMAND,
	ASSOCSTR_DDEIFEXEC,
	ASSOCSTR_DDEAPPLICATION,
	ASSOCSTR_DDETOPIC
}

enum ASSOCKEY
{
	ASSOCKEY_SHELLEXECCLASS = 1,
	ASSOCKEY_APP,
	ASSOCKEY_CLASS,
	ASSOCKEY_BASECLASS
}

enum ASSOCDATA
{
	ASSOCDATA_MSIDESCRIPTOR = 1,
	ASSOCDATA_NOACTIVATEHANDLER,
	ASSOCDATA_QUERYCLASSSTORE
}

alias DWORD ASSOCF;

enum SHREGDEL_FLAGS
{
	SHREGDEL_DEFAULT = 0x00000000,
	SHREGDEL_HKCU    = 0x00000001,
	SHREGDEL_HKLM    = 0x00000010,
	SHREGDEL_BOTH    = 0x00000011
}

enum SHREGENUM_FLAGS
{
	SHREGENUM_DEFAULT = 0x00000000,
	SHREGENUM_HKCU    = 0x00000001,
	SHREGENUM_HKLM    = 0x00000010,
	SHREGENUM_BOTH    = 0x00000011
}

enum URLIS
{
	URLIS_URL,
	URLIS_OPAQUE,
	URLIS_NOHISTORY,
	URLIS_FILEURL,
	URLIS_APPLIABLE,
	URLIS_DIRECTORY,
	URLIS_HASQUERY
}

alias HANDLE HUSKEY;
alias HUSKEY* PHUSKEY;

extern (Windows)
{
	alias HRESULT function (DLLVERSIONINFO *) DLLGETVERSIONPROC;
}


BOOL IntlStrEqNA(LPCSTR pStr1, LPCSTR pStr2, int nChar)
{
	return IntlStrEqWorkerA(TRUE, pStr1, pStr2, nChar);
}

BOOL IntlStrEqNW(LPCWSTR pStr1, LPCWSTR pStr2, int nChar)
{
	return IntlStrEqWorkerW(TRUE, pStr1, pStr2, nChar);
}

BOOL IntlStrEqNIA(LPCSTR pStr1, LPCSTR pStr2, int nChar)
{
	return IntlStrEqWorkerA(FALSE, pStr1, pStr2, nChar);
}

BOOL IntlStrEqNIW(LPCWSTR pStr1, LPCWSTR pStr2, int nChar)
{
	return IntlStrEqWorkerW(FALSE, pStr1, pStr2, nChar);
}

BOOL UrlIsFileUrlA(LPCSTR pszURL)
{
	return UrlIsA(pszURL, URLIS.URLIS_FILEURL);
}

BOOL UrlIsFileUrlW(LPCWSTR pszURL)
{
	return UrlIsW(pszURL, URLIS.URLIS_FILEURL);
}

HRESULT UrlUnescapeInPlaceA(LPSTR pszUrl,DWORD dwFlags)
{
	return UrlUnescapeA(pszUrl, null, null, dwFlags | URL_UNESCAPE_INPLACE);
}
HRESULT UrlUnescapeInPlaceW(LPWSTR pszUrl,DWORD dwFlags)
{
	return UrlUnescapeW(pszUrl, null, null, dwFlags | URL_UNESCAPE_INPLACE);
}

extern (Windows):
BOOL ChrCmpIA(WORD,WORD);
BOOL ChrCmpIW(WCHAR,WCHAR);
BOOL IntlStrEqWorkerA(BOOL,LPCSTR,LPCSTR,int);
BOOL IntlStrEqWorkerW(BOOL,LPCWSTR,LPCWSTR,int);
HRESULT SHStrDupA(LPCSTR,LPWSTR*);
HRESULT SHStrDupW(LPCWSTR,LPWSTR*);
LPSTR StrCatA(LPSTR,LPCSTR);
LPWSTR StrCatW(LPWSTR,LPCWSTR);
LPSTR StrCatBuffA(LPSTR,LPCSTR,int);
LPWSTR StrCatBuffW(LPWSTR,LPCWSTR,int);
DWORD StrCatChainW(LPWSTR,DWORD,DWORD,LPCWSTR);
LPSTR StrChrA(LPCSTR,WORD);
LPWSTR StrChrW(LPCWSTR,WCHAR);
LPSTR StrChrIA(LPCSTR,WORD);
LPWSTR StrChrIW(LPCWSTR,WCHAR);
int StrCmpIW(LPCWSTR,LPCWSTR);
int StrCmpW(LPCWSTR,LPCWSTR);
LPWSTR StrCpyW(LPWSTR,LPCWSTR);
LPWSTR StrCpyNW(LPWSTR,LPCWSTR,int);
int StrCmpNA(LPCSTR,LPCSTR,int);
int StrCmpNW(LPCWSTR,LPCWSTR,int);
int StrCmpNIA(LPCSTR,LPCSTR,int);
int StrCmpNIW(LPCWSTR,LPCWSTR,int);
int StrCSpnA(LPCSTR,LPCSTR);
int StrCSpnW(LPCWSTR,LPCWSTR);
int StrCSpnIA(LPCSTR,LPCSTR);
int StrCSpnIW(LPCWSTR,LPCWSTR);
LPSTR StrDupA(LPCSTR);
LPWSTR StrDupW(LPCWSTR);
LPSTR StrFormatByteSize64A(LONGLONG,LPSTR,UINT);
LPSTR StrFormatByteSizeA(DWORD,LPSTR,UINT);
LPWSTR StrFormatByteSizeW(LONGLONG,LPWSTR,UINT);
LPSTR StrFormatKBSizeA(LONGLONG,LPSTR,UINT);
LPWSTR StrFormatKBSizeW(LONGLONG,LPWSTR,UINT);
int StrFromTimeIntervalA(LPSTR,UINT,DWORD,int);
int StrFromTimeIntervalW(LPWSTR,UINT,DWORD,int);
BOOL StrIsIntlEqualA(BOOL,LPCSTR,LPCSTR,int);
BOOL StrIsIntlEqualW(BOOL,LPCWSTR,LPCWSTR,int);
LPSTR StrNCatA(LPSTR,LPCSTR,int);
LPWSTR StrNCatW(LPWSTR,LPCWSTR,int);
LPSTR StrPBrkA(LPCSTR,LPCSTR);
LPWSTR StrPBrkW(LPCWSTR,LPCWSTR);
LPSTR StrRChrA(LPCSTR,LPCSTR,WORD);
LPWSTR StrRChrW(LPCWSTR,LPCWSTR,WCHAR);
LPSTR StrRChrIA(LPCSTR,LPCSTR,WORD);
LPWSTR StrRChrIW(LPCWSTR,LPCWSTR,WCHAR);
LPSTR StrRStrIA(LPCSTR,LPCSTR,LPCSTR);
LPWSTR StrRStrIW(LPCWSTR,LPCWSTR,LPCWSTR);
int StrSpnA(LPCSTR,LPCSTR);
int StrSpnW(LPCWSTR,LPCWSTR);
LPSTR StrStrA(LPCSTR, LPCSTR);
LPSTR StrStrIA(LPCSTR,LPCSTR);
LPWSTR StrStrIW(LPCWSTR,LPCWSTR);
LPWSTR StrStrW(LPCWSTR,LPCWSTR);
int StrToIntA(LPCSTR);
int StrToIntW(LPCWSTR);
BOOL StrToIntExA(LPCSTR,DWORD,int*);
BOOL StrToIntExW(LPCWSTR,DWORD,int*);
BOOL StrTrimA(LPSTR,LPCSTR);
BOOL StrTrimW(LPWSTR,LPCWSTR);
LPSTR PathAddBackslashA(LPSTR);
LPWSTR PathAddBackslashW(LPWSTR);
BOOL PathAddExtensionA(LPSTR,LPCSTR);
BOOL PathAddExtensionW(LPWSTR,LPCWSTR);
BOOL PathAppendA(LPSTR,LPCSTR);
BOOL PathAppendW(LPWSTR,LPCWSTR);
LPSTR PathBuildRootA(LPSTR,int);
LPWSTR PathBuildRootW(LPWSTR,int);
BOOL PathCanonicalizeA(LPSTR,LPCSTR);
BOOL PathCanonicalizeW(LPWSTR,LPCWSTR);
LPSTR PathCombineA(LPSTR,LPCSTR,LPCSTR);
LPWSTR PathCombineW(LPWSTR,LPCWSTR,LPCWSTR);
int PathCommonPrefixA(LPCSTR,LPCSTR,LPSTR);
int PathCommonPrefixW(LPCWSTR,LPCWSTR,LPWSTR);
BOOL PathCompactPathA(HDC,LPSTR,UINT);
BOOL PathCompactPathW(HDC,LPWSTR,UINT);
BOOL PathCompactPathExA(LPSTR,LPCSTR,UINT,DWORD);
BOOL PathCompactPathExW(LPWSTR,LPCWSTR,UINT,DWORD);
HRESULT PathCreateFromUrlA(LPCSTR,LPSTR,LPDWORD,DWORD);
HRESULT PathCreateFromUrlW(LPCWSTR,LPWSTR,LPDWORD,DWORD);
BOOL PathFileExistsA(LPCSTR);
BOOL PathFileExistsW(LPCWSTR);
LPSTR PathFindExtensionA(LPCSTR);
LPWSTR PathFindExtensionW(LPCWSTR);
LPSTR PathFindFileNameA(LPCSTR);
LPWSTR PathFindFileNameW(LPCWSTR);
LPSTR PathFindNextComponentA(LPCSTR);
LPWSTR PathFindNextComponentW(LPCWSTR);
BOOL PathFindOnPathA(LPSTR,LPCSTR*);
BOOL PathFindOnPathW(LPWSTR,LPCWSTR*);
LPCSTR PathFindSuffixArrayA(LPCSTR,LPCSTR*,int);
LPCWSTR PathFindSuffixArrayW(LPCWSTR,LPCWSTR*,int);
LPSTR PathGetArgsA(LPCSTR);
LPWSTR PathGetArgsW(LPCWSTR);
UINT PathGetCharTypeA(UCHAR);
UINT PathGetCharTypeW(WCHAR);
int PathGetDriveNumberA(LPCSTR);
int PathGetDriveNumberW(LPCWSTR);
BOOL PathIsContentTypeA(LPCSTR,LPCSTR);
BOOL PathIsContentTypeW(LPCWSTR,LPCWSTR);
BOOL PathIsDirectoryA(LPCSTR);
BOOL PathIsDirectoryEmptyA(LPCSTR);
BOOL PathIsDirectoryEmptyW(LPCWSTR);
BOOL PathIsDirectoryW(LPCWSTR);
BOOL PathIsFileSpecA(LPCSTR);
BOOL PathIsFileSpecW(LPCWSTR);
BOOL PathIsLFNFileSpecA(LPCSTR);
BOOL PathIsLFNFileSpecW(LPCWSTR);
BOOL PathIsNetworkPathA(LPCSTR);
BOOL PathIsNetworkPathW(LPCWSTR);
BOOL PathIsPrefixA(LPCSTR,LPCSTR);
BOOL PathIsPrefixW(LPCWSTR,LPCWSTR);
BOOL PathIsRelativeA(LPCSTR);
BOOL PathIsRelativeW(LPCWSTR);
BOOL PathIsRootA(LPCSTR);
BOOL PathIsRootW(LPCWSTR);
BOOL PathIsSameRootA(LPCSTR,LPCSTR);
BOOL PathIsSameRootW(LPCWSTR,LPCWSTR);
BOOL PathIsSystemFolderA(LPCSTR,DWORD);
BOOL PathIsSystemFolderW(LPCWSTR,DWORD);
BOOL PathIsUNCA(LPCSTR);
BOOL PathIsUNCServerA(LPCSTR);
BOOL PathIsUNCServerShareA(LPCSTR);
BOOL PathIsUNCServerShareW(LPCWSTR);
BOOL PathIsUNCServerW(LPCWSTR);
BOOL PathIsUNCW(LPCWSTR);
BOOL PathIsURLA(LPCSTR);
BOOL PathIsURLW(LPCWSTR);
BOOL PathMakePrettyA(LPSTR);
BOOL PathMakePrettyW(LPWSTR);
BOOL PathMakeSystemFolderA(LPSTR);
BOOL PathMakeSystemFolderW(LPWSTR);
BOOL PathMatchSpecA(LPCSTR,LPCSTR);
BOOL PathMatchSpecW(LPCWSTR,LPCWSTR);
int PathParseIconLocationA(LPSTR);
int PathParseIconLocationW(LPWSTR);
void PathQuoteSpacesA(LPSTR);
void PathQuoteSpacesW(LPWSTR);
BOOL PathRelativePathToA(LPSTR,LPCSTR,DWORD,LPCSTR,DWORD);
BOOL PathRelativePathToW(LPWSTR,LPCWSTR,DWORD,LPCWSTR,DWORD);
void PathRemoveArgsA(LPSTR);
void PathRemoveArgsW(LPWSTR);
LPSTR PathRemoveBackslashA(LPSTR);
LPWSTR PathRemoveBackslashW(LPWSTR);
void PathRemoveBlanksA(LPSTR);
void PathRemoveBlanksW(LPWSTR);
void PathRemoveExtensionA(LPSTR);
void PathRemoveExtensionW(LPWSTR);
BOOL PathRemoveFileSpecA(LPSTR);
BOOL PathRemoveFileSpecW(LPWSTR);
BOOL PathRenameExtensionA(LPSTR,LPCSTR);
BOOL PathRenameExtensionW(LPWSTR,LPCWSTR);
BOOL PathSearchAndQualifyA(LPCSTR,LPSTR,UINT);
BOOL PathSearchAndQualifyW(LPCWSTR,LPWSTR,UINT);
void PathSetDlgItemPathA(HWND,int,LPCSTR);
void PathSetDlgItemPathW(HWND,int,LPCWSTR);
LPSTR PathSkipRootA(LPCSTR);
LPWSTR PathSkipRootW(LPCWSTR);
void PathStripPathA(LPSTR);
void PathStripPathW(LPWSTR);
BOOL PathStripToRootA(LPSTR);
BOOL PathStripToRootW(LPWSTR);
void PathUndecorateA(LPSTR);
void PathUndecorateW(LPWSTR);
BOOL PathUnExpandEnvStringsA(LPCSTR,LPSTR,UINT);
BOOL PathUnExpandEnvStringsW(LPCWSTR,LPWSTR,UINT);
BOOL PathUnmakeSystemFolderA(LPSTR);
BOOL PathUnmakeSystemFolderW(LPWSTR);
void PathUnquoteSpacesA(LPSTR);
void PathUnquoteSpacesW(LPWSTR);
HRESULT SHAutoComplete(HWND,DWORD);
BOOL SHCreateThread(LPTHREAD_START_ROUTINE,void*,DWORD,LPTHREAD_START_ROUTINE);
DWORD SHCopyKeyA(HKEY,LPCSTR,HKEY,DWORD);
DWORD SHCopyKeyW(HKEY,LPCWSTR,HKEY,DWORD);
DWORD SHDeleteEmptyKeyA(HKEY,LPCSTR);
DWORD SHDeleteEmptyKeyW(HKEY,LPCWSTR);
DWORD SHDeleteKeyA(HKEY,LPCSTR);
DWORD SHDeleteKeyW(HKEY,LPCWSTR);
DWORD SHEnumKeyExA(HKEY,DWORD,LPSTR,LPDWORD);
DWORD SHEnumKeyExW(HKEY,DWORD,LPWSTR,LPDWORD);
DWORD SHQueryInfoKeyA(HKEY,LPDWORD,LPDWORD,LPDWORD,LPDWORD);
DWORD SHQueryInfoKeyW(HKEY,LPDWORD,LPDWORD,LPDWORD,LPDWORD);
DWORD SHQueryValueExA(HKEY,LPCSTR,LPDWORD,LPDWORD,LPVOID,LPDWORD);
DWORD SHQueryValueExW(HKEY,LPCWSTR,LPDWORD,LPDWORD,LPVOID,LPDWORD);
HRESULT SHGetThreadRef(IUnknown**);
HRESULT SHSetThreadRef(IUnknown*);
BOOL SHSkipJunction(IBindCtx*, CPtr!(CLSID));
DWORD SHEnumValueA(HKEY,DWORD,LPSTR,LPDWORD,LPDWORD,LPVOID,LPDWORD);
DWORD SHEnumValueW(HKEY,DWORD,LPWSTR,LPDWORD,LPDWORD,LPVOID,LPDWORD);
DWORD SHGetValueA(HKEY,LPCSTR,LPCSTR,LPDWORD,LPVOID,LPDWORD);
DWORD SHGetValueW(HKEY,LPCWSTR,LPCWSTR,LPDWORD,LPVOID,LPDWORD);
DWORD SHSetValueA(HKEY,LPCSTR,LPCSTR,DWORD,LPCVOID,DWORD);
DWORD SHSetValueW(HKEY,LPCWSTR,LPCWSTR,DWORD,LPCVOID,DWORD);
DWORD SHDeleteValueA(HKEY,LPCSTR,LPCSTR);
DWORD SHDeleteValueW(HKEY,LPCWSTR,LPCWSTR);
HRESULT AssocCreate(CLSID, CPtr!(IID) ,CPtr!(LPVOID));
HRESULT AssocQueryKeyA(ASSOCF,ASSOCKEY,LPCSTR,LPCSTR,HKEY*);
HRESULT AssocQueryKeyW(ASSOCF,ASSOCKEY,LPCWSTR,LPCWSTR,HKEY*);
HRESULT AssocQueryStringA(ASSOCF,ASSOCSTR,LPCSTR,LPCSTR,LPSTR,DWORD*);
HRESULT AssocQueryStringByKeyA(ASSOCF,ASSOCSTR,HKEY,LPCSTR,LPSTR,DWORD*);
HRESULT AssocQueryStringByKeyW(ASSOCF,ASSOCSTR,HKEY,LPCWSTR,LPWSTR,DWORD*);
HRESULT AssocQueryStringW(ASSOCF,ASSOCSTR,LPCWSTR,LPCWSTR,LPWSTR,DWORD*);
HRESULT UrlApplySchemeA(LPCSTR,LPSTR,LPDWORD,DWORD);
HRESULT UrlApplySchemeW(LPCWSTR,LPWSTR,LPDWORD,DWORD);
HRESULT UrlCanonicalizeA(LPCSTR,LPSTR,LPDWORD,DWORD);
HRESULT UrlCanonicalizeW(LPCWSTR,LPWSTR,LPDWORD,DWORD);
HRESULT UrlCombineA(LPCSTR,LPCSTR,LPSTR,LPDWORD,DWORD);
HRESULT UrlCombineW(LPCWSTR,LPCWSTR,LPWSTR,LPDWORD,DWORD);
int UrlCompareA(LPCSTR,LPCSTR,BOOL);
int UrlCompareW(LPCWSTR,LPCWSTR,BOOL);
HRESULT UrlCreateFromPathA(LPCSTR,LPSTR,LPDWORD,DWORD);
HRESULT UrlCreateFromPathW(LPCWSTR,LPWSTR,LPDWORD,DWORD);
HRESULT UrlEscapeA(LPCSTR,LPSTR,LPDWORD,DWORD);
HRESULT UrlEscapeW(LPCWSTR,LPWSTR,LPDWORD,DWORD);
LPCSTR UrlGetLocationA(LPCSTR);
LPCWSTR UrlGetLocationW(LPCWSTR);
HRESULT UrlGetPartA(LPCSTR,LPSTR,LPDWORD,DWORD,DWORD);
HRESULT UrlGetPartW(LPCWSTR,LPWSTR,LPDWORD,DWORD,DWORD);
HRESULT UrlHashA(LPCSTR,LPBYTE,DWORD);
HRESULT UrlHashW(LPCWSTR,LPBYTE,DWORD);
BOOL UrlIsA(LPCSTR,URLIS);
BOOL UrlIsW(LPCWSTR,URLIS);
BOOL UrlIsNoHistoryA(LPCSTR);
BOOL UrlIsNoHistoryW(LPCWSTR);
BOOL UrlIsOpaqueA(LPCSTR);
BOOL UrlIsOpaqueW(LPCWSTR);
HRESULT UrlUnescapeA(LPSTR,LPSTR,LPDWORD,DWORD);
HRESULT UrlUnescapeW(LPWSTR,LPWSTR,LPDWORD,DWORD);
DWORD SHRegCloseUSKey(HUSKEY);
LONG SHRegCreateUSKeyA(LPCSTR,REGSAM,HUSKEY,PHUSKEY,DWORD);
LONG SHRegCreateUSKeyW(LPCWSTR,REGSAM,HUSKEY,PHUSKEY,DWORD);
LONG SHRegDeleteEmptyUSKeyA(HUSKEY,LPCSTR,SHREGDEL_FLAGS);
LONG SHRegDeleteEmptyUSKeyW(HUSKEY,LPCWSTR,SHREGDEL_FLAGS);
LONG SHRegDeleteUSValueA(HUSKEY,LPCSTR,SHREGDEL_FLAGS);
LONG SHRegDeleteUSValueW(HUSKEY,LPCWSTR,SHREGDEL_FLAGS);
HKEY SHRegDuplicateHKey(HKEY);
DWORD SHRegEnumUSKeyA(HUSKEY,DWORD,LPSTR,LPDWORD,SHREGENUM_FLAGS);
DWORD SHRegEnumUSKeyW(HUSKEY,DWORD,LPWSTR,LPDWORD,SHREGENUM_FLAGS);
DWORD SHRegEnumUSValueA(HUSKEY,DWORD,LPSTR,LPDWORD,LPDWORD,LPVOID,LPDWORD,SHREGENUM_FLAGS);
DWORD SHRegEnumUSValueW(HUSKEY,DWORD,LPWSTR,LPDWORD,LPDWORD,LPVOID,LPDWORD,SHREGENUM_FLAGS);
BOOL SHRegGetBoolUSValueA(LPCSTR,LPCSTR,BOOL,BOOL);
BOOL SHRegGetBoolUSValueW(LPCWSTR,LPCWSTR,BOOL,BOOL);
DWORD SHRegGetPathA(HKEY,LPCSTR,LPCSTR,LPSTR,DWORD);
DWORD SHRegGetPathW(HKEY,LPCWSTR,LPCWSTR,LPWSTR,DWORD);
LONG SHRegGetUSValueA(LPCSTR,LPCSTR,LPDWORD,LPVOID,LPDWORD,BOOL,LPVOID,DWORD);
LONG SHRegGetUSValueW(LPCWSTR,LPCWSTR,LPDWORD,LPVOID,LPDWORD,BOOL,LPVOID,DWORD);
LONG SHRegOpenUSKeyA(LPCSTR,REGSAM,HUSKEY,PHUSKEY,BOOL);
LONG SHRegOpenUSKeyW(LPCWSTR,REGSAM,HUSKEY,PHUSKEY,BOOL);
DWORD SHRegQueryInfoUSKeyA(HUSKEY,LPDWORD,LPDWORD,LPDWORD,LPDWORD,SHREGENUM_FLAGS);
DWORD SHRegQueryInfoUSKeyW(HUSKEY,LPDWORD,LPDWORD,LPDWORD,LPDWORD,SHREGENUM_FLAGS);
LONG SHRegQueryUSValueA(HUSKEY,LPCSTR,LPDWORD,LPVOID,LPDWORD,BOOL,LPVOID,DWORD);
LONG SHRegQueryUSValueW(HUSKEY,LPCWSTR,LPDWORD,LPVOID,LPDWORD,BOOL,LPVOID,DWORD);
DWORD SHRegSetPathA(HKEY,LPCSTR,LPCSTR,LPCSTR,DWORD);
DWORD SHRegSetPathW(HKEY,LPCWSTR,LPCWSTR,LPCWSTR,DWORD);
LONG SHRegSetUSValueA(LPCSTR,LPCSTR,DWORD,LPVOID,DWORD,DWORD);
LONG SHRegSetUSValueW(LPCWSTR,LPCWSTR,DWORD,LPVOID,DWORD,DWORD);
LONG SHRegWriteUSValueA(HUSKEY,LPCSTR,DWORD,LPVOID,DWORD,DWORD);
LONG SHRegWriteUSValueW(HUSKEY,LPCWSTR,DWORD,LPVOID,DWORD,DWORD);
HRESULT HashData(LPBYTE,DWORD,LPBYTE,DWORD);
HPALETTE SHCreateShellPalette(HDC);
COLORREF ColorHLSToRGB(WORD,WORD,WORD);
COLORREF ColorAdjustLuma(COLORREF,int,BOOL);
void ColorRGBToHLS(COLORREF,WORD*,WORD*,WORD*);
/** Should not be necessary for D?
extern (C):
int  wnsprintfA(LPSTR,int,LPCSTR,...);
int  wnsprintfW(LPWSTR,int,LPCWSTR,...);
extern (Windows):
int wvnsprintfA(LPSTR,int,LPCSTR,va_list);
int wvnsprintfW(LPWSTR,int,LPCWSTR,va_list);
*/

HINSTANCE MLLoadLibraryA(LPCSTR,HANDLE,DWORD,LPCSTR,BOOL);
HINSTANCE MLLoadLibraryW(LPCWSTR,HANDLE,DWORD,LPCWSTR,BOOL);

HRESULT DllInstall(BOOL,LPCWSTR);

HRESULT StrRetToBufA(LPSTRRET,LPCITEMIDLIST,LPSTR,UINT);
HRESULT StrRetToBufW(LPSTRRET,LPCITEMIDLIST,LPWSTR,UINT);
HRESULT StrRetToStrA(LPSTRRET,LPCITEMIDLIST,LPSTR*);
HRESULT StrRetToStrW(LPSTRRET,LPCITEMIDLIST,LPWSTR*);
HRESULT SHCreateStreamOnFileA(LPCSTR,DWORD,IStream**);
HRESULT SHCreateStreamOnFileW(LPCWSTR,DWORD,IStream**);
IStream* SHOpenRegStream2A(HKEY,LPCSTR,LPCSTR,DWORD);
IStream* SHOpenRegStream2W(HKEY,LPCWSTR,LPCWSTR,DWORD);
IStream* SHOpenRegStreamA(HKEY,LPCSTR,LPCSTR,DWORD);
IStream* SHOpenRegStreamW(HKEY,LPCWSTR,LPCWSTR,DWORD);

version(Unicode) {
alias ChrCmpIW ChrCmpI;
alias IntlStrEqNW IntlStrEqN;
alias IntlStrEqNIW IntlStrEqNI;
alias IntlStrEqWorkerW IntlStrEqWorker;
alias SHStrDupW SHStrDup;
alias StrCatW StrCat;
alias StrCatBuffW StrCatBuff;
alias StrChrW StrChr;
alias StrChrIW StrChrI;
alias StrCmpW StrCmp;
alias StrCmpIW StrCmpI;
alias StrCmpNIW StrCmpNI;
alias StrCmpNW StrCmpN;
alias StrCpyNW StrCpyN;
alias StrCpyW StrCpy;
alias StrCSpnIW StrCSpnI;
alias StrCSpnW StrCSpn;
alias StrDupW StrDup;
alias StrFormatByteSizeW StrFormatByteSize;
alias StrFormatKBSizeW StrFormatKBSize;
alias StrFromTimeIntervalW StrFromTimeInterval;
alias StrIsIntlEqualW StrIsIntlEqual;
alias StrNCatW StrNCat;
alias StrPBrkW StrPBrk;
alias StrRChrW StrRChr;
alias StrRChrIW StrRChrI;
alias StrRetToBufW StrRetToBuf;
alias StrRetToStrW StrRetToStr;
alias StrRStrIW StrRStrI;
alias StrSpnW StrSpn;
alias StrStrIW StrStrI;
alias StrStrW StrStr;
alias StrToIntW StrToInt;
alias StrToIntExW StrToIntEx;
alias StrTrimW StrTrim;
alias PathAddBackslashW PathAddBackslash;
alias PathAddExtensionW PathAddExtension;
alias PathAppendW PathAppend;
alias PathBuildRootW PathBuildRoot;
alias PathCanonicalizeW PathCanonicalize;
alias PathCombineW PathCombine;
alias PathCommonPrefixW PathCommonPrefix;
alias PathCompactPathW PathCompactPath;
alias PathCompactPathExW PathCompactPathEx;
alias PathCreateFromUrlW PathCreateFromUrl;
alias PathFileExistsW PathFileExists;
alias PathFindExtensionW PathFindExtension;
alias PathFindFileNameW PathFindFileName;
alias PathFindNextComponentW PathFindNextComponent;
alias PathFindOnPathW PathFindOnPath;
alias PathFindSuffixArrayW PathFindSuffixArray;
alias PathGetArgsW PathGetArgs;
alias PathGetCharTypeW PathGetCharType;
alias PathGetDriveNumberW PathGetDriveNumber;
alias PathIsContentTypeW PathIsContentType;
alias PathIsDirectoryEmptyW PathIsDirectoryEmpty;
alias PathIsDirectoryW PathIsDirectory;
alias PathIsFileSpecW PathIsFileSpec;
alias PathIsLFNFileSpecW PathIsLFNFileSpec;
alias PathIsNetworkPathW PathIsNetworkPath;
alias PathIsPrefixW PathIsPrefix;
alias PathIsRelativeW PathIsRelative;
alias PathIsRootW PathIsRoot;
alias PathIsSameRootW PathIsSameRoot;
alias PathIsSystemFolderW PathIsSystemFolder;
alias PathIsUNCServerShareW PathIsUNCServerShare;
alias PathIsUNCServerW PathIsUNCServer;
alias PathIsUNCW PathIsUNC;
alias PathIsURLW PathIsURL;
alias PathMakePrettyW PathMakePretty;
alias PathMakeSystemFolderW PathMakeSystemFolder;
alias PathMatchSpecW PathMatchSpec;
alias PathParseIconLocationW PathParseIconLocation;
alias PathQuoteSpacesW PathQuoteSpaces;
alias PathRelativePathToW PathRelativePathTo;
alias PathRemoveArgsW PathRemoveArgs;
alias PathRemoveBackslashW PathRemoveBackslash;
alias PathRemoveBlanksW PathRemoveBlanks;
alias PathRemoveExtensionW PathRemoveExtension;
alias PathRemoveFileSpecW PathRemoveFileSpec;
alias PathRenameExtensionW PathRenameExtension;
alias PathSearchAndQualifyW PathSearchAndQualify;
alias PathSetDlgItemPathW PathSetDlgItemPath;
alias PathSkipRootW PathSkipRoot;
alias PathStripPathW PathStripPath;
alias PathStripToRootW PathStripToRoot;
alias PathUndecorateW PathUndecorate;
alias PathUnExpandEnvStringsW PathUnExpandEnvStrings;
alias PathUnmakeSystemFolderW PathUnmakeSystemFolder;
alias PathUnquoteSpacesW PathUnquoteSpaces;
alias SHCreateStreamOnFileW SHCreateStreamOnFile;
alias SHOpenRegStreamW SHOpenRegStream;
alias SHOpenRegStream2W SHOpenRegStream2;
alias SHCopyKeyW SHCopyKey;
alias SHDeleteEmptyKeyW SHDeleteEmptyKey;
alias SHDeleteKeyW SHDeleteKey;
alias SHEnumKeyExW SHEnumKeyEx;
alias SHQueryInfoKeyW SHQueryInfoKey;
alias SHQueryValueExW SHQueryValueEx;
alias SHEnumValueW SHEnumValue;
alias SHGetValueW SHGetValue;
alias SHSetValueW SHSetValue;
alias SHDeleteValueW SHDeleteValue;
alias AssocQueryKeyW AssocQueryKey;
alias AssocQueryStringByKeyW AssocQueryStringByKey;
alias AssocQueryStringW AssocQueryString;
alias UrlApplySchemeW UrlApplyScheme;
alias UrlCanonicalizeW UrlCanonicalize;
alias UrlCombineW UrlCombine;
alias UrlCompareW UrlCompare;
alias UrlCreateFromPathW UrlCreateFromPath;
alias UrlEscapeW UrlEscape;
alias UrlGetLocationW UrlGetLocation;
alias UrlGetPartW UrlGetPart;
alias UrlHashW UrlHash;
alias UrlIsW UrlIs;
alias UrlIsFileUrlW UrlIsFileUrl;
alias UrlIsNoHistoryW UrlIsNoHistory;
alias UrlIsOpaqueW UrlIsOpaque;
alias UrlUnescapeW UrlUnescape;
alias UrlUnescapeInPlaceW UrlUnescapeInPlace;
alias SHRegCreateUSKeyW SHRegCreateUSKey;
alias SHRegDeleteEmptyUSKeyW SHRegDeleteEmptyUSKey;
alias SHRegDeleteUSValueW SHRegDeleteUSValue;
alias SHRegEnumUSKeyW SHRegEnumUSKey;
alias SHRegEnumUSValueW SHRegEnumUSValue;
alias SHRegGetBoolUSValueW SHRegGetBoolUSValue;
alias SHRegGetPathW SHRegGetPath;
alias SHRegGetUSValueW SHRegGetUSValue;
alias SHRegOpenUSKeyW SHRegOpenUSKey;
alias SHRegQueryInfoUSKeyW SHRegQueryInfoUSKey;
alias SHRegQueryUSValueW SHRegQueryUSValue;
alias SHRegSetPathW SHRegSetPath;
alias SHRegSetUSValueW SHRegSetUSValue;
alias SHRegWriteUSValueW SHRegWriteUSValue;
//alias wnsprintfW wnsprintf;
//alias wvnsprintfW wvnsprintf;
} else {
alias ChrCmpIA ChrCmpI;
alias IntlStrEqNA IntlStrEqN;
alias IntlStrEqNIA IntlStrEqNI;
alias IntlStrEqWorkerA IntlStrEqWorker;
alias SHStrDupA SHStrDup;
alias StrCatBuffA StrCatBuff;
alias StrChrA StrChr;
alias StrChrIA StrChrI;
alias StrCmpNIA StrCmpNI;
alias StrCmpNA StrCmpN;
alias StrCSpnIA StrCSpnI;
alias StrCSpnA StrCSpn;
alias StrDupA StrDup;
alias StrFormatByteSizeA StrFormatByteSize;
alias StrFormatKBSizeA StrFormatKBSize;
alias StrFromTimeIntervalA StrFromTimeInterval;
alias StrIsIntlEqualA StrIsIntlEqual;
alias StrNCatA StrNCat;
alias StrPBrkA StrPBrk;
alias StrRChrA StrRChr;
alias StrRChrIA StrRChrI;
alias StrRetToBufA StrRetToBuf;
alias StrRetToStrA StrRetToStr;
alias StrRStrIA StrRStrI;
alias StrSpnA StrSpn;
alias StrStrIA StrStrI;
alias StrStrA StrStr;
alias StrToIntA StrToInt;
alias StrToIntExA StrToIntEx;
alias StrTrimA StrTrim;
alias PathAddBackslashA PathAddBackslash;
alias PathAddExtensionA PathAddExtension;
alias PathAppendA PathAppend;
alias PathBuildRootA PathBuildRoot;
alias PathCanonicalizeA PathCanonicalize;
alias PathCombineA PathCombine;
alias PathCommonPrefixA PathCommonPrefix;
alias PathCompactPathA PathCompactPath;
alias PathCompactPathExA PathCompactPathEx;
alias PathCreateFromUrlA PathCreateFromUrl;
alias PathFileExistsA PathFileExists;
alias PathFindExtensionA PathFindExtension;
alias PathFindFileNameA PathFindFileName;
alias PathFindNextComponentA PathFindNextComponent;
alias PathFindOnPathA PathFindOnPath;
alias PathFindSuffixArrayA PathFindSuffixArray;
alias PathGetArgsA PathGetArgs;
alias PathGetCharTypeA PathGetCharType;
alias PathGetDriveNumberA PathGetDriveNumber;
alias PathIsContentTypeA PathIsContentType;
alias PathIsDirectoryEmptyA PathIsDirectoryEmpty;
alias PathIsDirectoryA PathIsDirectory;
alias PathIsFileSpecA PathIsFileSpec;
alias PathIsLFNFileSpecA PathIsLFNFileSpec;
alias PathIsNetworkPathA PathIsNetworkPath;
alias PathIsPrefixA PathIsPrefix;
alias PathIsRelativeA PathIsRelative;
alias PathIsRootA PathIsRoot;
alias PathIsSameRootA PathIsSameRoot;
alias PathIsSystemFolderA PathIsSystemFolder;
alias PathIsUNCServerShareA PathIsUNCServerShare;
alias PathIsUNCServerA PathIsUNCServer;
alias PathIsUNCA PathIsUNC;
alias PathIsURLA PathIsURL;
alias PathMakePrettyA PathMakePretty;
alias PathMakeSystemFolderA PathMakeSystemFolder;
alias PathMatchSpecA PathMatchSpec;
alias PathParseIconLocationA PathParseIconLocation;
alias PathQuoteSpacesA PathQuoteSpaces;
alias PathRelativePathToA PathRelativePathTo;
alias PathRemoveArgsA PathRemoveArgs;
alias PathRemoveBackslashA PathRemoveBackslash;
alias PathRemoveBlanksA PathRemoveBlanks;
alias PathRemoveExtensionA PathRemoveExtension;
alias PathRemoveFileSpecA PathRemoveFileSpec;
alias PathRenameExtensionA PathRenameExtension;
alias PathSearchAndQualifyA PathSearchAndQualify;
alias PathSetDlgItemPathA PathSetDlgItemPath;
alias PathSkipRootA PathSkipRoot;
alias PathStripPathA PathStripPath;
alias PathStripToRootA PathStripToRoot;
alias PathUndecorateA PathUndecorate;
alias PathUnExpandEnvStringsA PathUnExpandEnvStrings;
alias PathUnmakeSystemFolderA PathUnmakeSystemFolder;
alias PathUnquoteSpacesA PathUnquoteSpaces;
alias SHCreateStreamOnFileA SHCreateStreamOnFile;
alias SHOpenRegStreamA SHOpenRegStream;
alias SHOpenRegStream2A SHOpenRegStream2;
alias SHCopyKeyA SHCopyKey;
alias SHDeleteEmptyKeyA SHDeleteEmptyKey;
alias SHDeleteKeyA SHDeleteKey;
alias SHEnumKeyExA SHEnumKeyEx;
alias SHQueryInfoKeyA SHQueryInfoKey;
alias SHQueryValueExA SHQueryValueEx;
alias SHEnumValueA SHEnumValue;
alias SHGetValueA SHGetValue;
alias SHSetValueA SHSetValue;
alias SHDeleteValueA SHDeleteValue;
alias AssocQueryKeyA AssocQueryKey;
alias AssocQueryStringByKeyA AssocQueryStringByKey;
alias AssocQueryStringA AssocQueryString;
alias UrlApplySchemeA UrlApplyScheme;
alias UrlCanonicalizeA UrlCanonicalize;
alias UrlCombineA UrlCombine;
alias UrlCompareA UrlCompare;
alias UrlCreateFromPathA UrlCreateFromPath;
alias UrlEscapeA UrlEscape;
alias UrlGetLocationA UrlGetLocation;
alias UrlGetPartA UrlGetPart;
alias UrlHashA UrlHash;
alias UrlIsA UrlIs;
alias UrlIsNoHistoryA UrlIsNoHistory;
alias UrlIsOpaqueA UrlIsOpaque;
alias UrlUnescapeA UrlUnescape;
alias UrlUnescapeInPlaceA UrlUnescapeInPlace;
alias SHRegCreateUSKeyA SHRegCreateUSKey;
alias SHRegDeleteEmptyUSKeyA SHRegDeleteEmptyUSKey;
alias SHRegDeleteUSValueA SHRegDeleteUSValue;
alias SHRegEnumUSKeyA SHRegEnumUSKey;
alias SHRegEnumUSValueA SHRegEnumUSValue;
alias SHRegGetBoolUSValueA SHRegGetBoolUSValue;
alias SHRegGetPathA SHRegGetPath;
alias SHRegGetUSValueA SHRegGetUSValue;
alias SHRegOpenUSKeyA SHRegOpenUSKey;
alias SHRegQueryInfoUSKeyA SHRegQueryInfoUSKey;
alias SHRegQueryUSValueA SHRegQueryUSValue;
alias SHRegSetPathA SHRegSetPath;
alias SHRegSetUSValueA SHRegSetUSValue;
alias SHRegWriteUSValueA SHRegWriteUSValue;
//alias wnsprintfA wnsprintf;
//alias wvnsprintfA wvnsprintf;
}

alias StrToInt StrToLong;
