mirror of https://github.com/buggins/dlangui.git
731 lines
27 KiB
D
731 lines
27 KiB
D
/***********************************************************************\
|
|
* shlwapi.d *
|
|
* *
|
|
* Windows API header module *
|
|
* *
|
|
* Translated from MinGW Windows headers *
|
|
* *
|
|
* Placed into public domain *
|
|
\***********************************************************************/
|
|
module win32.shlwapi;
|
|
pragma(lib, "shlwapi");
|
|
|
|
/* 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
|
|
}
|
|
|
|
mixin DECLARE_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, const(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, const(IID)* , const(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;
|