[PSDK] Update wincodec.idl. CORE-13362
[reactos.git] / reactos / sdk / include / psdk / shlwapi.h
1 /*
2 * SHLWAPI.DLL functions
3 *
4 * Copyright (C) 2000 Juergen Schmied
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #ifndef __WINE_SHLWAPI_H
22 #define __WINE_SHLWAPI_H
23
24 #include <specstrings.h>
25 #include <objbase.h>
26 #include <shtypes.h>
27
28 #ifdef __cplusplus
29 extern "C" {
30 #endif /* defined(__cplusplus) */
31
32 #include <pshpack8.h>
33
34 #ifndef NO_SHLWAPI_REG
35
36 /* Registry functions */
37
38 DWORD WINAPI SHDeleteEmptyKeyA(_In_ HKEY, _In_opt_ LPCSTR);
39 DWORD WINAPI SHDeleteEmptyKeyW(_In_ HKEY, _In_opt_ LPCWSTR);
40 #define SHDeleteEmptyKey WINELIB_NAME_AW(SHDeleteEmptyKey)
41
42 DWORD WINAPI SHDeleteKeyA(_In_ HKEY, _In_opt_ LPCSTR);
43 DWORD WINAPI SHDeleteKeyW(_In_ HKEY, _In_opt_ LPCWSTR);
44 #define SHDeleteKey WINELIB_NAME_AW(SHDeleteKey)
45
46 DWORD WINAPI SHDeleteValueA(_In_ HKEY, _In_opt_ LPCSTR, _In_ LPCSTR);
47 DWORD WINAPI SHDeleteValueW(_In_ HKEY, _In_opt_ LPCWSTR, _In_ LPCWSTR);
48 #define SHDeleteValue WINELIB_NAME_AW(SHDeleteValue)
49
50 DWORD
51 WINAPI
52 SHGetValueA(
53 _In_ HKEY,
54 _In_opt_ LPCSTR,
55 _In_opt_ LPCSTR,
56 _Out_opt_ LPDWORD,
57 _Out_writes_bytes_opt_(*pcbData) LPVOID,
58 _Inout_opt_ LPDWORD pcbData);
59
60 DWORD
61 WINAPI
62 SHGetValueW(
63 _In_ HKEY,
64 _In_opt_ LPCWSTR,
65 _In_opt_ LPCWSTR,
66 _Out_opt_ LPDWORD,
67 _Out_writes_bytes_opt_(*pcbData) LPVOID,
68 _Inout_opt_ LPDWORD pcbData);
69
70 #define SHGetValue WINELIB_NAME_AW(SHGetValue)
71
72 DWORD
73 WINAPI
74 SHSetValueA(
75 _In_ HKEY,
76 _In_opt_ LPCSTR,
77 _In_opt_ LPCSTR,
78 _In_ DWORD,
79 _In_reads_bytes_opt_(cbData) LPCVOID,
80 _In_ DWORD cbData);
81
82 DWORD
83 WINAPI
84 SHSetValueW(
85 _In_ HKEY,
86 _In_opt_ LPCWSTR,
87 _In_opt_ LPCWSTR,
88 _In_ DWORD,
89 _In_reads_bytes_opt_(cbData) LPCVOID,
90 _In_ DWORD cbData);
91
92 #define SHSetValue WINELIB_NAME_AW(SHSetValue)
93
94 DWORD
95 WINAPI
96 SHQueryValueExA(
97 _In_ HKEY,
98 _In_opt_ LPCSTR,
99 _Reserved_ LPDWORD,
100 _Out_opt_ LPDWORD,
101 _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID,
102 _Inout_opt_ LPDWORD pcbData);
103
104 DWORD
105 WINAPI
106 SHQueryValueExW(
107 _In_ HKEY,
108 _In_opt_ LPCWSTR,
109 _Reserved_ LPDWORD,
110 _Out_opt_ LPDWORD,
111 _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID,
112 _Inout_opt_ LPDWORD pcbData);
113
114 #define SHQueryValueEx WINELIB_NAME_AW(SHQueryValueEx)
115
116 LONG
117 WINAPI
118 SHEnumKeyExA(
119 _In_ HKEY,
120 _In_ DWORD,
121 _Out_writes_(*pcchName) LPSTR,
122 _Inout_ LPDWORD pcchName);
123
124 LONG
125 WINAPI
126 SHEnumKeyExW(
127 _In_ HKEY,
128 _In_ DWORD,
129 _Out_writes_(*pcchName) LPWSTR,
130 _Inout_ LPDWORD pcchName);
131
132 #define SHEnumKeyEx WINELIB_NAME_AW(SHEnumKeyEx)
133
134 LONG
135 WINAPI
136 SHEnumValueA(
137 _In_ HKEY,
138 _In_ DWORD,
139 _Out_writes_opt_(*pcchValueName) LPSTR,
140 _Inout_opt_ LPDWORD pcchValueName,
141 _Out_opt_ LPDWORD,
142 _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID,
143 _Inout_opt_ LPDWORD pcbData);
144
145 LONG
146 WINAPI
147 SHEnumValueW(
148 _In_ HKEY,
149 _In_ DWORD,
150 _Out_writes_opt_(*pcchValueName) LPWSTR,
151 _Inout_opt_ LPDWORD pcchValueName,
152 _Out_opt_ LPDWORD,
153 _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID,
154 _Inout_opt_ LPDWORD pcbData);
155
156 #define SHEnumValue WINELIB_NAME_AW(SHEnumValue)
157
158 LONG
159 WINAPI
160 SHQueryInfoKeyA(
161 _In_ HKEY,
162 _Out_opt_ LPDWORD,
163 _Out_opt_ LPDWORD,
164 _Out_opt_ LPDWORD,
165 _Out_opt_ LPDWORD);
166
167 LONG
168 WINAPI
169 SHQueryInfoKeyW(
170 _In_ HKEY,
171 _Out_opt_ LPDWORD,
172 _Out_opt_ LPDWORD,
173 _Out_opt_ LPDWORD,
174 _Out_opt_ LPDWORD);
175
176 #define SHQueryInfoKey WINELIB_NAME_AW(SHQueryInfoKey)
177
178 DWORD
179 WINAPI
180 SHRegGetPathA(
181 _In_ HKEY,
182 _In_opt_ LPCSTR,
183 _In_opt_ LPCSTR,
184 _Out_writes_(MAX_PATH) LPSTR,
185 _In_ DWORD);
186
187 DWORD
188 WINAPI
189 SHRegGetPathW(
190 _In_ HKEY,
191 _In_opt_ LPCWSTR,
192 _In_opt_ LPCWSTR,
193 _Out_writes_(MAX_PATH) LPWSTR,
194 _In_ DWORD);
195
196 #define SHRegGetPath WINELIB_NAME_AW(SHRegGetPath)
197
198 DWORD
199 WINAPI
200 SHRegSetPathA(
201 _In_ HKEY,
202 _In_opt_ LPCSTR,
203 _In_opt_ LPCSTR,
204 _In_ LPCSTR,
205 _In_ DWORD);
206
207 DWORD
208 WINAPI
209 SHRegSetPathW(
210 _In_ HKEY,
211 _In_opt_ LPCWSTR,
212 _In_opt_ LPCWSTR,
213 _In_ LPCWSTR,
214 _In_ DWORD);
215
216 #define SHRegSetPath WINELIB_NAME_AW(SHRegSetPath)
217
218 DWORD
219 WINAPI
220 SHCopyKeyA(
221 _In_ HKEY,
222 _In_opt_ LPCSTR,
223 _In_ HKEY,
224 _Reserved_ DWORD);
225
226 DWORD
227 WINAPI
228 SHCopyKeyW(
229 _In_ HKEY,
230 _In_opt_ LPCWSTR,
231 _In_ HKEY,
232 _Reserved_ DWORD);
233
234 #define SHCopyKey WINELIB_NAME_AW(SHCopyKey)
235
236 HKEY WINAPI SHRegDuplicateHKey(_In_ HKEY);
237
238 /* SHRegGetValue flags */
239 typedef INT SRRF;
240
241 #define SRRF_RT_REG_NONE 0x1
242 #define SRRF_RT_REG_SZ 0x2
243 #define SRRF_RT_REG_EXPAND_SZ 0x4
244 #define SRRF_RT_REG_BINARY 0x8
245 #define SRRF_RT_REG_DWORD 0x10
246 #define SRRF_RT_REG_MULTI_SZ 0x20
247 #define SRRF_RT_REG_QWORD 0x40
248
249 #define SRRF_RT_DWORD (SRRF_RT_REG_BINARY|SRRF_RT_REG_DWORD)
250 #define SRRF_RT_QWORD (SRRF_RT_REG_BINARY|SRRF_RT_REG_QWORD)
251 #define SRRF_RT_ANY 0xffff
252
253 #define SRRF_RM_ANY 0
254 #define SRRF_RM_NORMAL 0x10000
255 #define SRRF_RM_SAFE 0x20000
256 #define SRRF_RM_SAFENETWORK 0x40000
257
258 #define SRRF_NOEXPAND 0x10000000
259 #define SRRF_ZEROONFAILURE 0x20000000
260 #define SRRF_NOVIRT 0x40000000
261
262 LSTATUS
263 WINAPI
264 SHRegGetValueA(
265 _In_ HKEY,
266 _In_opt_ LPCSTR,
267 _In_opt_ LPCSTR,
268 _In_ SRRF,
269 _Out_opt_ LPDWORD,
270 _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID,
271 _Inout_opt_ LPDWORD pcbData);
272
273 LSTATUS
274 WINAPI
275 SHRegGetValueW(
276 _In_ HKEY,
277 _In_opt_ LPCWSTR,
278 _In_opt_ LPCWSTR,
279 _In_ SRRF,
280 _Out_opt_ LPDWORD,
281 _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID,
282 _Inout_opt_ LPDWORD pcbData);
283
284 #define SHRegGetValue WINELIB_NAME_AW(SHRegGetValue)
285
286 /* Undocumented registry functions */
287
288 DWORD WINAPI SHDeleteOrphanKeyA(HKEY,LPCSTR);
289 DWORD WINAPI SHDeleteOrphanKeyW(HKEY,LPCWSTR);
290 #define SHDeleteOrphanKey WINELIB_NAME_AW(SHDeleteOrphanKey)
291
292
293 /* User registry functions */
294
295 typedef enum
296 {
297 SHREGDEL_DEFAULT = 0,
298 SHREGDEL_HKCU = 0x1,
299 SHREGDEL_HKLM = 0x10,
300 SHREGDEL_BOTH = SHREGDEL_HKLM | SHREGDEL_HKCU
301 } SHREGDEL_FLAGS;
302
303 typedef enum
304 {
305 SHREGENUM_DEFAULT = 0,
306 SHREGENUM_HKCU = 0x1,
307 SHREGENUM_HKLM = 0x10,
308 SHREGENUM_BOTH = SHREGENUM_HKLM | SHREGENUM_HKCU
309 } SHREGENUM_FLAGS;
310
311 #define SHREGSET_HKCU 0x1 /* Apply to HKCU if empty */
312 #define SHREGSET_FORCE_HKCU 0x2 /* Always apply to HKCU */
313 #define SHREGSET_HKLM 0x4 /* Apply to HKLM if empty */
314 #define SHREGSET_FORCE_HKLM 0x8 /* Always apply to HKLM */
315 #define SHREGSET_DEFAULT (SHREGSET_FORCE_HKCU | SHREGSET_HKLM)
316
317 typedef HANDLE HUSKEY;
318 typedef HUSKEY *PHUSKEY;
319
320 LONG
321 WINAPI
322 SHRegCreateUSKeyA(
323 _In_ LPCSTR,
324 _In_ REGSAM,
325 _In_opt_ HUSKEY,
326 _Out_ PHUSKEY,
327 _In_ DWORD);
328
329 LONG
330 WINAPI
331 SHRegCreateUSKeyW(
332 _In_ LPCWSTR,
333 _In_ REGSAM,
334 _In_opt_ HUSKEY,
335 _Out_ PHUSKEY,
336 _In_ DWORD);
337
338 #define SHRegCreateUSKey WINELIB_NAME_AW(SHRegCreateUSKey)
339
340 LONG
341 WINAPI
342 SHRegOpenUSKeyA(
343 _In_ LPCSTR,
344 _In_ REGSAM,
345 _In_opt_ HUSKEY,
346 _Out_ PHUSKEY,
347 _In_ BOOL);
348
349 LONG
350 WINAPI
351 SHRegOpenUSKeyW(
352 _In_ LPCWSTR,
353 _In_ REGSAM,
354 _In_opt_ HUSKEY,
355 _Out_ PHUSKEY,
356 _In_ BOOL);
357
358 #define SHRegOpenUSKey WINELIB_NAME_AW(SHRegOpenUSKey)
359
360 LONG
361 WINAPI
362 SHRegQueryUSValueA(
363 _In_ HUSKEY,
364 _In_opt_ LPCSTR,
365 _Inout_opt_ LPDWORD,
366 _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID,
367 _Inout_opt_ LPDWORD pcbData,
368 _In_ BOOL,
369 _In_reads_bytes_opt_(dwDefaultDataSize) LPVOID,
370 _In_opt_ DWORD dwDefaultDataSize);
371
372 LONG
373 WINAPI
374 SHRegQueryUSValueW(
375 _In_ HUSKEY,
376 _In_opt_ LPCWSTR,
377 _Inout_opt_ LPDWORD,
378 _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID,
379 _Inout_opt_ LPDWORD pcbData,
380 _In_ BOOL,
381 _In_reads_bytes_opt_(dwDefaultDataSize) LPVOID,
382 _In_opt_ DWORD dwDefaultDataSize);
383
384 #define SHRegQueryUSValue WINELIB_NAME_AW(SHRegQueryUSValue)
385
386 LONG
387 WINAPI
388 SHRegWriteUSValueA(
389 _In_ HUSKEY,
390 _In_ LPCSTR,
391 _In_ DWORD,
392 _In_reads_bytes_(cbData) LPVOID,
393 _In_ DWORD cbData,
394 _In_ DWORD);
395
396 LONG
397 WINAPI
398 SHRegWriteUSValueW(
399 _In_ HUSKEY,
400 _In_ LPCWSTR,
401 _In_ DWORD,
402 _In_reads_bytes_(cbData) LPVOID,
403 _In_ DWORD cbData,
404 _In_ DWORD);
405
406 #define SHRegWriteUSValue WINELIB_NAME_AW(SHRegWriteUSValue)
407
408 LONG
409 WINAPI
410 SHRegDeleteUSValueA(
411 _In_ HUSKEY,
412 _In_ LPCSTR,
413 _In_ SHREGDEL_FLAGS);
414
415 LONG
416 WINAPI
417 SHRegDeleteUSValueW(
418 _In_ HUSKEY,
419 _In_ LPCWSTR,
420 _In_ SHREGDEL_FLAGS);
421
422 #define SHRegDeleteUSValue WINELIB_NAME_AW(SHRegDeleteUSValue)
423
424 LONG
425 WINAPI
426 SHRegDeleteEmptyUSKeyA(
427 _In_ HUSKEY,
428 _In_ LPCSTR,
429 _In_ SHREGDEL_FLAGS);
430
431 LONG
432 WINAPI
433 SHRegDeleteEmptyUSKeyW(
434 _In_ HUSKEY,
435 _In_ LPCWSTR,
436 _In_ SHREGDEL_FLAGS);
437
438 #define SHRegDeleteEmptyUSKey WINELIB_NAME_AW(SHRegDeleteEmptyUSKey)
439
440 LONG
441 WINAPI
442 SHRegEnumUSKeyA(
443 _In_ HUSKEY,
444 _In_ DWORD,
445 _Out_writes_to_(*pcchName, *pcchName) LPSTR,
446 _Inout_ LPDWORD pcchName,
447 _In_ SHREGENUM_FLAGS);
448
449 LONG
450 WINAPI
451 SHRegEnumUSKeyW(
452 _In_ HUSKEY,
453 _In_ DWORD,
454 _Out_writes_to_(*pcchName, *pcchName) LPWSTR,
455 _Inout_ LPDWORD pcchName,
456 _In_ SHREGENUM_FLAGS);
457
458 #define SHRegEnumUSKey WINELIB_NAME_AW(SHRegEnumUSKey)
459
460 LONG
461 WINAPI
462 SHRegEnumUSValueA(
463 _In_ HUSKEY,
464 _In_ DWORD,
465 _Out_writes_to_(*pcchValueName, *pcchValueName) LPSTR,
466 _Inout_ LPDWORD pcchValueName,
467 _Out_opt_ LPDWORD,
468 _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID,
469 _Inout_opt_ LPDWORD pcbData,
470 _In_ SHREGENUM_FLAGS);
471
472 LONG
473 WINAPI
474 SHRegEnumUSValueW(
475 _In_ HUSKEY,
476 _In_ DWORD,
477 _Out_writes_to_(*pcchValueName, *pcchValueName) LPWSTR,
478 _Inout_ LPDWORD pcchValueName,
479 _Out_opt_ LPDWORD,
480 _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID,
481 _Inout_opt_ LPDWORD pcbData,
482 _In_ SHREGENUM_FLAGS);
483
484 #define SHRegEnumUSValue WINELIB_NAME_AW(SHRegEnumUSValue)
485
486 LONG
487 WINAPI
488 SHRegQueryInfoUSKeyA(
489 _In_ HUSKEY,
490 _Out_opt_ LPDWORD,
491 _Out_opt_ LPDWORD,
492 _Out_opt_ LPDWORD,
493 _Out_opt_ LPDWORD,
494 _In_ SHREGENUM_FLAGS);
495
496 LONG
497 WINAPI
498 SHRegQueryInfoUSKeyW(
499 _In_ HUSKEY,
500 _Out_opt_ LPDWORD,
501 _Out_opt_ LPDWORD,
502 _Out_opt_ LPDWORD,
503 _Out_opt_ LPDWORD,
504 _In_ SHREGENUM_FLAGS);
505
506 #define SHRegQueryInfoUSKey WINELIB_NAME_AW(SHRegQueryInfoUSKey)
507
508 LONG WINAPI SHRegCloseUSKey(_In_ HUSKEY);
509
510 LONG
511 WINAPI
512 SHRegGetUSValueA(
513 _In_ LPCSTR,
514 _In_opt_ LPCSTR,
515 _Inout_opt_ LPDWORD,
516 _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID,
517 _Inout_opt_ LPDWORD pcbData,
518 _In_ BOOL,
519 _In_reads_bytes_opt_(dwDefaultDataSize) LPVOID,
520 _In_ DWORD dwDefaultDataSize);
521
522 LONG
523 WINAPI
524 SHRegGetUSValueW(
525 _In_ LPCWSTR,
526 _In_opt_ LPCWSTR,
527 _Inout_opt_ LPDWORD,
528 _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID,
529 _Inout_opt_ LPDWORD pcbData,
530 _In_ BOOL,
531 _In_reads_bytes_opt_(dwDefaultDataSize) LPVOID,
532 _In_ DWORD dwDefaultDataSize);
533
534 #define SHRegGetUSValue WINELIB_NAME_AW(SHRegGetUSValue)
535
536 LONG
537 WINAPI
538 SHRegSetUSValueA(
539 _In_ LPCSTR,
540 _In_ LPCSTR,
541 _In_ DWORD,
542 _In_reads_bytes_opt_(cbData) LPVOID,
543 _In_opt_ DWORD cbData,
544 _In_opt_ DWORD);
545
546 LONG
547 WINAPI
548 SHRegSetUSValueW(
549 _In_ LPCWSTR,
550 _In_ LPCWSTR,
551 _In_ DWORD,
552 _In_reads_bytes_opt_(cbData) LPVOID,
553 _In_opt_ DWORD cbData,
554 _In_opt_ DWORD);
555
556 #define SHRegSetUSValue WINELIB_NAME_AW(SHRegSetUSValue)
557
558 BOOL
559 WINAPI
560 SHRegGetBoolUSValueA(
561 _In_ LPCSTR,
562 _In_opt_ LPCSTR,
563 _In_ BOOL,
564 _In_ BOOL);
565
566 BOOL
567 WINAPI
568 SHRegGetBoolUSValueW(
569 _In_ LPCWSTR,
570 _In_opt_ LPCWSTR,
571 _In_ BOOL,
572 _In_ BOOL);
573
574 #define SHRegGetBoolUSValue WINELIB_NAME_AW(SHRegGetBoolUSValue)
575
576 int WINAPI SHRegGetIntW(_In_ HKEY, _In_opt_ LPCWSTR, _In_ int);
577
578 /* IQueryAssociation and helpers */
579 enum
580 {
581 ASSOCF_NONE = 0x0000,
582 ASSOCF_INIT_NOREMAPCLSID = 0x0001, /* Don't map clsid->progid */
583 ASSOCF_INIT_BYEXENAME = 0x0002, /* .exe name given */
584 ASSOCF_OPEN_BYEXENAME = 0x0002, /* Synonym */
585 ASSOCF_INIT_DEFAULTTOSTAR = 0x0004, /* Use * as base */
586 ASSOCF_INIT_DEFAULTTOFOLDER = 0x0008, /* Use folder as base */
587 ASSOCF_NOUSERSETTINGS = 0x0010, /* No HKCU reads */
588 ASSOCF_NOTRUNCATE = 0x0020, /* Don't truncate return */
589 ASSOCF_VERIFY = 0x0040, /* Verify data */
590 ASSOCF_REMAPRUNDLL = 0x0080, /* Get rundll args */
591 ASSOCF_NOFIXUPS = 0x0100, /* Don't fixup errors */
592 ASSOCF_IGNOREBASECLASS = 0x0200, /* Don't read baseclass */
593 ASSOCF_INIT_IGNOREUNKNOWN = 0x0400, /* Fail for unknown progid */
594 ASSOCF_INIT_FIXED_PROGID = 0x0800, /* Used passed string as progid, don't try to map it */
595 ASSOCF_IS_PROTOCOL = 0x1000, /* Treat as protocol, that should be mapped */
596 ASSOCF_INIT_FOR_FILE = 0x2000, /* progid is for file extension association */
597 };
598
599 typedef DWORD ASSOCF;
600
601 typedef enum
602 {
603 ASSOCSTR_COMMAND = 1, /* Verb command */
604 ASSOCSTR_EXECUTABLE, /* .exe from command string */
605 ASSOCSTR_FRIENDLYDOCNAME, /* Friendly doc type name */
606 ASSOCSTR_FRIENDLYAPPNAME, /* Friendly .exe name */
607 ASSOCSTR_NOOPEN, /* noopen value */
608 ASSOCSTR_SHELLNEWVALUE, /* Use shellnew key */
609 ASSOCSTR_DDECOMMAND, /* DDE command template */
610 ASSOCSTR_DDEIFEXEC, /* DDE command for process create */
611 ASSOCSTR_DDEAPPLICATION, /* DDE app name */
612 ASSOCSTR_DDETOPIC, /* DDE topic */
613 ASSOCSTR_INFOTIP, /* Infotip */
614 ASSOCSTR_QUICKTIP, /* Quick infotip */
615 ASSOCSTR_TILEINFO, /* Properties for tileview */
616 ASSOCSTR_CONTENTTYPE, /* Mimetype */
617 ASSOCSTR_DEFAULTICON, /* Icon */
618 ASSOCSTR_SHELLEXTENSION, /* GUID for shell extension handler */
619 ASSOCSTR_MAX
620 } ASSOCSTR;
621
622 typedef enum
623 {
624 ASSOCKEY_SHELLEXECCLASS = 1, /* Key for ShellExec */
625 ASSOCKEY_APP, /* Application */
626 ASSOCKEY_CLASS, /* Progid or class */
627 ASSOCKEY_BASECLASS, /* Base class */
628 ASSOCKEY_MAX
629 } ASSOCKEY;
630
631 typedef enum
632 {
633 ASSOCDATA_MSIDESCRIPTOR = 1, /* Component descriptor */
634 ASSOCDATA_NOACTIVATEHANDLER, /* Don't activate */
635 ASSOCDATA_QUERYCLASSSTORE, /* Look in Class Store */
636 ASSOCDATA_HASPERUSERASSOC, /* Use user association */
637 ASSOCDATA_EDITFLAGS, /* Edit flags */
638 ASSOCDATA_VALUE, /* pszExtra is value */
639 ASSOCDATA_MAX
640 } ASSOCDATA;
641
642 typedef enum
643 {
644 ASSOCENUM_NONE
645 } ASSOCENUM;
646
647 typedef struct IQueryAssociations *LPQUERYASSOCIATIONS;
648
649 #define INTERFACE IQueryAssociations
650 DECLARE_INTERFACE_(IQueryAssociations,IUnknown)
651 {
652 /*** IUnknown methods ***/
653 STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE;
654 STDMETHOD_(ULONG,AddRef)(THIS) PURE;
655 STDMETHOD_(ULONG,Release)(THIS) PURE;
656 /*** IQueryAssociations methods ***/
657 STDMETHOD(Init)(THIS_ _In_ ASSOCF flags, _In_opt_ LPCWSTR pszAssoc, _In_opt_ HKEY hkProgid, _In_opt_ HWND hwnd) PURE;
658 STDMETHOD(GetString)(THIS_ _In_ ASSOCF flags, _In_ ASSOCSTR str, _In_opt_ LPCWSTR pszExtra, _Out_writes_opt_(*pcchOut) LPWSTR pszOut, _Inout_ DWORD *pcchOut) PURE;
659 STDMETHOD(GetKey)(THIS_ _In_ ASSOCF flags, _In_ ASSOCKEY key, _In_opt_ LPCWSTR pszExtra, _Out_ HKEY *phkeyOut) PURE;
660 STDMETHOD(GetData)(THIS_ _In_ ASSOCF flags, _In_ ASSOCDATA data, _In_opt_ LPCWSTR pszExtra, _Out_writes_bytes_opt_(*pcbOut) LPVOID pvOut, _Inout_opt_ DWORD *pcbOut) PURE;
661 STDMETHOD(GetEnum)(THIS_ _In_ ASSOCF flags, _In_ ASSOCENUM assocenum, _In_opt_ LPCWSTR pszExtra, _In_ REFIID riid, _Outptr_ LPVOID *ppvOut) PURE;
662 };
663 #undef INTERFACE
664
665 #if !defined(__cplusplus) || defined(CINTERFACE)
666 #define IQueryAssociations_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
667 #define IQueryAssociations_AddRef(p) (p)->lpVtbl->AddRef(p)
668 #define IQueryAssociations_Release(p) (p)->lpVtbl->Release(p)
669 #define IQueryAssociations_Init(p,a,b,c,d) (p)->lpVtbl->Init(p,a,b,c,d)
670 #define IQueryAssociations_GetString(p,a,b,c,d,e) (p)->lpVtbl->GetString(p,a,b,c,d,e)
671 #define IQueryAssociations_GetKey(p,a,b,c,d) (p)->lpVtbl->GetKey(p,a,b,c,d)
672 #define IQueryAssociations_GetData(p,a,b,c,d,e) (p)->lpVtbl->GetData(p,a,b,c,d,e)
673 #define IQueryAssociations_GetEnum(p,a,b,c,d,e) (p)->lpVtbl->GetEnum(p,a,b,c,d,e)
674 #endif
675
676 HRESULT WINAPI AssocCreate(_In_ CLSID, _In_ REFIID, _Outptr_ LPVOID*);
677
678 HRESULT
679 WINAPI
680 AssocQueryStringA(
681 _In_ ASSOCF,
682 _In_ ASSOCSTR,
683 _In_ LPCSTR,
684 _In_opt_ LPCSTR,
685 _Out_writes_opt_(*pcchOut) LPSTR,
686 _Inout_ LPDWORD pcchOut);
687
688 HRESULT
689 WINAPI
690 AssocQueryStringW(
691 _In_ ASSOCF,
692 _In_ ASSOCSTR,
693 _In_ LPCWSTR,
694 _In_opt_ LPCWSTR,
695 _Out_writes_opt_(*pcchOut) LPWSTR,
696 _Inout_ LPDWORD pcchOut);
697
698 #define AssocQueryString WINELIB_NAME_AW(AssocQueryString)
699
700 HRESULT
701 WINAPI
702 AssocQueryStringByKeyA(
703 _In_ ASSOCF,
704 _In_ ASSOCSTR,
705 _In_ HKEY,
706 _In_opt_ LPCSTR,
707 _Out_writes_opt_(*pcchOut) LPSTR,
708 _Inout_ LPDWORD pcchOut);
709
710 HRESULT
711 WINAPI
712 AssocQueryStringByKeyW(
713 _In_ ASSOCF,
714 _In_ ASSOCSTR,
715 _In_ HKEY,
716 _In_opt_ LPCWSTR,
717 _Out_writes_opt_(*pcchOut) LPWSTR,
718 _Inout_ LPDWORD pcchOut);
719
720 #define AssocQueryStringByKey WINELIB_NAME_AW(AssocQueryStringByKey)
721
722 HRESULT
723 WINAPI
724 AssocQueryKeyA(
725 _In_ ASSOCF,
726 _In_ ASSOCKEY,
727 _In_ LPCSTR,
728 _In_opt_ LPCSTR,
729 _Out_ PHKEY);
730
731 HRESULT
732 WINAPI
733 AssocQueryKeyW(
734 _In_ ASSOCF,
735 _In_ ASSOCKEY,
736 _In_ LPCWSTR,
737 _In_opt_ LPCWSTR,
738 _Out_ PHKEY);
739
740 #define AssocQueryKey WINELIB_NAME_AW(AssocQueryKey)
741
742 BOOL WINAPI AssocIsDangerous(_In_ LPCWSTR);
743
744 #endif /* NO_SHLWAPI_REG */
745
746 void WINAPI IUnknown_Set(_Inout_ IUnknown **ppunk, _In_opt_ IUnknown *punk);
747 void WINAPI IUnknown_AtomicRelease(_Inout_opt_ IUnknown **punk);
748 HRESULT WINAPI IUnknown_GetWindow(_In_ IUnknown *punk, _Out_ HWND *phwnd);
749
750 HRESULT
751 WINAPI
752 IUnknown_SetSite(
753 _In_ IUnknown *punk,
754 _In_opt_ IUnknown *punkSite);
755
756 HRESULT
757 WINAPI
758 IUnknown_GetSite(
759 _In_ IUnknown *punk,
760 _In_ REFIID riid,
761 _Outptr_ void **ppv);
762
763 HRESULT
764 WINAPI
765 IUnknown_QueryService(
766 _In_opt_ IUnknown *punk,
767 _In_ REFGUID guidService,
768 _In_ REFIID riid,
769 _Outptr_ void **ppvOut);
770
771 /* Path functions */
772 #ifndef NO_SHLWAPI_PATH
773
774 /* GetPathCharType return flags */
775 #define GCT_INVALID 0x0
776 #define GCT_LFNCHAR 0x1
777 #define GCT_SHORTCHAR 0x2
778 #define GCT_WILD 0x4
779 #define GCT_SEPARATOR 0x8
780
781 LPSTR WINAPI PathAddBackslashA(_Inout_updates_(MAX_PATH) LPSTR);
782 LPWSTR WINAPI PathAddBackslashW(_Inout_updates_(MAX_PATH) LPWSTR);
783 #define PathAddBackslash WINELIB_NAME_AW(PathAddBackslash)
784
785 BOOL
786 WINAPI
787 PathAddExtensionA(
788 _Inout_updates_(MAX_PATH) LPSTR,
789 _In_opt_ LPCSTR);
790
791 BOOL
792 WINAPI
793 PathAddExtensionW(
794 _Inout_updates_(MAX_PATH) LPWSTR,
795 _In_opt_ LPCWSTR);
796
797 #define PathAddExtension WINELIB_NAME_AW(PathAddExtension)
798
799 BOOL WINAPI PathAppendA(_Inout_updates_(MAX_PATH) LPSTR, _In_ LPCSTR);
800 BOOL WINAPI PathAppendW(_Inout_updates_(MAX_PATH) LPWSTR, _In_ LPCWSTR);
801 #define PathAppend WINELIB_NAME_AW(PathAppend)
802
803 LPSTR WINAPI PathBuildRootA(_Out_writes_(4) LPSTR, int);
804 LPWSTR WINAPI PathBuildRootW(_Out_writes_(4) LPWSTR, int);
805 #define PathBuildRoot WINELIB_NAME_AW(PathBuiltRoot)
806
807 BOOL WINAPI PathCanonicalizeA(_Out_writes_(MAX_PATH) LPSTR, _In_ LPCSTR);
808 BOOL WINAPI PathCanonicalizeW(_Out_writes_(MAX_PATH) LPWSTR, _In_ LPCWSTR);
809 #define PathCanonicalize WINELIB_NAME_AW(PathCanonicalize)
810
811 LPSTR
812 WINAPI
813 PathCombineA(
814 _Out_writes_(MAX_PATH) LPSTR,
815 _In_opt_ LPCSTR,
816 _In_opt_ LPCSTR);
817
818 LPWSTR
819 WINAPI
820 PathCombineW(
821 _Out_writes_(MAX_PATH) LPWSTR,
822 _In_opt_ LPCWSTR,
823 _In_opt_ LPCWSTR);
824
825 #define PathCombine WINELIB_NAME_AW(PathCombine)
826
827 BOOL
828 WINAPI
829 PathCompactPathA(
830 _In_opt_ HDC,
831 _Inout_updates_(MAX_PATH) LPSTR,
832 _In_ UINT);
833
834 BOOL
835 WINAPI
836 PathCompactPathW(
837 _In_opt_ HDC,
838 _Inout_updates_(MAX_PATH) LPWSTR,
839 _In_ UINT);
840
841 #define PathCompactPath WINELIB_NAME_AW(PathCompactPath)
842
843 BOOL
844 WINAPI
845 PathCompactPathExA(
846 _Out_writes_(cchMax) LPSTR,
847 _In_ LPCSTR,
848 _In_ UINT cchMax,
849 _In_ DWORD);
850
851 BOOL
852 WINAPI
853 PathCompactPathExW(
854 _Out_writes_(cchMax) LPWSTR,
855 _In_ LPCWSTR,
856 _In_ UINT cchMax,
857 _In_ DWORD);
858
859 #define PathCompactPathEx WINELIB_NAME_AW(PathCompactPathEx)
860
861 int
862 WINAPI
863 PathCommonPrefixA(
864 _In_ LPCSTR,
865 _In_ LPCSTR,
866 _Out_writes_opt_(MAX_PATH) LPSTR);
867
868 int
869 WINAPI
870 PathCommonPrefixW(
871 _In_ LPCWSTR,
872 _In_ LPCWSTR,
873 _Out_writes_opt_(MAX_PATH) LPWSTR);
874
875 #define PathCommonPrefix WINELIB_NAME_AW(PathCommonPrefix)
876
877 HRESULT
878 WINAPI
879 PathCreateFromUrlA(
880 _In_ LPCSTR,
881 _Out_writes_to_(*pcchPath, *pcchPath) LPSTR,
882 _Inout_ LPDWORD pcchPath,
883 DWORD);
884
885 HRESULT
886 WINAPI
887 PathCreateFromUrlW(
888 _In_ LPCWSTR,
889 _Out_writes_to_(*pcchPath, *pcchPath) LPWSTR,
890 _Inout_ LPDWORD pcchPath,
891 DWORD);
892
893 #define PathCreateFromUrl WINELIB_NAME_AW(PathCreateFromUrl)
894
895 HRESULT WINAPI PathCreateFromUrlAlloc(_In_ LPCWSTR, _Outptr_ LPWSTR*, DWORD);
896
897 BOOL WINAPI PathFileExistsA(_In_ LPCSTR);
898 BOOL WINAPI PathFileExistsW(_In_ LPCWSTR);
899 #define PathFileExists WINELIB_NAME_AW(PathFileExists)
900
901 BOOL WINAPI PathFileExistsAndAttributesA(LPCSTR,DWORD*);
902 BOOL WINAPI PathFileExistsAndAttributesW(LPCWSTR,DWORD*);
903 #define PathFileExistsAndAttributes WINELIB_NAME_AW(PathFileExistsAndAttributes)
904
905 LPSTR WINAPI PathFindExtensionA(_In_ LPCSTR);
906 LPWSTR WINAPI PathFindExtensionW(_In_ LPCWSTR);
907 #define PathFindExtension WINELIB_NAME_AW(PathFindExtension)
908
909 LPSTR WINAPI PathFindFileNameA(_In_ LPCSTR);
910 LPWSTR WINAPI PathFindFileNameW(_In_ LPCWSTR);
911 #define PathFindFileName WINELIB_NAME_AW(PathFindFileName)
912
913 LPSTR WINAPI PathFindNextComponentA(_In_ LPCSTR);
914 LPWSTR WINAPI PathFindNextComponentW(_In_ LPCWSTR);
915 #define PathFindNextComponent WINELIB_NAME_AW(PathFindNextComponent)
916
917 BOOL WINAPI PathFindOnPathA(_Inout_updates_(MAX_PATH) LPSTR, _In_opt_ LPCSTR*);
918 BOOL WINAPI PathFindOnPathW(_Inout_updates_(MAX_PATH) LPWSTR, _In_opt_ LPCWSTR*);
919 #define PathFindOnPath WINELIB_NAME_AW(PathFindOnPath)
920
921 LPSTR WINAPI PathGetArgsA(_In_ LPCSTR);
922 LPWSTR WINAPI PathGetArgsW(_In_ LPCWSTR);
923 #define PathGetArgs WINELIB_NAME_AW(PathGetArgs)
924
925 UINT WINAPI PathGetCharTypeA(_In_ UCHAR);
926 UINT WINAPI PathGetCharTypeW(_In_ WCHAR);
927 #define PathGetCharType WINELIB_NAME_AW(PathGetCharType)
928
929 int WINAPI PathGetDriveNumberA(_In_ LPCSTR);
930 int WINAPI PathGetDriveNumberW(_In_ LPCWSTR);
931 #define PathGetDriveNumber WINELIB_NAME_AW(PathGetDriveNumber)
932
933 BOOL WINAPI PathIsDirectoryA(_In_ LPCSTR);
934 BOOL WINAPI PathIsDirectoryW(_In_ LPCWSTR);
935 #define PathIsDirectory WINELIB_NAME_AW(PathIsDirectory)
936
937 BOOL WINAPI PathIsDirectoryEmptyA(_In_ LPCSTR);
938 BOOL WINAPI PathIsDirectoryEmptyW(_In_ LPCWSTR);
939 #define PathIsDirectoryEmpty WINELIB_NAME_AW(PathIsDirectoryEmpty)
940
941 BOOL WINAPI PathIsFileSpecA(_In_ LPCSTR);
942 BOOL WINAPI PathIsFileSpecW(_In_ LPCWSTR);
943 #define PathIsFileSpec WINELIB_NAME_AW(PathIsFileSpec);
944
945 BOOL WINAPI PathIsPrefixA(_In_ LPCSTR, _In_ LPCSTR);
946 BOOL WINAPI PathIsPrefixW(_In_ LPCWSTR, _In_ LPCWSTR);
947 #define PathIsPrefix WINELIB_NAME_AW(PathIsPrefix)
948
949 BOOL WINAPI PathIsRelativeA(_In_ LPCSTR);
950 BOOL WINAPI PathIsRelativeW(_In_ LPCWSTR);
951 #define PathIsRelative WINELIB_NAME_AW(PathIsRelative)
952
953 BOOL WINAPI PathIsRootA(_In_ LPCSTR);
954 BOOL WINAPI PathIsRootW(_In_ LPCWSTR);
955 #define PathIsRoot WINELIB_NAME_AW(PathIsRoot)
956
957 BOOL WINAPI PathIsSameRootA(_In_ LPCSTR, _In_ LPCSTR);
958 BOOL WINAPI PathIsSameRootW(_In_ LPCWSTR, _In_ LPCWSTR);
959 #define PathIsSameRoot WINELIB_NAME_AW(PathIsSameRoot)
960
961 BOOL WINAPI PathIsUNCA(_In_ LPCSTR);
962 BOOL WINAPI PathIsUNCW(_In_ LPCWSTR);
963 #define PathIsUNC WINELIB_NAME_AW(PathIsUNC)
964
965 BOOL WINAPI PathIsUNCServerA(_In_ LPCSTR);
966 BOOL WINAPI PathIsUNCServerW(_In_ LPCWSTR);
967 #define PathIsUNCServer WINELIB_NAME_AW(PathIsUNCServer)
968
969 BOOL WINAPI PathIsUNCServerShareA(_In_ LPCSTR);
970 BOOL WINAPI PathIsUNCServerShareW(_In_ LPCWSTR);
971 #define PathIsUNCServerShare WINELIB_NAME_AW(PathIsUNCServerShare)
972
973 BOOL WINAPI PathIsContentTypeA(_In_ LPCSTR, _In_ LPCSTR);
974 BOOL WINAPI PathIsContentTypeW(_In_ LPCWSTR, _In_ LPCWSTR);
975 #define PathIsContentType WINELIB_NAME_AW(PathIsContentType)
976
977 BOOL WINAPI PathIsURLA(_In_ LPCSTR);
978 BOOL WINAPI PathIsURLW(_In_ LPCWSTR);
979 #define PathIsURL WINELIB_NAME_AW(PathIsURL)
980
981 BOOL WINAPI PathMakePrettyA(_Inout_ LPSTR);
982 BOOL WINAPI PathMakePrettyW(_Inout_ LPWSTR);
983 #define PathMakePretty WINELIB_NAME_AW(PathMakePretty)
984
985 BOOL WINAPI PathMatchSpecA(_In_ LPCSTR, _In_ LPCSTR);
986 BOOL WINAPI PathMatchSpecW(_In_ LPCWSTR, _In_ LPCWSTR);
987 #define PathMatchSpec WINELIB_NAME_AW(PathMatchSpec)
988
989 int WINAPI PathParseIconLocationA(_Inout_ LPSTR);
990 int WINAPI PathParseIconLocationW(_Inout_ LPWSTR);
991 #define PathParseIconLocation WINELIB_NAME_AW(PathParseIconLocation)
992
993 VOID WINAPI PathQuoteSpacesA(_Inout_updates_(MAX_PATH) LPSTR);
994 VOID WINAPI PathQuoteSpacesW(_Inout_updates_(MAX_PATH) LPWSTR);
995 #define PathQuoteSpaces WINELIB_NAME_AW(PathQuoteSpaces)
996
997 BOOL
998 WINAPI
999 PathRelativePathToA(
1000 _Out_writes_(MAX_PATH) LPSTR,
1001 _In_ LPCSTR,
1002 _In_ DWORD,
1003 _In_ LPCSTR,
1004 _In_ DWORD);
1005
1006 BOOL
1007 WINAPI
1008 PathRelativePathToW(
1009 _Out_writes_(MAX_PATH) LPWSTR,
1010 _In_ LPCWSTR,
1011 _In_ DWORD,
1012 _In_ LPCWSTR,
1013 _In_ DWORD);
1014
1015 #define PathRelativePathTo WINELIB_NAME_AW(PathRelativePathTo)
1016
1017 VOID WINAPI PathRemoveArgsA(_Inout_ LPSTR);
1018 VOID WINAPI PathRemoveArgsW(_Inout_ LPWSTR);
1019 #define PathRemoveArgs WINELIB_NAME_AW(PathRemoveArgs)
1020
1021 LPSTR WINAPI PathRemoveBackslashA(_Inout_ LPSTR);
1022 LPWSTR WINAPI PathRemoveBackslashW(_Inout_ LPWSTR);
1023 #define PathRemoveBackslash WINELIB_NAME_AW(PathRemoveBackslash)
1024
1025 VOID WINAPI PathRemoveBlanksA(_Inout_ LPSTR);
1026 VOID WINAPI PathRemoveBlanksW(_Inout_ LPWSTR);
1027 #define PathRemoveBlanks WINELIB_NAME_AW(PathRemoveBlanks)
1028
1029 VOID WINAPI PathRemoveExtensionA(_Inout_ LPSTR);
1030 VOID WINAPI PathRemoveExtensionW(_Inout_ LPWSTR);
1031 #define PathRemoveExtension WINELIB_NAME_AW(PathRemoveExtension)
1032
1033 BOOL WINAPI PathRemoveFileSpecA(_Inout_ LPSTR);
1034 BOOL WINAPI PathRemoveFileSpecW(_Inout_ LPWSTR);
1035 #define PathRemoveFileSpec WINELIB_NAME_AW(PathRemoveFileSpec)
1036
1037 BOOL
1038 WINAPI
1039 PathRenameExtensionA(
1040 _Inout_updates_(MAX_PATH) LPSTR,
1041 _In_ LPCSTR);
1042
1043 BOOL
1044 WINAPI
1045 PathRenameExtensionW(
1046 _Inout_updates_(MAX_PATH) LPWSTR,
1047 _In_ LPCWSTR);
1048
1049 #define PathRenameExtension WINELIB_NAME_AW(PathRenameExtension)
1050
1051 BOOL
1052 WINAPI
1053 PathSearchAndQualifyA(
1054 _In_ LPCSTR,
1055 _Out_writes_(cchBuf) LPSTR,
1056 _In_ UINT cchBuf);
1057
1058 BOOL
1059 WINAPI
1060 PathSearchAndQualifyW(
1061 _In_ LPCWSTR,
1062 _Out_writes_(cchBuf) LPWSTR,
1063 _In_ UINT cchBuf);
1064
1065 #define PathSearchAndQualify WINELIB_NAME_AW(PathSearchAndQualify)
1066
1067 VOID WINAPI PathSetDlgItemPathA(_In_ HWND, int, LPCSTR);
1068 VOID WINAPI PathSetDlgItemPathW(_In_ HWND, int, LPCWSTR);
1069 #define PathSetDlgItemPath WINELIB_NAME_AW(PathSetDlgItemPath)
1070
1071 LPSTR WINAPI PathSkipRootA(_In_ LPCSTR);
1072 LPWSTR WINAPI PathSkipRootW(_In_ LPCWSTR);
1073 #define PathSkipRoot WINELIB_NAME_AW(PathSkipRoot)
1074
1075 VOID WINAPI PathStripPathA(_Inout_ LPSTR);
1076 VOID WINAPI PathStripPathW(_Inout_ LPWSTR);
1077 #define PathStripPath WINELIB_NAME_AW(PathStripPath)
1078
1079 BOOL WINAPI PathStripToRootA(_Inout_ LPSTR);
1080 BOOL WINAPI PathStripToRootW(_Inout_ LPWSTR);
1081 #define PathStripToRoot WINELIB_NAME_AW(PathStripToRoot)
1082
1083 VOID WINAPI PathUnquoteSpacesA(_Inout_ LPSTR);
1084 VOID WINAPI PathUnquoteSpacesW(_Inout_ LPWSTR);
1085 #define PathUnquoteSpaces WINELIB_NAME_AW(PathUnquoteSpaces)
1086
1087 BOOL WINAPI PathMakeSystemFolderA(_In_ LPCSTR);
1088 BOOL WINAPI PathMakeSystemFolderW(_In_ LPCWSTR);
1089 #define PathMakeSystemFolder WINELIB_NAME_AW(PathMakeSystemFolder)
1090
1091 BOOL WINAPI PathUnmakeSystemFolderA(_In_ LPCSTR);
1092 BOOL WINAPI PathUnmakeSystemFolderW(_In_ LPCWSTR);
1093 #define PathUnmakeSystemFolder WINELIB_NAME_AW(PathUnmakeSystemFolder)
1094
1095 BOOL WINAPI PathIsSystemFolderA(_In_opt_ LPCSTR, _In_ DWORD);
1096 BOOL WINAPI PathIsSystemFolderW(_In_opt_ LPCWSTR, _In_ DWORD);
1097 #define PathIsSystemFolder WINELIB_NAME_AW(PathIsSystemFolder)
1098
1099 BOOL WINAPI PathIsNetworkPathA(_In_ LPCSTR);
1100 BOOL WINAPI PathIsNetworkPathW(_In_ LPCWSTR);
1101 #define PathIsNetworkPath WINELIB_NAME_AW(PathIsNetworkPath)
1102
1103 BOOL WINAPI PathIsLFNFileSpecA(_In_ LPCSTR);
1104 BOOL WINAPI PathIsLFNFileSpecW(_In_ LPCWSTR);
1105 #define PathIsLFNFileSpec WINELIB_NAME_AW(PathIsLFNFileSpec)
1106
1107 LPCSTR
1108 WINAPI
1109 PathFindSuffixArrayA(
1110 _In_ LPCSTR,
1111 _In_reads_(iArraySize) LPCSTR *,
1112 int iArraySize);
1113
1114 LPCWSTR
1115 WINAPI
1116 PathFindSuffixArrayW(
1117 _In_ LPCWSTR,
1118 _In_reads_(iArraySize) LPCWSTR *,
1119 int iArraySize);
1120
1121 #define PathFindSuffixArray WINELIB_NAME_AW(PathFindSuffixArray)
1122
1123 VOID WINAPI PathUndecorateA(_Inout_ LPSTR);
1124 VOID WINAPI PathUndecorateW(_Inout_ LPWSTR);
1125 #define PathUndecorate WINELIB_NAME_AW(PathUndecorate)
1126
1127 BOOL
1128 WINAPI
1129 PathUnExpandEnvStringsA(
1130 _In_ LPCSTR,
1131 _Out_writes_(cchBuf) LPSTR,
1132 _In_ UINT cchBuf);
1133
1134 BOOL
1135 WINAPI
1136 PathUnExpandEnvStringsW(
1137 _In_ LPCWSTR,
1138 _Out_writes_(cchBuf) LPWSTR,
1139 _In_ UINT cchBuf);
1140
1141 #define PathUnExpandEnvStrings WINELIB_NAME_AW(PathUnExpandEnvStrings)
1142
1143 /* Url functions */
1144 typedef enum {
1145 URL_SCHEME_INVALID = -1,
1146 URL_SCHEME_UNKNOWN = 0,
1147 URL_SCHEME_FTP,
1148 URL_SCHEME_HTTP,
1149 URL_SCHEME_GOPHER,
1150 URL_SCHEME_MAILTO,
1151 URL_SCHEME_NEWS,
1152 URL_SCHEME_NNTP,
1153 URL_SCHEME_TELNET,
1154 URL_SCHEME_WAIS,
1155 URL_SCHEME_FILE,
1156 URL_SCHEME_MK,
1157 URL_SCHEME_HTTPS,
1158 URL_SCHEME_SHELL,
1159 URL_SCHEME_SNEWS,
1160 URL_SCHEME_LOCAL,
1161 URL_SCHEME_JAVASCRIPT,
1162 URL_SCHEME_VBSCRIPT,
1163 URL_SCHEME_ABOUT,
1164 URL_SCHEME_RES,
1165 URL_SCHEME_MSSHELLROOTED,
1166 URL_SCHEME_MSSHELLIDLIST,
1167 URL_SCHEME_MSHELP,
1168 URL_SCHEME_MSSHELLDEVICE,
1169 URL_SCHEME_WILDCARD,
1170 URL_SCHEME_SEARCH_MS,
1171 URL_SCHEME_SEARCH,
1172 URL_SCHEME_KNOWNFOLDER,
1173 URL_SCHEME_MAXVALUE
1174 } URL_SCHEME;
1175
1176 /* These are used by UrlGetPart routine */
1177 typedef enum {
1178 URL_PART_NONE = 0,
1179 URL_PART_SCHEME = 1,
1180 URL_PART_HOSTNAME,
1181 URL_PART_USERNAME,
1182 URL_PART_PASSWORD,
1183 URL_PART_PORT,
1184 URL_PART_QUERY
1185 } URL_PART;
1186
1187 #define URL_PARTFLAG_KEEPSCHEME 0x00000001
1188
1189 /* These are used by the UrlIs... routines */
1190 typedef enum {
1191 URLIS_URL,
1192 URLIS_OPAQUE,
1193 URLIS_NOHISTORY,
1194 URLIS_FILEURL,
1195 URLIS_APPLIABLE,
1196 URLIS_DIRECTORY,
1197 URLIS_HASQUERY
1198 } URLIS;
1199
1200 /* This is used by the UrlApplyScheme... routines */
1201 #define URL_APPLY_FORCEAPPLY 0x00000008
1202 #define URL_APPLY_GUESSFILE 0x00000004
1203 #define URL_APPLY_GUESSSCHEME 0x00000002
1204 #define URL_APPLY_DEFAULT 0x00000001
1205
1206 /* The following are used by UrlEscape..., UrlUnEscape...,
1207 * UrlCanonicalize..., and UrlCombine... routines
1208 */
1209 #define URL_WININET_COMPATIBILITY 0x80000000
1210 #define URL_PLUGGABLE_PROTOCOL 0x40000000
1211 #define URL_ESCAPE_UNSAFE 0x20000000
1212 #define URL_UNESCAPE 0x10000000
1213
1214 #define URL_DONT_SIMPLIFY 0x08000000
1215 #define URL_NO_META URL_DONT_SIMPLIFY
1216 #define URL_ESCAPE_SPACES_ONLY 0x04000000
1217 #define URL_DONT_ESCAPE_EXTRA_INFO 0x02000000
1218 #define URL_DONT_UNESCAPE_EXTRA_INFO URL_DONT_ESCAPE_EXTRA_INFO
1219 #define URL_BROWSER_MODE URL_DONT_ESCAPE_EXTRA_INFO
1220
1221 #define URL_INTERNAL_PATH 0x00800000 /* Will escape #'s in paths */
1222 #define URL_UNESCAPE_HIGH_ANSI_ONLY 0x00400000
1223 #define URL_CONVERT_IF_DOSPATH 0x00200000
1224 #define URL_UNESCAPE_INPLACE 0x00100000
1225
1226 #define URL_FILE_USE_PATHURL 0x00010000
1227 #define URL_ESCAPE_AS_UTF8 0x00040000
1228
1229 #define URL_ESCAPE_SEGMENT_ONLY 0x00002000
1230 #define URL_ESCAPE_PERCENT 0x00001000
1231
1232 HRESULT
1233 WINAPI
1234 UrlApplySchemeA(
1235 _In_ LPCSTR,
1236 _Out_writes_(*pcchOut) LPSTR,
1237 _Inout_ LPDWORD pcchOut,
1238 DWORD);
1239
1240 HRESULT
1241 WINAPI
1242 UrlApplySchemeW(
1243 _In_ LPCWSTR,
1244 _Out_writes_(*pcchOut) LPWSTR,
1245 _Inout_ LPDWORD pcchOut,
1246 DWORD);
1247
1248 #define UrlApplyScheme WINELIB_NAME_AW(UrlApplyScheme)
1249
1250 HRESULT
1251 WINAPI
1252 UrlCanonicalizeA(
1253 _In_ LPCSTR,
1254 _Out_writes_to_(*pcchCanonicalized, *pcchCanonicalized) LPSTR,
1255 _Inout_ LPDWORD pcchCanonicalized,
1256 DWORD);
1257
1258 HRESULT
1259 WINAPI
1260 UrlCanonicalizeW(
1261 _In_ LPCWSTR,
1262 _Out_writes_to_(*pcchCanonicalized, *pcchCanonicalized) LPWSTR,
1263 _Inout_ LPDWORD pcchCanonicalized,
1264 DWORD);
1265
1266 #define UrlCanonicalize WINELIB_NAME_AW(UrlCanonicalize)
1267
1268 HRESULT
1269 WINAPI
1270 UrlCombineA(
1271 _In_ LPCSTR,
1272 _In_ LPCSTR,
1273 _Out_writes_to_opt_(*pcchCombined, *pcchCombined) LPSTR,
1274 _Inout_ LPDWORD pcchCombined,
1275 DWORD);
1276
1277 HRESULT
1278 WINAPI
1279 UrlCombineW(
1280 _In_ LPCWSTR,
1281 _In_ LPCWSTR,
1282 _Out_writes_to_opt_(*pcchCombined, *pcchCombined) LPWSTR,
1283 _Inout_ LPDWORD pcchCombined,
1284 DWORD);
1285
1286 #define UrlCombine WINELIB_NAME_AW(UrlCombine)
1287
1288 INT WINAPI UrlCompareA(_In_ LPCSTR, _In_ LPCSTR, BOOL);
1289 INT WINAPI UrlCompareW(_In_ LPCWSTR, _In_ LPCWSTR, BOOL);
1290 #define UrlCompare WINELIB_NAME_AW(UrlCompare)
1291
1292 HRESULT
1293 WINAPI
1294 UrlEscapeA(
1295 _In_ LPCSTR,
1296 _Out_writes_to_(*pcchEscaped, *pcchEscaped) LPSTR,
1297 _Inout_ LPDWORD pcchEscaped,
1298 DWORD);
1299
1300 HRESULT
1301 WINAPI
1302 UrlEscapeW(
1303 _In_ LPCWSTR,
1304 _Out_writes_to_(*pcchEscaped, *pcchEscaped) LPWSTR,
1305 _Inout_ LPDWORD pcchEscaped,
1306 DWORD);
1307
1308 #define UrlEscape WINELIB_NAME_AW(UrlEscape)
1309
1310 #define UrlEscapeSpacesA(x,y,z) UrlCanonicalizeA(x, y, z, \
1311 URL_DONT_ESCAPE_EXTRA_INFO|URL_ESCAPE_SPACES_ONLY)
1312 #define UrlEscapeSpacesW(x,y,z) UrlCanonicalizeW(x, y, z, \
1313 URL_DONT_ESCAPE_EXTRA_INFO|URL_ESCAPE_SPACES_ONLY)
1314 #define UrlEscapeSpaces WINELIB_NAME_AW(UrlEscapeSpaces)
1315
1316 LPCSTR WINAPI UrlGetLocationA(_In_ LPCSTR);
1317 LPCWSTR WINAPI UrlGetLocationW(_In_ LPCWSTR);
1318 #define UrlGetLocation WINELIB_NAME_AW(UrlGetLocation)
1319
1320 HRESULT
1321 WINAPI
1322 UrlGetPartA(
1323 _In_ LPCSTR,
1324 _Out_writes_(*pcchOut) LPSTR,
1325 _Inout_ LPDWORD pcchOut,
1326 DWORD,
1327 DWORD);
1328
1329 HRESULT
1330 WINAPI
1331 UrlGetPartW(
1332 _In_ LPCWSTR,
1333 _Out_writes_(*pcchOut) LPWSTR,
1334 _Inout_ LPDWORD pcchOut,
1335 DWORD,
1336 DWORD);
1337
1338 #define UrlGetPart WINELIB_NAME_AW(UrlGetPart)
1339
1340 HRESULT
1341 WINAPI
1342 HashData(
1343 _In_reads_bytes_(cbData) const unsigned char *,
1344 DWORD cbData,
1345 _Out_writes_bytes_(cbHash) unsigned char *lpDest,
1346 DWORD cbHash);
1347
1348 HRESULT
1349 WINAPI
1350 UrlHashA(
1351 _In_ LPCSTR,
1352 _Out_writes_bytes_(cbHash) unsigned char *,
1353 DWORD cbHash);
1354
1355 HRESULT
1356 WINAPI
1357 UrlHashW(
1358 _In_ LPCWSTR,
1359 _Out_writes_bytes_(cbHash) unsigned char *,
1360 DWORD cbHash);
1361
1362 #define UrlHash WINELIB_NAME_AW(UrlHash)
1363
1364 BOOL WINAPI UrlIsA(_In_ LPCSTR, URLIS);
1365 BOOL WINAPI UrlIsW(_In_ LPCWSTR, URLIS);
1366 #define UrlIs WINELIB_NAME_AW(UrlIs)
1367
1368 BOOL WINAPI UrlIsNoHistoryA(_In_ LPCSTR);
1369 BOOL WINAPI UrlIsNoHistoryW(_In_ LPCWSTR);
1370 #define UrlIsNoHistory WINELIB_NAME_AW(UrlIsNoHistory)
1371
1372 BOOL WINAPI UrlIsOpaqueA(_In_ LPCSTR);
1373 BOOL WINAPI UrlIsOpaqueW(_In_ LPCWSTR);
1374 #define UrlIsOpaque WINELIB_NAME_AW(UrlIsOpaque)
1375
1376 #define UrlIsFileUrlA(x) UrlIsA(x, URLIS_FILEURL)
1377 #define UrlIsFileUrlW(x) UrlIsW(x, URLIS_FILEURL)
1378 #define UrlIsFileUrl WINELIB_NAME_AW(UrlIsFileUrl)
1379
1380 HRESULT
1381 WINAPI
1382 UrlUnescapeA(
1383 _Inout_ LPSTR,
1384 _Out_writes_to_opt_(*pcchUnescaped, *pcchUnescaped) LPSTR,
1385 _Inout_opt_ LPDWORD pcchUnescaped,
1386 DWORD);
1387
1388 HRESULT
1389 WINAPI
1390 UrlUnescapeW(
1391 _Inout_ LPWSTR,
1392 _Out_writes_to_opt_(*pcchUnescaped, *pcchUnescaped) LPWSTR,
1393 _Inout_opt_ LPDWORD pcchUnescaped,
1394 DWORD);
1395
1396 #define UrlUnescape WINELIB_NAME_AW(UrlUnescape)
1397
1398 #define UrlUnescapeInPlaceA(x,y) UrlUnescapeA(x, NULL, NULL, \
1399 y | URL_UNESCAPE_INPLACE)
1400 #define UrlUnescapeInPlaceW(x,y) UrlUnescapeW(x, NULL, NULL, \
1401 y | URL_UNESCAPE_INPLACE)
1402 #define UrlUnescapeInPlace WINELIB_NAME_AW(UrlUnescapeInPlace)
1403
1404 HRESULT
1405 WINAPI
1406 UrlCreateFromPathA(
1407 _In_ LPCSTR,
1408 _Out_writes_to_(*pcchUrl, *pcchUrl) LPSTR,
1409 _Inout_ LPDWORD pcchUrl,
1410 DWORD);
1411
1412 HRESULT
1413 WINAPI
1414 UrlCreateFromPathW(
1415 _In_ LPCWSTR,
1416 _Out_writes_to_(*pcchUrl, *pcchUrl) LPWSTR,
1417 _Inout_ LPDWORD pcchUrl,
1418 DWORD);
1419
1420 #define UrlCreateFromPath WINELIB_NAME_AW(UrlCreateFromPath)
1421
1422 typedef struct tagPARSEDURLA {
1423 DWORD cbSize;
1424 LPCSTR pszProtocol;
1425 UINT cchProtocol;
1426 LPCSTR pszSuffix;
1427 UINT cchSuffix;
1428 UINT nScheme;
1429 } PARSEDURLA, *PPARSEDURLA;
1430
1431 typedef struct tagPARSEDURLW {
1432 DWORD cbSize;
1433 LPCWSTR pszProtocol;
1434 UINT cchProtocol;
1435 LPCWSTR pszSuffix;
1436 UINT cchSuffix;
1437 UINT nScheme;
1438 } PARSEDURLW, *PPARSEDURLW;
1439
1440 HRESULT WINAPI ParseURLA(_In_ LPCSTR pszUrl, _Inout_ PARSEDURLA *ppu);
1441 HRESULT WINAPI ParseURLW(_In_ LPCWSTR pszUrl, _Inout_ PARSEDURLW *ppu);
1442 #define ParseURL WINELIB_NAME_AW(ParseUrl)
1443
1444 #endif /* NO_SHLWAPI_PATH */
1445
1446
1447 /* String functions */
1448 #ifndef NO_SHLWAPI_STRFCNS
1449
1450 /* StrToIntEx flags */
1451 #define STIF_DEFAULT 0x0L
1452 #define STIF_SUPPORT_HEX 0x1L
1453
1454 BOOL WINAPI ChrCmpIA (WORD,WORD);
1455 BOOL WINAPI ChrCmpIW (WCHAR,WCHAR);
1456 #define ChrCmpI WINELIB_NAME_AW(ChrCmpI)
1457
1458 INT WINAPI StrCSpnA(_In_ LPCSTR, _In_ LPCSTR);
1459 INT WINAPI StrCSpnW(_In_ LPCWSTR, _In_ LPCWSTR);
1460 #define StrCSpn WINELIB_NAME_AW(StrCSpn)
1461
1462 INT WINAPI StrCSpnIA(_In_ LPCSTR, _In_ LPCSTR);
1463 INT WINAPI StrCSpnIW(_In_ LPCWSTR, _In_ LPCWSTR);
1464 #define StrCSpnI WINELIB_NAME_AW(StrCSpnI)
1465
1466 #define StrCatA lstrcatA
1467 LPWSTR WINAPI StrCatW(_Inout_ LPWSTR, _In_ LPCWSTR);
1468 #define StrCat WINELIB_NAME_AW(StrCat)
1469
1470 LPSTR
1471 WINAPI
1472 StrCatBuffA(
1473 _Inout_updates_(cchDestBuffSize) LPSTR,
1474 _In_ LPCSTR,
1475 INT cchDestBuffSize);
1476
1477 LPWSTR
1478 WINAPI
1479 StrCatBuffW(
1480 _Inout_updates_(cchDestBuffSize) LPWSTR,
1481 _In_ LPCWSTR,
1482 INT cchDestBuffSize);
1483
1484 #define StrCatBuff WINELIB_NAME_AW(StrCatBuff)
1485
1486 DWORD
1487 WINAPI
1488 StrCatChainW(
1489 _Out_writes_(cchDst) LPWSTR,
1490 DWORD cchDst,
1491 DWORD,
1492 _In_ LPCWSTR);
1493
1494 LPSTR WINAPI StrChrA(_In_ LPCSTR, WORD);
1495 LPWSTR WINAPI StrChrW(_In_ LPCWSTR, WCHAR);
1496 #define StrChr WINELIB_NAME_AW(StrChr)
1497
1498 LPSTR WINAPI StrChrIA(_In_ LPCSTR, WORD);
1499 LPWSTR WINAPI StrChrIW(_In_ LPCWSTR, WCHAR);
1500 #define StrChrI WINELIB_NAME_AW(StrChrI)
1501
1502 #define StrCmpA lstrcmpA
1503 int WINAPI StrCmpW(_In_ LPCWSTR, _In_ LPCWSTR);
1504 #define StrCmp WINELIB_NAME_AW(StrCmp)
1505
1506 #define StrCmpIA lstrcmpiA
1507 int WINAPI StrCmpIW(_In_ LPCWSTR, _In_ LPCWSTR);
1508 #define StrCmpI WINELIB_NAME_AW(StrCmpI)
1509
1510 #define StrCpyA lstrcpyA
1511 LPWSTR WINAPI StrCpyW(_Out_ LPWSTR, _In_ LPCWSTR);
1512 #define StrCpy WINELIB_NAME_AW(StrCpy)
1513
1514 #define StrCpyNA lstrcpynA
1515 LPWSTR WINAPI StrCpyNW(_Out_writes_(cchMax) LPWSTR, _In_ LPCWSTR, int cchMax);
1516 #define StrCpyN WINELIB_NAME_AW(StrCpyN)
1517 #define StrNCpy WINELIB_NAME_AW(StrCpyN)
1518
1519 INT WINAPI StrCmpLogicalW(_In_ LPCWSTR, _In_ LPCWSTR);
1520
1521 INT WINAPI StrCmpNA(_In_ LPCSTR, _In_ LPCSTR, INT);
1522 INT WINAPI StrCmpNW(_In_ LPCWSTR, _In_ LPCWSTR, INT);
1523 #define StrCmpN WINELIB_NAME_AW(StrCmpN)
1524 #define StrNCmp WINELIB_NAME_AW(StrCmpN)
1525
1526 INT WINAPI StrCmpNIA(_In_ LPCSTR, _In_ LPCSTR, INT);
1527 INT WINAPI StrCmpNIW(_In_ LPCWSTR, _In_ LPCWSTR, INT);
1528 #define StrCmpNI WINELIB_NAME_AW(StrCmpNI)
1529 #define StrNCmpI WINELIB_NAME_AW(StrCmpNI)
1530
1531 LPSTR WINAPI StrDupA(_In_ LPCSTR);
1532 LPWSTR WINAPI StrDupW(_In_ LPCWSTR);
1533 #define StrDup WINELIB_NAME_AW(StrDup)
1534
1535 HRESULT WINAPI SHStrDupA(_In_ LPCSTR, _Outptr_ WCHAR**);
1536 HRESULT WINAPI SHStrDupW(_In_ LPCWSTR, _Outptr_ WCHAR**);
1537 #define SHStrDup WINELIB_NAME_AW(SHStrDup)
1538
1539 LPSTR
1540 WINAPI
1541 StrFormatByteSizeA(
1542 DWORD,
1543 _Out_writes_(cchBuf) LPSTR,
1544 UINT cchBuf);
1545
1546 /* A/W Pairing is broken for this function */
1547
1548 LPSTR
1549 WINAPI
1550 StrFormatByteSize64A(
1551 LONGLONG,
1552 _Out_writes_(cchBuf) LPSTR,
1553 UINT cchBuf);
1554
1555 LPWSTR
1556 WINAPI
1557 StrFormatByteSizeW(
1558 LONGLONG,
1559 _Out_writes_(cchBuf) LPWSTR,
1560 UINT cchBuf);
1561
1562 #ifndef WINE_NO_UNICODE_MACROS
1563 #ifdef UNICODE
1564 #define StrFormatByteSize StrFormatByteSizeW
1565 #else
1566 #define StrFormatByteSize StrFormatByteSize64A
1567 #endif
1568 #endif
1569
1570 LPSTR
1571 WINAPI
1572 StrFormatKBSizeA(
1573 LONGLONG,
1574 _Out_writes_(cchBuf) LPSTR,
1575 UINT cchBuf);
1576
1577 LPWSTR
1578 WINAPI
1579 StrFormatKBSizeW(
1580 LONGLONG,
1581 _Out_writes_(cchBuf) LPWSTR,
1582 UINT cchBuf);
1583
1584 #define StrFormatKBSize WINELIB_NAME_AW(StrFormatKBSize)
1585
1586 int
1587 WINAPI
1588 StrFromTimeIntervalA(
1589 _Out_writes_(cchMax) LPSTR,
1590 UINT cchMax,
1591 DWORD,
1592 int);
1593
1594 int
1595 WINAPI
1596 StrFromTimeIntervalW(
1597 _Out_writes_(cchMax) LPWSTR,
1598 UINT cchMax,
1599 DWORD,
1600 int);
1601
1602 #define StrFromTimeInterval WINELIB_NAME_AW(StrFromTimeInterval)
1603
1604 BOOL WINAPI StrIsIntlEqualA(BOOL, _In_ LPCSTR, _In_ LPCSTR, int);
1605 BOOL WINAPI StrIsIntlEqualW(BOOL, _In_ LPCWSTR, _In_ LPCWSTR, int);
1606 #define StrIsIntlEqual WINELIB_NAME_AW(StrIsIntlEqual)
1607
1608 #define StrIntlEqNA(a,b,c) StrIsIntlEqualA(TRUE,a,b,c)
1609 #define StrIntlEqNW(a,b,c) StrIsIntlEqualW(TRUE,a,b,c)
1610
1611 #define StrIntlEqNIA(a,b,c) StrIsIntlEqualA(FALSE,a,b,c)
1612 #define StrIntlEqNIW(a,b,c) StrIsIntlEqualW(FALSE,a,b,c)
1613
1614 LPSTR WINAPI StrNCatA(_Inout_updates_(cchMax) LPSTR, LPCSTR, int cchMax);
1615 LPWSTR WINAPI StrNCatW(_Inout_updates_(cchMax) LPWSTR, LPCWSTR, int cchMax);
1616 #define StrNCat WINELIB_NAME_AW(StrNCat)
1617 #define StrCatN WINELIB_NAME_AW(StrNCat)
1618
1619 LPSTR WINAPI StrPBrkA(_In_ LPCSTR, _In_ LPCSTR);
1620 LPWSTR WINAPI StrPBrkW(_In_ LPCWSTR, _In_ LPCWSTR);
1621 #define StrPBrk WINELIB_NAME_AW(StrPBrk)
1622
1623 LPSTR WINAPI StrRChrA(_In_ LPCSTR, _In_opt_ LPCSTR, WORD);
1624 LPWSTR WINAPI StrRChrW(_In_ LPCWSTR, _In_opt_ LPCWSTR, WCHAR);
1625 #define StrRChr WINELIB_NAME_AW(StrRChr)
1626
1627 LPSTR WINAPI StrRChrIA(_In_ LPCSTR, _In_opt_ LPCSTR, WORD);
1628 LPWSTR WINAPI StrRChrIW(_In_ LPCWSTR, _In_opt_ LPCWSTR, WCHAR);
1629 #define StrRChrI WINELIB_NAME_AW(StrRChrI)
1630
1631 LPSTR WINAPI StrRStrIA(_In_ LPCSTR, _In_opt_ LPCSTR, _In_ LPCSTR);
1632 LPWSTR WINAPI StrRStrIW(_In_ LPCWSTR, _In_opt_ LPCWSTR, _In_ LPCWSTR);
1633 #define StrRStrI WINELIB_NAME_AW(StrRStrI)
1634
1635 int WINAPI StrSpnA(_In_ LPCSTR, _In_ LPCSTR);
1636 int WINAPI StrSpnW(_In_ LPCWSTR, _In_ LPCWSTR);
1637 #define StrSpn WINELIB_NAME_AW(StrSpn)
1638
1639 LPSTR WINAPI StrStrA(_In_ LPCSTR, _In_ LPCSTR);
1640 LPWSTR WINAPI StrStrW(_In_ LPCWSTR, _In_ LPCWSTR);
1641 #define StrStr WINELIB_NAME_AW(StrStr)
1642
1643 LPSTR WINAPI StrStrIA(_In_ LPCSTR, _In_ LPCSTR);
1644 LPWSTR WINAPI StrStrIW(_In_ LPCWSTR, _In_ LPCWSTR);
1645 #define StrStrI WINELIB_NAME_AW(StrStrI)
1646
1647 LPWSTR WINAPI StrStrNW(_In_ LPCWSTR, _In_ LPCWSTR, UINT);
1648 LPWSTR WINAPI StrStrNIW(_In_ LPCWSTR, _In_ LPCWSTR, UINT);
1649
1650 int WINAPI StrToIntA(_In_ LPCSTR);
1651 int WINAPI StrToIntW(_In_ LPCWSTR);
1652 #define StrToInt WINELIB_NAME_AW(StrToInt)
1653 #define StrToLong WINELIB_NAME_AW(StrToInt)
1654
1655 BOOL WINAPI StrToIntExA(_In_ LPCSTR, DWORD, _Out_ int*);
1656 BOOL WINAPI StrToIntExW(_In_ LPCWSTR, DWORD, _Out_ int*);
1657 #define StrToIntEx WINELIB_NAME_AW(StrToIntEx)
1658
1659 BOOL WINAPI StrToInt64ExA(_In_ LPCSTR, DWORD, _Out_ LONGLONG*);
1660 BOOL WINAPI StrToInt64ExW(_In_ LPCWSTR, DWORD, _Out_ LONGLONG*);
1661 #define StrToIntEx64 WINELIB_NAME_AW(StrToIntEx64)
1662
1663 BOOL WINAPI StrTrimA(_Inout_ LPSTR, _In_ LPCSTR);
1664 BOOL WINAPI StrTrimW(_Inout_ LPWSTR, _In_ LPCWSTR);
1665 #define StrTrim WINELIB_NAME_AW(StrTrim)
1666
1667 INT
1668 WINAPI
1669 wvnsprintfA(
1670 _Out_writes_(cchDest) LPSTR,
1671 _In_ INT cchDest,
1672 _In_ _Printf_format_string_ LPCSTR,
1673 _In_ __ms_va_list);
1674
1675 INT
1676 WINAPI
1677 wvnsprintfW(
1678 _Out_writes_(cchDest) LPWSTR,
1679 _In_ INT cchDest,
1680 _In_ _Printf_format_string_ LPCWSTR,
1681 _In_ __ms_va_list);
1682
1683 #define wvnsprintf WINELIB_NAME_AW(wvnsprintf)
1684
1685 INT
1686 WINAPIV
1687 wnsprintfA(
1688 _Out_writes_(cchDest) LPSTR,
1689 _In_ INT cchDest,
1690 _In_ _Printf_format_string_ LPCSTR,
1691 ...);
1692
1693 INT
1694 WINAPIV
1695 wnsprintfW(
1696 _Out_writes_(cchDest) LPWSTR,
1697 _In_ INT cchDest,
1698 _In_ _Printf_format_string_ LPCWSTR,
1699 ...);
1700
1701 #define wnsprintf WINELIB_NAME_AW(wnsprintf)
1702
1703 HRESULT
1704 WINAPI
1705 SHLoadIndirectString(
1706 _In_ LPCWSTR,
1707 _Out_writes_(cchOutBuf) LPWSTR,
1708 _In_ UINT cchOutBuf,
1709 _Reserved_ PVOID*);
1710
1711 BOOL
1712 WINAPI
1713 IntlStrEqWorkerA(
1714 BOOL,
1715 _In_reads_(nChar) LPCSTR,
1716 _In_reads_(nChar) LPCSTR,
1717 int nChar);
1718
1719 BOOL
1720 WINAPI
1721 IntlStrEqWorkerW(
1722 BOOL,
1723 _In_reads_(nChar) LPCWSTR,
1724 _In_reads_(nChar) LPCWSTR,
1725 int nChar);
1726
1727 #define IntlStrEqWorker WINELIB_NAME_AW(IntlStrEqWorker)
1728
1729 #define IntlStrEqNA(s1,s2,n) IntlStrEqWorkerA(TRUE,s1,s2,n)
1730 #define IntlStrEqNW(s1,s2,n) IntlStrEqWorkerW(TRUE,s1,s2,n)
1731 #define IntlStrEqN WINELIB_NAME_AW(IntlStrEqN)
1732
1733 #define IntlStrEqNIA(s1,s2,n) IntlStrEqWorkerA(FALSE,s1,s2,n)
1734 #define IntlStrEqNIW(s1,s2,n) IntlStrEqWorkerW(FALSE,s1,s2,n)
1735 #define IntlStrEqNI WINELIB_NAME_AW(IntlStrEqNI)
1736
1737 HRESULT
1738 WINAPI
1739 StrRetToStrA(
1740 _Inout_ STRRET*,
1741 _In_opt_ LPCITEMIDLIST,
1742 _Outptr_ LPSTR*);
1743
1744 HRESULT
1745 WINAPI
1746 StrRetToStrW(
1747 _Inout_ STRRET*,
1748 _In_opt_ LPCITEMIDLIST,
1749 _Outptr_ LPWSTR*);
1750
1751 #define StrRetToStr WINELIB_NAME_AW(StrRetToStr)
1752
1753 HRESULT
1754 WINAPI
1755 StrRetToBufA(
1756 _Inout_ STRRET*,
1757 _In_opt_ LPCITEMIDLIST,
1758 _Out_writes_(cchBuf) LPSTR,
1759 UINT cchBuf);
1760
1761 HRESULT
1762 WINAPI
1763 StrRetToBufW(
1764 _Inout_ STRRET*,
1765 _In_opt_ LPCITEMIDLIST,
1766 _Out_writes_(cchBuf) LPWSTR,
1767 UINT cchBuf);
1768
1769 #define StrRetToBuf WINELIB_NAME_AW(StrRetToBuf)
1770
1771 HRESULT
1772 WINAPI
1773 StrRetToBSTR(
1774 _Inout_ STRRET*,
1775 _In_opt_ LPCITEMIDLIST,
1776 _Outptr_ BSTR*);
1777
1778 BOOL WINAPI IsCharSpaceA(CHAR);
1779 BOOL WINAPI IsCharSpaceW(WCHAR);
1780 #define IsCharSpace WINELIB_NAME_AW(IsCharSpace)
1781
1782 #endif /* NO_SHLWAPI_STRFCNS */
1783
1784
1785 /* GDI functions */
1786 #ifndef NO_SHLWAPI_GDI
1787
1788 HPALETTE WINAPI SHCreateShellPalette(_In_opt_ HDC);
1789
1790 COLORREF WINAPI ColorHLSToRGB(WORD,WORD,WORD);
1791
1792 COLORREF WINAPI ColorAdjustLuma(COLORREF,int,BOOL);
1793
1794 VOID WINAPI ColorRGBToHLS(COLORREF, _Out_ LPWORD, _Out_ LPWORD, _Out_ LPWORD);
1795
1796 #endif /* NO_SHLWAPI_GDI */
1797
1798 /* Security functions */
1799 BOOL WINAPI IsInternetESCEnabled(void);
1800
1801 /* Stream functions */
1802 #ifndef NO_SHLWAPI_STREAM
1803
1804 struct IStream *
1805 WINAPI
1806 SHOpenRegStreamA(
1807 _In_ HKEY,
1808 _In_opt_ LPCSTR,
1809 _In_opt_ LPCSTR,
1810 _In_ DWORD);
1811
1812 struct IStream *
1813 WINAPI
1814 SHOpenRegStreamW(
1815 _In_ HKEY,
1816 _In_opt_ LPCWSTR,
1817 _In_opt_ LPCWSTR,
1818 _In_ DWORD);
1819
1820 #define SHOpenRegStream WINELIB_NAME_AW(SHOpenRegStream2) /* Uses version 2 */
1821
1822 struct IStream *
1823 WINAPI
1824 SHOpenRegStream2A(
1825 _In_ HKEY,
1826 _In_opt_ LPCSTR,
1827 _In_opt_ LPCSTR,
1828 _In_ DWORD);
1829
1830 struct IStream *
1831 WINAPI
1832 SHOpenRegStream2W(
1833 _In_ HKEY,
1834 _In_opt_ LPCWSTR,
1835 _In_opt_ LPCWSTR,
1836 _In_ DWORD);
1837
1838 #define SHOpenRegStream2 WINELIB_NAME_AW(SHOpenRegStream2)
1839
1840 HRESULT
1841 WINAPI
1842 SHCreateStreamOnFileA(
1843 _In_ LPCSTR,
1844 _In_ DWORD,
1845 _Outptr_ struct IStream**);
1846
1847 HRESULT
1848 WINAPI
1849 SHCreateStreamOnFileW(
1850 _In_ LPCWSTR,
1851 _In_ DWORD,
1852 _Outptr_ struct IStream**);
1853
1854 #define SHCreateStreamOnFile WINELIB_NAME_AW(SHCreateStreamOnFile)
1855
1856 HRESULT
1857 WINAPI
1858 SHCreateStreamOnFileEx(
1859 _In_ LPCWSTR,
1860 _In_ DWORD,
1861 _In_ DWORD,
1862 _In_ BOOL,
1863 _In_opt_ struct IStream*,
1864 _Outptr_ struct IStream**);
1865
1866 HRESULT WINAPI SHCreateStreamWrapper(LPBYTE,DWORD,DWORD,struct IStream**);
1867
1868 #endif /* NO_SHLWAPI_STREAM */
1869
1870 #ifndef NO_SHLWAPI_SHARED
1871
1872 // These functions are only included in this file starting with the Windows 7 platform SDK
1873
1874 HANDLE
1875 WINAPI
1876 SHAllocShared(
1877 _In_opt_ const void *pvData,
1878 _In_ DWORD dwSize,
1879 _In_ DWORD dwDestinationProcessId
1880 );
1881
1882 PVOID
1883 WINAPI
1884 SHLockShared(
1885 _In_ HANDLE hData,
1886 _In_ DWORD dwProcessId
1887 );
1888
1889 BOOL
1890 WINAPI
1891 SHUnlockShared(
1892 _In_ void *pvData
1893 );
1894
1895 BOOL
1896 WINAPI
1897 SHFreeShared(
1898 _In_ HANDLE hData,
1899 _In_ DWORD dwProcessId
1900 );
1901
1902 #endif /* NO_SHLWAPI_SHARED */
1903
1904 /* SHAutoComplete flags */
1905 #define SHACF_DEFAULT 0x00000000
1906 #define SHACF_FILESYSTEM 0x00000001
1907 #define SHACF_URLHISTORY 0x00000002
1908 #define SHACF_URLMRU 0x00000004
1909 #define SHACF_URLALL (SHACF_URLHISTORY|SHACF_URLMRU)
1910 #define SHACF_USETAB 0x00000008
1911 #define SHACF_FILESYS_ONLY 0x00000010
1912 #define SHACF_FILESYS_DIRS 0x00000020
1913 #define SHACF_AUTOSUGGEST_FORCE_ON 0x10000000
1914 #define SHACF_AUTOSUGGEST_FORCE_OFF 0x20000000
1915 #define SHACF_AUTOAPPEND_FORCE_ON 0x40000000
1916 #define SHACF_AUTOAPPEND_FORCE_OFF 0x80000000
1917
1918 HRESULT WINAPI SHAutoComplete(_In_ HWND, DWORD);
1919
1920 /* Threads */
1921 HRESULT WINAPI SHCreateThreadRef(_Inout_ LONG*, _Outptr_ IUnknown**);
1922 HRESULT WINAPI SHGetThreadRef(_Outptr_ IUnknown**);
1923 HRESULT WINAPI SHSetThreadRef(_In_opt_ IUnknown*);
1924 HRESULT WINAPI SHReleaseThreadRef(void);
1925
1926 /* SHCreateThread flags */
1927 #define CTF_INSIST 0x01 /* Always call */
1928 #define CTF_THREAD_REF 0x02 /* Hold thread ref */
1929 #define CTF_PROCESS_REF 0x04 /* Hold process ref */
1930 #define CTF_COINIT 0x08 /* Startup COM first */
1931 #define CTF_FREELIBANDEXIT 0x10 /* Hold DLL ref */
1932 #define CTF_REF_COUNTED 0x20 /* Thread is ref counted */
1933 #define CTF_WAIT_ALLOWCOM 0x40 /* Allow marshalling */
1934
1935 BOOL
1936 WINAPI
1937 SHCreateThread(
1938 _In_ LPTHREAD_START_ROUTINE,
1939 _In_opt_ void*,
1940 _In_ DWORD,
1941 _In_opt_ LPTHREAD_START_ROUTINE);
1942
1943 BOOL WINAPI SHSkipJunction(_In_opt_ struct IBindCtx*, _In_ const CLSID*);
1944
1945 /* Version Information */
1946
1947 typedef struct _DllVersionInfo {
1948 DWORD cbSize;
1949 DWORD dwMajorVersion;
1950 DWORD dwMinorVersion;
1951 DWORD dwBuildNumber;
1952 DWORD dwPlatformID;
1953 } DLLVERSIONINFO;
1954
1955 #define DLLVER_PLATFORM_WINDOWS 0x01 /* Win9x */
1956 #define DLLVER_PLATFORM_NT 0x02 /* WinNT */
1957
1958 typedef HRESULT (CALLBACK *DLLGETVERSIONPROC)(DLLVERSIONINFO *);
1959
1960 #ifdef __WINESRC__
1961 /* shouldn't be here, but is nice for type checking */
1962 HRESULT WINAPI DllGetVersion(DLLVERSIONINFO *) DECLSPEC_HIDDEN;
1963 #endif
1964
1965 typedef struct _DLLVERSIONINFO2 {
1966 DLLVERSIONINFO info1;
1967 DWORD dwFlags; /* Reserved */
1968 ULONGLONG DECLSPEC_ALIGN(8) ullVersion; /* 16 bits each for Major, Minor, Build, QFE */
1969 } DLLVERSIONINFO2;
1970
1971 #define DLLVER_MAJOR_MASK 0xFFFF000000000000
1972 #define DLLVER_MINOR_MASK 0x0000FFFF00000000
1973 #define DLLVER_BUILD_MASK 0x00000000FFFF0000
1974 #define DLLVER_QFE_MASK 0x000000000000FFFF
1975
1976 #define MAKEDLLVERULL(mjr, mnr, bld, qfe) (((ULONGLONG)(mjr)<< 48)| \
1977 ((ULONGLONG)(mnr)<< 32) | ((ULONGLONG)(bld)<< 16) | (ULONGLONG)(qfe))
1978
1979 HRESULT WINAPI DllInstall(BOOL, _In_opt_ LPCWSTR) DECLSPEC_HIDDEN;
1980
1981
1982 #if (_WIN32_IE >= 0x0600)
1983 #define SHGVSPB_PERUSER 0x00000001
1984 #define SHGVSPB_ALLUSERS 0x00000002
1985 #define SHGVSPB_PERFOLDER 0x00000004
1986 #define SHGVSPB_ALLFOLDERS 0x00000008
1987 #define SHGVSPB_INHERIT 0x00000010
1988 #define SHGVSPB_ROAM 0x00000020
1989 #define SHGVSPB_NOAUTODEFAULTS 0x80000000
1990
1991 #define SHGVSPB_FOLDER (SHGVSPB_PERUSER | SHGVSPB_PERFOLDER)
1992 #define SHGVSPB_FOLDERNODEFAULTS (SHGVSPB_PERUSER | SHGVSPB_PERFOLDER | SHGVSPB_NOAUTODEFAULTS)
1993 #define SHGVSPB_USERDEFAULTS (SHGVSPB_PERUSER | SHGVSPB_ALLFOLDERS)
1994 #define SHGVSPB_GLOBALDEAFAULTS (SHGVSPB_ALLUSERS | SHGVSPB_ALLFOLDERS)
1995
1996 HRESULT
1997 WINAPI
1998 SHGetViewStatePropertyBag(
1999 _In_opt_ LPCITEMIDLIST pidl,
2000 _In_opt_ LPWSTR bag_name,
2001 DWORD flags,
2002 _In_ REFIID riid,
2003 _Outptr_ void **ppv);
2004
2005 #endif /* (_WIN32_IE >= 0x0600) */
2006
2007
2008 /* IsOS definitions */
2009
2010 #define OS_WIN32SORGREATER 0x00
2011 #define OS_NT 0x01
2012 #define OS_WIN95ORGREATER 0x02
2013 #define OS_NT4ORGREATER 0x03
2014 #define OS_WIN2000ORGREATER_ALT 0x04
2015 #define OS_WIN98ORGREATER 0x05
2016 #define OS_WIN98_GOLD 0x06
2017 #define OS_WIN2000ORGREATER 0x07
2018 #define OS_WIN2000PRO 0x08
2019 #define OS_WIN2000SERVER 0x09
2020 #define OS_WIN2000ADVSERVER 0x0A
2021 #define OS_WIN2000DATACENTER 0x0B
2022 #define OS_WIN2000TERMINAL 0x0C
2023 #define OS_EMBEDDED 0x0D
2024 #define OS_TERMINALCLIENT 0x0E
2025 #define OS_TERMINALREMOTEADMIN 0x0F
2026 #define OS_WIN95_GOLD 0x10
2027 #define OS_MEORGREATER 0x11
2028 #define OS_XPORGREATER 0x12
2029 #define OS_HOME 0x13
2030 #define OS_PROFESSIONAL 0x14
2031 #define OS_DATACENTER 0x15
2032 #define OS_ADVSERVER 0x16
2033 #define OS_SERVER 0x17
2034 #define OS_TERMINALSERVER 0x18
2035 #define OS_PERSONALTERMINALSERVER 0x19
2036 #define OS_FASTUSERSWITCHING 0x1A
2037 #define OS_WELCOMELOGONUI 0x1B
2038 #define OS_DOMAINMEMBER 0x1C
2039 #define OS_ANYSERVER 0x1D
2040 #define OS_WOW6432 0x1E
2041 #define OS_WEBSERVER 0x1F
2042 #define OS_SMALLBUSINESSSERVER 0x20
2043 #define OS_TABLETPC 0x21
2044 #define OS_SERVERADMINUI 0x22
2045 #define OS_MEDIACENTER 0x23
2046 #define OS_APPLIANCE 0x24
2047
2048 BOOL WINAPI IsOS(DWORD);
2049
2050 /* SHSetTimerQueueTimer definitions */
2051 #define TPS_EXECUTEIO 0x00000001
2052 #define TPS_LONGEXECTIME 0x00000008
2053
2054 /* SHFormatDateTimeA/SHFormatDateTimeW flags */
2055 #define FDTF_SHORTTIME 0x00000001
2056 #define FDTF_SHORTDATE 0x00000002
2057 #define FDTF_DEFAULT (FDTF_SHORTDATE | FDTF_SHORTTIME)
2058 #define FDTF_LONGDATE 0x00000004
2059 #define FDTF_LONGTIME 0x00000008
2060 #define FDTF_RELATIVE 0x00000010
2061 #define FDTF_LTRDATE 0x00000100
2062 #define FDTF_RTLDATE 0x00000200
2063 #define FDTF_NOAUTOREADINGORDER 0x00000400
2064
2065
2066 typedef struct
2067 {
2068 const IID *piid;
2069 int dwOffset;
2070 } QITAB, *LPQITAB;
2071
2072 HRESULT
2073 WINAPI
2074 QISearch(
2075 _Inout_ void* base,
2076 _In_ const QITAB *pqit,
2077 _In_ REFIID riid,
2078 _Outptr_ void **ppv);
2079
2080 #define OFFSETOFCLASS(base, derived) \
2081 ((DWORD)(DWORD_PTR)(static_cast<base*>((derived*)8))-8)
2082
2083 #include <poppack.h>
2084
2085 #ifdef __cplusplus
2086 } /* extern "C" */
2087 #endif /* defined(__cplusplus) */
2088
2089 #endif /* __WINE_SHLWAPI_H */