core.sys.windows.shlwapi source code

1 /**
2  * Windows API header module
3  *
4  * Translated from MinGW Windows headers
5  *
6  * License: $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
7  * Source: $(DRUNTIMESRC core/sys/windows/_shlwapi.d)
8  */
9 module core.sys.windows.shlwapi;
10 version (Windows):
11 
12 version (ANSI) {} else version = Unicode;
13 pragma(lib, "shlwapi");
14 
15 /* Changes compared to MinGW:
16 wnsprintf functions are not included.
17 // Macros unneeded for D
18 #define StrCmpIA lstrcmpiA;
19 #define StrCmpA lstrcmpA;
20 #define StrCpyA lstrcpyA;
21 #define StrCpyNA lstrcpynA;
22 #define MAKEDLLVERULL(major, minor, build, qfe) \
23         (((ULONGLONG)(major) << 48) | \
24          ((ULONGLONG)(minor) << 32) | \
25          ((ULONGLONG)(build) << 16) | \
26          ((ULONGLONG)(  qfe) <<  0))
27 */
28 
29 import core.sys.windows.objbase, core.sys.windows.shlobj;
30 import core.sys.windows.basetyps, core.sys.windows.objidl, core.sys.windows.unknwn, core.sys.windows.windef,
31   core.sys.windows.winbase, core.sys.windows.winreg;
32 
33 enum DLLVER_PLATFORM_WINDOWS = 0x00000001;
34 enum DLLVER_PLATFORM_NT      = 0x00000002;
35 
36 enum URL_DONT_ESCAPE_EXTRA_INFO  = 0x02000000;
37 enum URL_DONT_SIMPLIFY           = 0x08000000;
38 enum URL_ESCAPE_PERCENT          = 0x00001000;
39 enum URL_ESCAPE_SEGMENT_ONLY     = 0x00002000;
40 enum URL_ESCAPE_SPACES_ONLY      = 0x04000000;
41 enum URL_ESCAPE_UNSAFE           = 0x20000000;
42 enum URL_INTERNAL_PATH           = 0x00800000;
43 enum URL_PARTFLAG_KEEPSCHEME     = 0x00000001;
44 enum URL_PLUGGABLE_PROTOCOL      = 0x40000000;
45 enum URL_UNESCAPE                = 0x10000000;
46 enum URL_UNESCAPE_HIGH_ANSI_ONLY = 0x00400000;
47 enum URL_UNESCAPE_INPLACE        = 0x00100000;
48 
49 align(1):
50 struct DLLVERSIONINFO
51 {
52     DWORD cbSize = this.sizeof;
53     DWORD dwMajorVersion;
54     DWORD dwMinorVersion;
55     DWORD dwBuildNumber;
56     DWORD dwPlatformID;
57 }
58 
59 struct DLLVERSIONINFO2
60 {
61     DLLVERSIONINFO info1;
62     DWORD dwFlags;
63     ULONGLONG ullVersion;
64 }
65 
66 enum ASSOCSTR {
67     ASSOCSTR_COMMAND,
68     ASSOCSTR_EXECUTABLE,
69     ASSOCSTR_FRIENDLYDOCNAME,
70     ASSOCSTR_FRIENDLYAPPNAME,
71     ASSOCSTR_NOOPEN,
72     ASSOCSTR_SHELLNEWVALUE,
73     ASSOCSTR_DDECOMMAND,
74     ASSOCSTR_DDEIFEXEC,
75     ASSOCSTR_DDEAPPLICATION,
76     ASSOCSTR_DDETOPIC
77 }
78 
79 enum ASSOCKEY
80 {
81     ASSOCKEY_SHELLEXECCLASS = 1,
82     ASSOCKEY_APP,
83     ASSOCKEY_CLASS,
84     ASSOCKEY_BASECLASS
85 }
86 
87 enum ASSOCDATA
88 {
89     ASSOCDATA_MSIDESCRIPTOR = 1,
90     ASSOCDATA_NOACTIVATEHANDLER,
91     ASSOCDATA_QUERYCLASSSTORE
92 }
93 
94 alias DWORD ASSOCF;
95 
96 enum SHREGDEL_FLAGS
97 {
98     SHREGDEL_DEFAULT = 0x00000000,
99     SHREGDEL_HKCU    = 0x00000001,
100     SHREGDEL_HKLM    = 0x00000010,
101     SHREGDEL_BOTH    = 0x00000011
102 }
103 
104 enum SHREGENUM_FLAGS
105 {
106     SHREGENUM_DEFAULT = 0x00000000,
107     SHREGENUM_HKCU    = 0x00000001,
108     SHREGENUM_HKLM    = 0x00000010,
109     SHREGENUM_BOTH    = 0x00000011
110 }
111 
112 enum URLIS
113 {
114     URLIS_URL,
115     URLIS_OPAQUE,
116     URLIS_NOHISTORY,
117     URLIS_FILEURL,
118     URLIS_APPLIABLE,
119     URLIS_DIRECTORY,
120     URLIS_HASQUERY
121 }
122 
123 mixin DECLARE_HANDLE!("HUSKEY");
124 alias HUSKEY* PHUSKEY;
125 
126 extern (Windows)
127 {
128     alias HRESULT function (DLLVERSIONINFO *) DLLGETVERSIONPROC;
129 }
130 
131 
132 BOOL IntlStrEqNA(LPCSTR pStr1, LPCSTR pStr2, int nChar)
133 {
134     return IntlStrEqWorkerA(TRUE, pStr1, pStr2, nChar);
135 }
136 
137 BOOL IntlStrEqNW(LPCWSTR pStr1, LPCWSTR pStr2, int nChar)
138 {
139     return IntlStrEqWorkerW(TRUE, pStr1, pStr2, nChar);
140 }
141 
142 BOOL IntlStrEqNIA(LPCSTR pStr1, LPCSTR pStr2, int nChar)
143 {
144     return IntlStrEqWorkerA(FALSE, pStr1, pStr2, nChar);
145 }
146 
147 BOOL IntlStrEqNIW(LPCWSTR pStr1, LPCWSTR pStr2, int nChar)
148 {
149     return IntlStrEqWorkerW(FALSE, pStr1, pStr2, nChar);
150 }
151 
152 BOOL UrlIsFileUrlA(LPCSTR pszURL)
153 {
154     return UrlIsA(pszURL, URLIS.URLIS_FILEURL);
155 }
156 
157 BOOL UrlIsFileUrlW(LPCWSTR pszURL)
158 {
159     return UrlIsW(pszURL, URLIS.URLIS_FILEURL);
160 }
161 
162 HRESULT UrlUnescapeInPlaceA(LPSTR pszUrl, DWORD dwFlags)
163 {
164     return UrlUnescapeA(pszUrl, null, null, dwFlags | URL_UNESCAPE_INPLACE);
165 }
166 HRESULT UrlUnescapeInPlaceW(LPWSTR pszUrl, DWORD dwFlags)
167 {
168     return UrlUnescapeW(pszUrl, null, null, dwFlags | URL_UNESCAPE_INPLACE);
169 }
170 
171 extern (Windows):
172 BOOL ChrCmpIA(WORD, WORD);
173 BOOL ChrCmpIW(WCHAR, WCHAR);
174 BOOL IntlStrEqWorkerA(BOOL, LPCSTR, LPCSTR, int);
175 BOOL IntlStrEqWorkerW(BOOL, LPCWSTR, LPCWSTR, int);
176 HRESULT SHStrDupA(LPCSTR, LPWSTR*);
177 HRESULT SHStrDupW(LPCWSTR, LPWSTR*);
178 LPSTR StrCatA(LPSTR, LPCSTR);
179 LPWSTR StrCatW(LPWSTR, LPCWSTR);
180 LPSTR StrCatBuffA(LPSTR, LPCSTR, int);
181 LPWSTR StrCatBuffW(LPWSTR, LPCWSTR, int);
182 DWORD StrCatChainW(LPWSTR, DWORD, DWORD, LPCWSTR);
183 LPSTR StrChrA(LPCSTR, WORD);
184 LPWSTR StrChrW(LPCWSTR, WCHAR);
185 LPSTR StrChrIA(LPCSTR, WORD);
186 LPWSTR StrChrIW(LPCWSTR, WCHAR);
187 int StrCmpIW(LPCWSTR, LPCWSTR);
188 int StrCmpW(LPCWSTR, LPCWSTR);
189 LPWSTR StrCpyW(LPWSTR, LPCWSTR);
190 LPWSTR StrCpyNW(LPWSTR, LPCWSTR, int);
191 int StrCmpNA(LPCSTR, LPCSTR, int);
192 int StrCmpNW(LPCWSTR, LPCWSTR, int);
193 int StrCmpNIA(LPCSTR, LPCSTR, int);
194 int StrCmpNIW(LPCWSTR, LPCWSTR, int);
195 int StrCSpnA(LPCSTR, LPCSTR);
196 int StrCSpnW(LPCWSTR, LPCWSTR);
197 int StrCSpnIA(LPCSTR, LPCSTR);
198 int StrCSpnIW(LPCWSTR, LPCWSTR);
199 LPSTR StrDupA(LPCSTR);
200 LPWSTR StrDupW(LPCWSTR);
201 LPSTR StrFormatByteSize64A(LONGLONG, LPSTR, UINT);
202 LPSTR StrFormatByteSizeA(DWORD, LPSTR, UINT);
203 LPWSTR StrFormatByteSizeW(LONGLONG, LPWSTR, UINT);
204 LPSTR StrFormatKBSizeA(LONGLONG, LPSTR, UINT);
205 LPWSTR StrFormatKBSizeW(LONGLONG, LPWSTR, UINT);
206 int StrFromTimeIntervalA(LPSTR, UINT, DWORD, int);
207 int StrFromTimeIntervalW(LPWSTR, UINT, DWORD, int);
208 BOOL StrIsIntlEqualA(BOOL, LPCSTR, LPCSTR, int);
209 BOOL StrIsIntlEqualW(BOOL, LPCWSTR, LPCWSTR, int);
210 LPSTR StrNCatA(LPSTR, LPCSTR, int);
211 LPWSTR StrNCatW(LPWSTR, LPCWSTR, int);
212 LPSTR StrPBrkA(LPCSTR, LPCSTR);
213 LPWSTR StrPBrkW(LPCWSTR, LPCWSTR);
214 LPSTR StrRChrA(LPCSTR, LPCSTR, WORD);
215 LPWSTR StrRChrW(LPCWSTR, LPCWSTR, WCHAR);
216 LPSTR StrRChrIA(LPCSTR, LPCSTR, WORD);
217 LPWSTR StrRChrIW(LPCWSTR, LPCWSTR, WCHAR);
218 LPSTR StrRStrIA(LPCSTR, LPCSTR, LPCSTR);
219 LPWSTR StrRStrIW(LPCWSTR, LPCWSTR, LPCWSTR);
220 int StrSpnA(LPCSTR, LPCSTR);
221 int StrSpnW(LPCWSTR, LPCWSTR);
222 LPSTR StrStrA(LPCSTR, LPCSTR);
223 LPSTR StrStrIA(LPCSTR, LPCSTR);
224 LPWSTR StrStrIW(LPCWSTR, LPCWSTR);
225 LPWSTR StrStrW(LPCWSTR, LPCWSTR);
226 int StrToIntA(LPCSTR);
227 int StrToIntW(LPCWSTR);
228 BOOL StrToIntExA(LPCSTR, DWORD, int*);
229 BOOL StrToIntExW(LPCWSTR, DWORD, int*);
230 BOOL StrTrimA(LPSTR, LPCSTR);
231 BOOL StrTrimW(LPWSTR, LPCWSTR);
232 LPSTR PathAddBackslashA(LPSTR);
233 LPWSTR PathAddBackslashW(LPWSTR);
234 BOOL PathAddExtensionA(LPSTR, LPCSTR);
235 BOOL PathAddExtensionW(LPWSTR, LPCWSTR);
236 BOOL PathAppendA(LPSTR, LPCSTR);
237 BOOL PathAppendW(LPWSTR, LPCWSTR);
238 LPSTR PathBuildRootA(LPSTR, int);
239 LPWSTR PathBuildRootW(LPWSTR, int);
240 BOOL PathCanonicalizeA(LPSTR, LPCSTR);
241 BOOL PathCanonicalizeW(LPWSTR, LPCWSTR);
242 LPSTR PathCombineA(LPSTR, LPCSTR, LPCSTR);
243 LPWSTR PathCombineW(LPWSTR, LPCWSTR, LPCWSTR);
244 int PathCommonPrefixA(LPCSTR, LPCSTR, LPSTR);
245 int PathCommonPrefixW(LPCWSTR, LPCWSTR, LPWSTR);
246 BOOL PathCompactPathA(HDC, LPSTR, UINT);
247 BOOL PathCompactPathW(HDC, LPWSTR, UINT);
248 BOOL PathCompactPathExA(LPSTR, LPCSTR, UINT, DWORD);
249 BOOL PathCompactPathExW(LPWSTR, LPCWSTR, UINT, DWORD);
250 HRESULT PathCreateFromUrlA(LPCSTR, LPSTR, LPDWORD, DWORD);
251 HRESULT PathCreateFromUrlW(LPCWSTR, LPWSTR, LPDWORD, DWORD);
252 BOOL PathFileExistsA(LPCSTR);
253 BOOL PathFileExistsW(LPCWSTR);
254 LPSTR PathFindExtensionA(LPCSTR);
255 LPWSTR PathFindExtensionW(LPCWSTR);
256 LPSTR PathFindFileNameA(LPCSTR);
257 LPWSTR PathFindFileNameW(LPCWSTR);
258 LPSTR PathFindNextComponentA(LPCSTR);
259 LPWSTR PathFindNextComponentW(LPCWSTR);
260 BOOL PathFindOnPathA(LPSTR, LPCSTR*);
261 BOOL PathFindOnPathW(LPWSTR, LPCWSTR*);
262 LPCSTR PathFindSuffixArrayA(LPCSTR, LPCSTR*, int);
263 LPCWSTR PathFindSuffixArrayW(LPCWSTR, LPCWSTR*, int);
264 LPSTR PathGetArgsA(LPCSTR);
265 LPWSTR PathGetArgsW(LPCWSTR);
266 UINT PathGetCharTypeA(UCHAR);
267 UINT PathGetCharTypeW(WCHAR);
268 int PathGetDriveNumberA(LPCSTR);
269 int PathGetDriveNumberW(LPCWSTR);
270 BOOL PathIsContentTypeA(LPCSTR, LPCSTR);
271 BOOL PathIsContentTypeW(LPCWSTR, LPCWSTR);
272 BOOL PathIsDirectoryA(LPCSTR);
273 BOOL PathIsDirectoryEmptyA(LPCSTR);
274 BOOL PathIsDirectoryEmptyW(LPCWSTR);
275 BOOL PathIsDirectoryW(LPCWSTR);
276 BOOL PathIsFileSpecA(LPCSTR);
277 BOOL PathIsFileSpecW(LPCWSTR);
278 BOOL PathIsLFNFileSpecA(LPCSTR);
279 BOOL PathIsLFNFileSpecW(LPCWSTR);
280 BOOL PathIsNetworkPathA(LPCSTR);
281 BOOL PathIsNetworkPathW(LPCWSTR);
282 BOOL PathIsPrefixA(LPCSTR, LPCSTR);
283 BOOL PathIsPrefixW(LPCWSTR, LPCWSTR);
284 BOOL PathIsRelativeA(LPCSTR);
285 BOOL PathIsRelativeW(LPCWSTR);
286 BOOL PathIsRootA(LPCSTR);
287 BOOL PathIsRootW(LPCWSTR);
288 BOOL PathIsSameRootA(LPCSTR, LPCSTR);
289 BOOL PathIsSameRootW(LPCWSTR, LPCWSTR);
290 BOOL PathIsSystemFolderA(LPCSTR, DWORD);
291 BOOL PathIsSystemFolderW(LPCWSTR, DWORD);
292 BOOL PathIsUNCA(LPCSTR);
293 BOOL PathIsUNCServerA(LPCSTR);
294 BOOL PathIsUNCServerShareA(LPCSTR);
295 BOOL PathIsUNCServerShareW(LPCWSTR);
296 BOOL PathIsUNCServerW(LPCWSTR);
297 BOOL PathIsUNCW(LPCWSTR);
298 BOOL PathIsURLA(LPCSTR);
299 BOOL PathIsURLW(LPCWSTR);
300 BOOL PathMakePrettyA(LPSTR);
301 BOOL PathMakePrettyW(LPWSTR);
302 BOOL PathMakeSystemFolderA(LPSTR);
303 BOOL PathMakeSystemFolderW(LPWSTR);
304 BOOL PathMatchSpecA(LPCSTR, LPCSTR);
305 BOOL PathMatchSpecW(LPCWSTR, LPCWSTR);
306 int PathParseIconLocationA(LPSTR);
307 int PathParseIconLocationW(LPWSTR);
308 void PathQuoteSpacesA(LPSTR);
309 void PathQuoteSpacesW(LPWSTR);
310 BOOL PathRelativePathToA(LPSTR, LPCSTR, DWORD, LPCSTR, DWORD);
311 BOOL PathRelativePathToW(LPWSTR, LPCWSTR, DWORD, LPCWSTR, DWORD);
312 void PathRemoveArgsA(LPSTR);
313 void PathRemoveArgsW(LPWSTR);
314 LPSTR PathRemoveBackslashA(LPSTR);
315 LPWSTR PathRemoveBackslashW(LPWSTR);
316 void PathRemoveBlanksA(LPSTR);
317 void PathRemoveBlanksW(LPWSTR);
318 void PathRemoveExtensionA(LPSTR);
319 void PathRemoveExtensionW(LPWSTR);
320 BOOL PathRemoveFileSpecA(LPSTR);
321 BOOL PathRemoveFileSpecW(LPWSTR);
322 BOOL PathRenameExtensionA(LPSTR, LPCSTR);
323 BOOL PathRenameExtensionW(LPWSTR, LPCWSTR);
324 BOOL PathSearchAndQualifyA(LPCSTR, LPSTR, UINT);
325 BOOL PathSearchAndQualifyW(LPCWSTR, LPWSTR, UINT);
326 void PathSetDlgItemPathA(HWND, int, LPCSTR);
327 void PathSetDlgItemPathW(HWND, int, LPCWSTR);
328 LPSTR PathSkipRootA(LPCSTR);
329 LPWSTR PathSkipRootW(LPCWSTR);
330 void PathStripPathA(LPSTR);
331 void PathStripPathW(LPWSTR);
332 BOOL PathStripToRootA(LPSTR);
333 BOOL PathStripToRootW(LPWSTR);
334 void PathUndecorateA(LPSTR);
335 void PathUndecorateW(LPWSTR);
336 BOOL PathUnExpandEnvStringsA(LPCSTR, LPSTR, UINT);
337 BOOL PathUnExpandEnvStringsW(LPCWSTR, LPWSTR, UINT);
338 BOOL PathUnmakeSystemFolderA(LPSTR);
339 BOOL PathUnmakeSystemFolderW(LPWSTR);
340 void PathUnquoteSpacesA(LPSTR);
341 void PathUnquoteSpacesW(LPWSTR);
342 HRESULT SHAutoComplete(HWND, DWORD);
343 BOOL SHCreateThread(LPTHREAD_START_ROUTINE, void*, DWORD, LPTHREAD_START_ROUTINE);
344 DWORD SHCopyKeyA(HKEY, LPCSTR, HKEY, DWORD);
345 DWORD SHCopyKeyW(HKEY, LPCWSTR, HKEY, DWORD);
346 DWORD SHDeleteEmptyKeyA(HKEY, LPCSTR);
347 DWORD SHDeleteEmptyKeyW(HKEY, LPCWSTR);
348 DWORD SHDeleteKeyA(HKEY, LPCSTR);
349 DWORD SHDeleteKeyW(HKEY, LPCWSTR);
350 DWORD SHEnumKeyExA(HKEY, DWORD, LPSTR, LPDWORD);
351 DWORD SHEnumKeyExW(HKEY, DWORD, LPWSTR, LPDWORD);
352 DWORD SHQueryInfoKeyA(HKEY, LPDWORD, LPDWORD, LPDWORD, LPDWORD);
353 DWORD SHQueryInfoKeyW(HKEY, LPDWORD, LPDWORD, LPDWORD, LPDWORD);
354 DWORD SHQueryValueExA(HKEY, LPCSTR, LPDWORD, LPDWORD, LPVOID, LPDWORD);
355 DWORD SHQueryValueExW(HKEY, LPCWSTR, LPDWORD, LPDWORD, LPVOID, LPDWORD);
356 HRESULT SHGetThreadRef(IUnknown*);
357 HRESULT SHSetThreadRef(IUnknown);
358 BOOL SHSkipJunction(IBindCtx, const(CLSID)*);
359 DWORD SHEnumValueA(HKEY, DWORD, LPSTR, LPDWORD, LPDWORD, LPVOID, LPDWORD);
360 DWORD SHEnumValueW(HKEY, DWORD, LPWSTR, LPDWORD, LPDWORD, LPVOID, LPDWORD);
361 DWORD SHGetValueA(HKEY, LPCSTR, LPCSTR, LPDWORD, LPVOID, LPDWORD);
362 DWORD SHGetValueW(HKEY, LPCWSTR, LPCWSTR, LPDWORD, LPVOID, LPDWORD);
363 DWORD SHSetValueA(HKEY, LPCSTR, LPCSTR, DWORD, LPCVOID, DWORD);
364 DWORD SHSetValueW(HKEY, LPCWSTR, LPCWSTR, DWORD, LPCVOID, DWORD);
365 DWORD SHDeleteValueA(HKEY, LPCSTR, LPCSTR);
366 DWORD SHDeleteValueW(HKEY, LPCWSTR, LPCWSTR);
367 HRESULT AssocCreate(CLSID, const(IID)* , const(LPVOID)*);
368 HRESULT AssocQueryKeyA(ASSOCF, ASSOCKEY, LPCSTR, LPCSTR, HKEY*);
369 HRESULT AssocQueryKeyW(ASSOCF, ASSOCKEY, LPCWSTR, LPCWSTR, HKEY*);
370 HRESULT AssocQueryStringA(ASSOCF, ASSOCSTR, LPCSTR, LPCSTR, LPSTR, DWORD*);
371 HRESULT AssocQueryStringByKeyA(ASSOCF, ASSOCSTR, HKEY, LPCSTR, LPSTR, DWORD*);
372 HRESULT AssocQueryStringByKeyW(ASSOCF, ASSOCSTR, HKEY, LPCWSTR, LPWSTR, DWORD*);
373 HRESULT AssocQueryStringW(ASSOCF, ASSOCSTR, LPCWSTR, LPCWSTR, LPWSTR, DWORD*);
374 HRESULT UrlApplySchemeA(LPCSTR, LPSTR, LPDWORD, DWORD);
375 HRESULT UrlApplySchemeW(LPCWSTR, LPWSTR, LPDWORD, DWORD);
376 HRESULT UrlCanonicalizeA(LPCSTR, LPSTR, LPDWORD, DWORD);
377 HRESULT UrlCanonicalizeW(LPCWSTR, LPWSTR, LPDWORD, DWORD);
378 HRESULT UrlCombineA(LPCSTR, LPCSTR, LPSTR, LPDWORD, DWORD);
379 HRESULT UrlCombineW(LPCWSTR, LPCWSTR, LPWSTR, LPDWORD, DWORD);
380 int UrlCompareA(LPCSTR, LPCSTR, BOOL);
381 int UrlCompareW(LPCWSTR, LPCWSTR, BOOL);
382 HRESULT UrlCreateFromPathA(LPCSTR, LPSTR, LPDWORD, DWORD);
383 HRESULT UrlCreateFromPathW(LPCWSTR, LPWSTR, LPDWORD, DWORD);
384 HRESULT UrlEscapeA(LPCSTR, LPSTR, LPDWORD, DWORD);
385 HRESULT UrlEscapeW(LPCWSTR, LPWSTR, LPDWORD, DWORD);
386 LPCSTR UrlGetLocationA(LPCSTR);
387 LPCWSTR UrlGetLocationW(LPCWSTR);
388 HRESULT UrlGetPartA(LPCSTR, LPSTR, LPDWORD, DWORD, DWORD);
389 HRESULT UrlGetPartW(LPCWSTR, LPWSTR, LPDWORD, DWORD, DWORD);
390 HRESULT UrlHashA(LPCSTR, LPBYTE, DWORD);
391 HRESULT UrlHashW(LPCWSTR, LPBYTE, DWORD);
392 BOOL UrlIsA(LPCSTR, URLIS);
393 BOOL UrlIsW(LPCWSTR, URLIS);
394 BOOL UrlIsNoHistoryA(LPCSTR);
395 BOOL UrlIsNoHistoryW(LPCWSTR);
396 BOOL UrlIsOpaqueA(LPCSTR);
397 BOOL UrlIsOpaqueW(LPCWSTR);
398 HRESULT UrlUnescapeA(LPSTR, LPSTR, LPDWORD, DWORD);
399 HRESULT UrlUnescapeW(LPWSTR, LPWSTR, LPDWORD, DWORD);
400 DWORD SHRegCloseUSKey(HUSKEY);
401 LONG SHRegCreateUSKeyA(LPCSTR, REGSAM, HUSKEY, PHUSKEY, DWORD);
402 LONG SHRegCreateUSKeyW(LPCWSTR, REGSAM, HUSKEY, PHUSKEY, DWORD);
403 LONG SHRegDeleteEmptyUSKeyA(HUSKEY, LPCSTR, SHREGDEL_FLAGS);
404 LONG SHRegDeleteEmptyUSKeyW(HUSKEY, LPCWSTR, SHREGDEL_FLAGS);
405 LONG SHRegDeleteUSValueA(HUSKEY, LPCSTR, SHREGDEL_FLAGS);
406 LONG SHRegDeleteUSValueW(HUSKEY, LPCWSTR, SHREGDEL_FLAGS);
407 HKEY SHRegDuplicateHKey(HKEY);
408 DWORD SHRegEnumUSKeyA(HUSKEY, DWORD, LPSTR, LPDWORD, SHREGENUM_FLAGS);
409 DWORD SHRegEnumUSKeyW(HUSKEY, DWORD, LPWSTR, LPDWORD, SHREGENUM_FLAGS);
410 DWORD SHRegEnumUSValueA(HUSKEY, DWORD, LPSTR, LPDWORD, LPDWORD, LPVOID, LPDWORD, SHREGENUM_FLAGS);
411 DWORD SHRegEnumUSValueW(HUSKEY, DWORD, LPWSTR, LPDWORD, LPDWORD, LPVOID, LPDWORD, SHREGENUM_FLAGS);
412 BOOL SHRegGetBoolUSValueA(LPCSTR, LPCSTR, BOOL, BOOL);
413 BOOL SHRegGetBoolUSValueW(LPCWSTR, LPCWSTR, BOOL, BOOL);
414 DWORD SHRegGetPathA(HKEY, LPCSTR, LPCSTR, LPSTR, DWORD);
415 DWORD SHRegGetPathW(HKEY, LPCWSTR, LPCWSTR, LPWSTR, DWORD);
416 LONG SHRegGetUSValueA(LPCSTR, LPCSTR, LPDWORD, LPVOID, LPDWORD, BOOL, LPVOID, DWORD);
417 LONG SHRegGetUSValueW(LPCWSTR, LPCWSTR, LPDWORD, LPVOID, LPDWORD, BOOL, LPVOID, DWORD);
418 LONG SHRegOpenUSKeyA(LPCSTR, REGSAM, HUSKEY, PHUSKEY, BOOL);
419 LONG SHRegOpenUSKeyW(LPCWSTR, REGSAM, HUSKEY, PHUSKEY, BOOL);
420 DWORD SHRegQueryInfoUSKeyA(HUSKEY, LPDWORD, LPDWORD, LPDWORD, LPDWORD, SHREGENUM_FLAGS);
421 DWORD SHRegQueryInfoUSKeyW(HUSKEY, LPDWORD, LPDWORD, LPDWORD, LPDWORD, SHREGENUM_FLAGS);
422 LONG SHRegQueryUSValueA(HUSKEY, LPCSTR, LPDWORD, LPVOID, LPDWORD, BOOL, LPVOID, DWORD);
423 LONG SHRegQueryUSValueW(HUSKEY, LPCWSTR, LPDWORD, LPVOID, LPDWORD, BOOL, LPVOID, DWORD);
424 DWORD SHRegSetPathA(HKEY, LPCSTR, LPCSTR, LPCSTR, DWORD);
425 DWORD SHRegSetPathW(HKEY, LPCWSTR, LPCWSTR, LPCWSTR, DWORD);
426 LONG SHRegSetUSValueA(LPCSTR, LPCSTR, DWORD, LPVOID, DWORD, DWORD);
427 LONG SHRegSetUSValueW(LPCWSTR, LPCWSTR, DWORD, LPVOID, DWORD, DWORD);
428 LONG SHRegWriteUSValueA(HUSKEY, LPCSTR, DWORD, LPVOID, DWORD, DWORD);
429 LONG SHRegWriteUSValueW(HUSKEY, LPCWSTR, DWORD, LPVOID, DWORD, DWORD);
430 HRESULT HashData(LPBYTE, DWORD, LPBYTE, DWORD);
431 HPALETTE SHCreateShellPalette(HDC);
432 COLORREF ColorHLSToRGB(WORD, WORD, WORD);
433 COLORREF ColorAdjustLuma(COLORREF, int, BOOL);
434 void ColorRGBToHLS(COLORREF, WORD*, WORD*, WORD*);
435 /** Should not be necessary for D?
436 extern (C):
437 int  wnsprintfA(LPSTR, int, LPCSTR, ...);
438 int  wnsprintfW(LPWSTR, int, LPCWSTR, ...);
439 extern (Windows):
440 int wvnsprintfA(LPSTR, int, LPCSTR, va_list);
441 int wvnsprintfW(LPWSTR, int, LPCWSTR, va_list);
442 */
443 
444 HINSTANCE MLLoadLibraryA(LPCSTR, HANDLE, DWORD, LPCSTR, BOOL);
445 HINSTANCE MLLoadLibraryW(LPCWSTR, HANDLE, DWORD, LPCWSTR, BOOL);
446 
447 HRESULT DllInstall(BOOL, LPCWSTR);
448 
449 HRESULT StrRetToBufA(LPSTRRET, LPCITEMIDLIST, LPSTR, UINT);
450 HRESULT StrRetToBufW(LPSTRRET, LPCITEMIDLIST, LPWSTR, UINT);
451 HRESULT StrRetToStrA(LPSTRRET, LPCITEMIDLIST, LPSTR*);
452 HRESULT StrRetToStrW(LPSTRRET, LPCITEMIDLIST, LPWSTR*);
453 HRESULT SHCreateStreamOnFileA(LPCSTR, DWORD, IStream*);
454 HRESULT SHCreateStreamOnFileW(LPCWSTR, DWORD, IStream*);
455 IStream SHOpenRegStream2A(HKEY, LPCSTR, LPCSTR, DWORD);
456 IStream SHOpenRegStream2W(HKEY, LPCWSTR, LPCWSTR, DWORD);
457 IStream SHOpenRegStreamA(HKEY, LPCSTR, LPCSTR, DWORD);
458 IStream SHOpenRegStreamW(HKEY, LPCWSTR, LPCWSTR, DWORD);
459 
460 version (Unicode) {
461 alias ChrCmpIW ChrCmpI;
462 alias IntlStrEqNW IntlStrEqN;
463 alias IntlStrEqNIW IntlStrEqNI;
464 alias IntlStrEqWorkerW IntlStrEqWorker;
465 alias SHStrDupW SHStrDup;
466 alias StrCatW StrCat;
467 alias StrCatBuffW StrCatBuff;
468 alias StrChrW StrChr;
469 alias StrChrIW StrChrI;
470 alias StrCmpW StrCmp;
471 alias StrCmpIW StrCmpI;
472 alias StrCmpNIW StrCmpNI;
473 alias StrCmpNW StrCmpN;
474 alias StrCpyNW StrCpyN;
475 alias StrCpyW StrCpy;
476 alias StrCSpnIW StrCSpnI;
477 alias StrCSpnW StrCSpn;
478 alias StrDupW StrDup;
479 alias StrFormatByteSizeW StrFormatByteSize;
480 alias StrFormatKBSizeW StrFormatKBSize;
481 alias StrFromTimeIntervalW StrFromTimeInterval;
482 alias StrIsIntlEqualW StrIsIntlEqual;
483 alias StrNCatW StrNCat;
484 alias StrPBrkW StrPBrk;
485 alias StrRChrW StrRChr;
486 alias StrRChrIW StrRChrI;
487 alias StrRetToBufW StrRetToBuf;
488 alias StrRetToStrW StrRetToStr;
489 alias StrRStrIW StrRStrI;
490 alias StrSpnW StrSpn;
491 alias StrStrIW StrStrI;
492 alias StrStrW StrStr;
493 alias StrToIntW StrToInt;
494 alias StrToIntExW StrToIntEx;
495 alias StrTrimW StrTrim;
496 alias PathAddBackslashW PathAddBackslash;
497 alias PathAddExtensionW PathAddExtension;
498 alias PathAppendW PathAppend;
499 alias PathBuildRootW PathBuildRoot;
500 alias PathCanonicalizeW PathCanonicalize;
501 alias PathCombineW PathCombine;
502 alias PathCommonPrefixW PathCommonPrefix;
503 alias PathCompactPathW PathCompactPath;
504 alias PathCompactPathExW PathCompactPathEx;
505 alias PathCreateFromUrlW PathCreateFromUrl;
506 alias PathFileExistsW PathFileExists;
507 alias PathFindExtensionW PathFindExtension;
508 alias PathFindFileNameW PathFindFileName;
509 alias PathFindNextComponentW PathFindNextComponent;
510 alias PathFindOnPathW PathFindOnPath;
511 alias PathFindSuffixArrayW PathFindSuffixArray;
512 alias PathGetArgsW PathGetArgs;
513 alias PathGetCharTypeW PathGetCharType;
514 alias PathGetDriveNumberW PathGetDriveNumber;
515 alias PathIsContentTypeW PathIsContentType;
516 alias PathIsDirectoryEmptyW PathIsDirectoryEmpty;
517 alias PathIsDirectoryW PathIsDirectory;
518 alias PathIsFileSpecW PathIsFileSpec;
519 alias PathIsLFNFileSpecW PathIsLFNFileSpec;
520 alias PathIsNetworkPathW PathIsNetworkPath;
521 alias PathIsPrefixW PathIsPrefix;
522 alias PathIsRelativeW PathIsRelative;
523 alias PathIsRootW PathIsRoot;
524 alias PathIsSameRootW PathIsSameRoot;
525 alias PathIsSystemFolderW PathIsSystemFolder;
526 alias PathIsUNCServerShareW PathIsUNCServerShare;
527 alias PathIsUNCServerW PathIsUNCServer;
528 alias PathIsUNCW PathIsUNC;
529 alias PathIsURLW PathIsURL;
530 alias PathMakePrettyW PathMakePretty;
531 alias PathMakeSystemFolderW PathMakeSystemFolder;
532 alias PathMatchSpecW PathMatchSpec;
533 alias PathParseIconLocationW PathParseIconLocation;
534 alias PathQuoteSpacesW PathQuoteSpaces;
535 alias PathRelativePathToW PathRelativePathTo;
536 alias PathRemoveArgsW PathRemoveArgs;
537 alias PathRemoveBackslashW PathRemoveBackslash;
538 alias PathRemoveBlanksW PathRemoveBlanks;
539 alias PathRemoveExtensionW PathRemoveExtension;
540 alias PathRemoveFileSpecW PathRemoveFileSpec;
541 alias PathRenameExtensionW PathRenameExtension;
542 alias PathSearchAndQualifyW PathSearchAndQualify;
543 alias PathSetDlgItemPathW PathSetDlgItemPath;
544 alias PathSkipRootW PathSkipRoot;
545 alias PathStripPathW PathStripPath;
546 alias PathStripToRootW PathStripToRoot;
547 alias PathUndecorateW PathUndecorate;
548 alias PathUnExpandEnvStringsW PathUnExpandEnvStrings;
549 alias PathUnmakeSystemFolderW PathUnmakeSystemFolder;
550 alias PathUnquoteSpacesW PathUnquoteSpaces;
551 alias SHCreateStreamOnFileW SHCreateStreamOnFile;
552 alias SHOpenRegStreamW SHOpenRegStream;
553 alias SHOpenRegStream2W SHOpenRegStream2;
554 alias SHCopyKeyW SHCopyKey;
555 alias SHDeleteEmptyKeyW SHDeleteEmptyKey;
556 alias SHDeleteKeyW SHDeleteKey;
557 alias SHEnumKeyExW SHEnumKeyEx;
558 alias SHQueryInfoKeyW SHQueryInfoKey;
559 alias SHQueryValueExW SHQueryValueEx;
560 alias SHEnumValueW SHEnumValue;
561 alias SHGetValueW SHGetValue;
562 alias SHSetValueW SHSetValue;
563 alias SHDeleteValueW SHDeleteValue;
564 alias AssocQueryKeyW AssocQueryKey;
565 alias AssocQueryStringByKeyW AssocQueryStringByKey;
566 alias AssocQueryStringW AssocQueryString;
567 alias UrlApplySchemeW UrlApplyScheme;
568 alias UrlCanonicalizeW UrlCanonicalize;
569 alias UrlCombineW UrlCombine;
570 alias UrlCompareW UrlCompare;
571 alias UrlCreateFromPathW UrlCreateFromPath;
572 alias UrlEscapeW UrlEscape;
573 alias UrlGetLocationW UrlGetLocation;
574 alias UrlGetPartW UrlGetPart;
575 alias UrlHashW UrlHash;
576 alias UrlIsW UrlIs;
577 alias UrlIsFileUrlW UrlIsFileUrl;
578 alias UrlIsNoHistoryW UrlIsNoHistory;
579 alias UrlIsOpaqueW UrlIsOpaque;
580 alias UrlUnescapeW UrlUnescape;
581 alias UrlUnescapeInPlaceW UrlUnescapeInPlace;
582 alias SHRegCreateUSKeyW SHRegCreateUSKey;
583 alias SHRegDeleteEmptyUSKeyW SHRegDeleteEmptyUSKey;
584 alias SHRegDeleteUSValueW SHRegDeleteUSValue;
585 alias SHRegEnumUSKeyW SHRegEnumUSKey;
586 alias SHRegEnumUSValueW SHRegEnumUSValue;
587 alias SHRegGetBoolUSValueW SHRegGetBoolUSValue;
588 alias SHRegGetPathW SHRegGetPath;
589 alias SHRegGetUSValueW SHRegGetUSValue;
590 alias SHRegOpenUSKeyW SHRegOpenUSKey;
591 alias SHRegQueryInfoUSKeyW SHRegQueryInfoUSKey;
592 alias SHRegQueryUSValueW SHRegQueryUSValue;
593 alias SHRegSetPathW SHRegSetPath;
594 alias SHRegSetUSValueW SHRegSetUSValue;
595 alias SHRegWriteUSValueW SHRegWriteUSValue;
596 //alias wnsprintfW wnsprintf;
597 //alias wvnsprintfW wvnsprintf;
598 } else {
599 alias ChrCmpIA ChrCmpI;
600 alias IntlStrEqNA IntlStrEqN;
601 alias IntlStrEqNIA IntlStrEqNI;
602 alias IntlStrEqWorkerA IntlStrEqWorker;
603 alias SHStrDupA SHStrDup;
604 alias StrCatBuffA StrCatBuff;
605 alias StrChrA StrChr;
606 alias StrChrIA StrChrI;
607 alias StrCmpNIA StrCmpNI;
608 alias StrCmpNA StrCmpN;
609 alias StrCSpnIA StrCSpnI;
610 alias StrCSpnA StrCSpn;
611 alias StrDupA StrDup;
612 alias StrFormatByteSizeA StrFormatByteSize;
613 alias StrFormatKBSizeA StrFormatKBSize;
614 alias StrFromTimeIntervalA StrFromTimeInterval;
615 alias StrIsIntlEqualA StrIsIntlEqual;
616 alias StrNCatA StrNCat;
617 alias StrPBrkA StrPBrk;
618 alias StrRChrA StrRChr;
619 alias StrRChrIA StrRChrI;
620 alias StrRetToBufA StrRetToBuf;
621 alias StrRetToStrA StrRetToStr;
622 alias StrRStrIA StrRStrI;
623 alias StrSpnA StrSpn;
624 alias StrStrIA StrStrI;
625 alias StrStrA StrStr;
626 alias StrToIntA StrToInt;
627 alias StrToIntExA StrToIntEx;
628 alias StrTrimA StrTrim;
629 alias PathAddBackslashA PathAddBackslash;
630 alias PathAddExtensionA PathAddExtension;
631 alias PathAppendA PathAppend;
632 alias PathBuildRootA PathBuildRoot;
633 alias PathCanonicalizeA PathCanonicalize;
634 alias PathCombineA PathCombine;
635 alias PathCommonPrefixA PathCommonPrefix;
636 alias PathCompactPathA PathCompactPath;
637 alias PathCompactPathExA PathCompactPathEx;
638 alias PathCreateFromUrlA PathCreateFromUrl;
639 alias PathFileExistsA PathFileExists;
640 alias PathFindExtensionA PathFindExtension;
641 alias PathFindFileNameA PathFindFileName;
642 alias PathFindNextComponentA PathFindNextComponent;
643 alias PathFindOnPathA PathFindOnPath;
644 alias PathFindSuffixArrayA PathFindSuffixArray;
645 alias PathGetArgsA PathGetArgs;
646 alias PathGetCharTypeA PathGetCharType;
647 alias PathGetDriveNumberA PathGetDriveNumber;
648 alias PathIsContentTypeA PathIsContentType;
649 alias PathIsDirectoryEmptyA PathIsDirectoryEmpty;
650 alias PathIsDirectoryA PathIsDirectory;
651 alias PathIsFileSpecA PathIsFileSpec;
652 alias PathIsLFNFileSpecA PathIsLFNFileSpec;
653 alias PathIsNetworkPathA PathIsNetworkPath;
654 alias PathIsPrefixA PathIsPrefix;
655 alias PathIsRelativeA PathIsRelative;
656 alias PathIsRootA PathIsRoot;
657 alias PathIsSameRootA PathIsSameRoot;
658 alias PathIsSystemFolderA PathIsSystemFolder;
659 alias PathIsUNCServerShareA PathIsUNCServerShare;
660 alias PathIsUNCServerA PathIsUNCServer;
661 alias PathIsUNCA PathIsUNC;
662 alias PathIsURLA PathIsURL;
663 alias PathMakePrettyA PathMakePretty;
664 alias PathMakeSystemFolderA PathMakeSystemFolder;
665 alias PathMatchSpecA PathMatchSpec;
666 alias PathParseIconLocationA PathParseIconLocation;
667 alias PathQuoteSpacesA PathQuoteSpaces;
668 alias PathRelativePathToA PathRelativePathTo;
669 alias PathRemoveArgsA PathRemoveArgs;
670 alias PathRemoveBackslashA PathRemoveBackslash;
671 alias PathRemoveBlanksA PathRemoveBlanks;
672 alias PathRemoveExtensionA PathRemoveExtension;
673 alias PathRemoveFileSpecA PathRemoveFileSpec;
674 alias PathRenameExtensionA PathRenameExtension;
675 alias PathSearchAndQualifyA PathSearchAndQualify;
676 alias PathSetDlgItemPathA PathSetDlgItemPath;
677 alias PathSkipRootA PathSkipRoot;
678 alias PathStripPathA PathStripPath;
679 alias PathStripToRootA PathStripToRoot;
680 alias PathUndecorateA PathUndecorate;
681 alias PathUnExpandEnvStringsA PathUnExpandEnvStrings;
682 alias PathUnmakeSystemFolderA PathUnmakeSystemFolder;
683 alias PathUnquoteSpacesA PathUnquoteSpaces;
684 alias SHCreateStreamOnFileA SHCreateStreamOnFile;
685 alias SHOpenRegStreamA SHOpenRegStream;
686 alias SHOpenRegStream2A SHOpenRegStream2;
687 alias SHCopyKeyA SHCopyKey;
688 alias SHDeleteEmptyKeyA SHDeleteEmptyKey;
689 alias SHDeleteKeyA SHDeleteKey;
690 alias SHEnumKeyExA SHEnumKeyEx;
691 alias SHQueryInfoKeyA SHQueryInfoKey;
692 alias SHQueryValueExA SHQueryValueEx;
693 alias SHEnumValueA SHEnumValue;
694 alias SHGetValueA SHGetValue;
695 alias SHSetValueA SHSetValue;
696 alias SHDeleteValueA SHDeleteValue;
697 alias AssocQueryKeyA AssocQueryKey;
698 alias AssocQueryStringByKeyA AssocQueryStringByKey;
699 alias AssocQueryStringA AssocQueryString;
700 alias UrlApplySchemeA UrlApplyScheme;
701 alias UrlCanonicalizeA UrlCanonicalize;
702 alias UrlCombineA UrlCombine;
703 alias UrlCompareA UrlCompare;
704 alias UrlCreateFromPathA UrlCreateFromPath;
705 alias UrlEscapeA UrlEscape;
706 alias UrlGetLocationA UrlGetLocation;
707 alias UrlGetPartA UrlGetPart;
708 alias UrlHashA UrlHash;
709 alias UrlIsA UrlIs;
710 alias UrlIsNoHistoryA UrlIsNoHistory;
711 alias UrlIsOpaqueA UrlIsOpaque;
712 alias UrlUnescapeA UrlUnescape;
713 alias UrlUnescapeInPlaceA UrlUnescapeInPlace;
714 alias SHRegCreateUSKeyA SHRegCreateUSKey;
715 alias SHRegDeleteEmptyUSKeyA SHRegDeleteEmptyUSKey;
716 alias SHRegDeleteUSValueA SHRegDeleteUSValue;
717 alias SHRegEnumUSKeyA SHRegEnumUSKey;
718 alias SHRegEnumUSValueA SHRegEnumUSValue;
719 alias SHRegGetBoolUSValueA SHRegGetBoolUSValue;
720 alias SHRegGetPathA SHRegGetPath;
721 alias SHRegGetUSValueA SHRegGetUSValue;
722 alias SHRegOpenUSKeyA SHRegOpenUSKey;
723 alias SHRegQueryInfoUSKeyA SHRegQueryInfoUSKey;
724 alias SHRegQueryUSValueA SHRegQueryUSValue;
725 alias SHRegSetPathA SHRegSetPath;
726 alias SHRegSetUSValueA SHRegSetUSValue;
727 alias SHRegWriteUSValueA SHRegWriteUSValue;
728 //alias wnsprintfA wnsprintf;
729 //alias wvnsprintfA wvnsprintf;
730 }
731 
732 alias StrToInt StrToLong;