Mercurial > hg > xemacs-beta
comparison src/intl-auto-encap-win32.c @ 771:943eaba38521
[xemacs-hg @ 2002-03-13 08:51:24 by ben]
The big ben-mule-21-5 check-in!
Various files were added and deleted. See CHANGES-ben-mule.
There are still some test suite failures. No crashes, though.
Many of the failures have to do with problems in the test suite itself
rather than in the actual code. I'll be addressing these in the next
day or so -- none of the test suite failures are at all critical.
Meanwhile I'll be trying to address the biggest issues -- i.e. build
or run failures, which will almost certainly happen on various platforms.
All comments should be sent to ben@xemacs.org -- use a Cc: if necessary
when sending to mailing lists. There will be pre- and post- tags,
something like
pre-ben-mule-21-5-merge-in, and
post-ben-mule-21-5-merge-in.
author | ben |
---|---|
date | Wed, 13 Mar 2002 08:54:06 +0000 |
parents | |
children | 2923009caf47 |
comparison
equal
deleted
inserted
replaced
770:336a418893b5 | 771:943eaba38521 |
---|---|
1 /* Automatically-generated Unicode-encapsulation file, | |
2 using the command | |
3 | |
4 ../lib-src/make-mswin-unicode.pl --c-output intl-auto-encap-win32.c --h-output intl-auto-encap-win32.h intl-encap-win32.c | |
5 | |
6 Do not edit. See `make-mswin-unicode.pl'. | |
7 */ | |
8 | |
9 #include <config.h> | |
10 #include "lisp.h" | |
11 | |
12 #include "syswindows.h" | |
13 | |
14 | |
15 /*----------------------------------------------------------------------*/ | |
16 /* Processing file WINSPOOL.H */ | |
17 /*----------------------------------------------------------------------*/ | |
18 | |
19 #if defined (HAVE_MS_WINDOWS) | |
20 | |
21 /* NOTE: #### problems with DEVMODE pointer in PRINTER_INFO_2 */ | |
22 BOOL | |
23 qxeEnumPrinters (DWORD Flags, Extbyte * Name, DWORD Level, LPBYTE pPrinterEnum, DWORD cbBuf, LPDWORD pcbNeeded, LPDWORD pcReturned) | |
24 { | |
25 if (XEUNICODE_P) | |
26 return EnumPrintersW (Flags, (LPWSTR) Name, Level, pPrinterEnum, cbBuf, pcbNeeded, pcReturned); | |
27 else | |
28 return EnumPrintersA (Flags, (LPSTR) Name, Level, pPrinterEnum, cbBuf, pcbNeeded, pcReturned); | |
29 } | |
30 | |
31 #endif /* defined (HAVE_MS_WINDOWS) */ | |
32 | |
33 #if defined (HAVE_MS_WINDOWS) | |
34 | |
35 /* Skipping OpenPrinter because split-sized DEVMODE pointer in split PRINTER_DEFAULTS */ | |
36 | |
37 #endif /* defined (HAVE_MS_WINDOWS) */ | |
38 | |
39 #if defined (HAVE_MS_WINDOWS) | |
40 | |
41 /* Error if ResetPrinter used: split-sized DEVMODE pointer in split PRINTER_DEFAULTS */ | |
42 | |
43 #endif /* defined (HAVE_MS_WINDOWS) */ | |
44 | |
45 #if defined (HAVE_MS_WINDOWS) | |
46 | |
47 /* Error if SetJob used: split-sized DEVMODE pointer in split JOB_INFO_2 */ | |
48 | |
49 #endif /* defined (HAVE_MS_WINDOWS) */ | |
50 | |
51 #if defined (HAVE_MS_WINDOWS) | |
52 | |
53 /* Error if GetJob used: split-sized DEVMODE pointer in split JOB_INFO_2 */ | |
54 | |
55 #endif /* defined (HAVE_MS_WINDOWS) */ | |
56 | |
57 #if defined (HAVE_MS_WINDOWS) | |
58 | |
59 /* Error if EnumJobs used: split-sized DEVMODE pointer in split JOB_INFO_2 */ | |
60 | |
61 #endif /* defined (HAVE_MS_WINDOWS) */ | |
62 | |
63 #if defined (HAVE_MS_WINDOWS) | |
64 | |
65 /* Error if AddPrinter used: split-sized DEVMODE pointer in split PRINTER_INFO_2 */ | |
66 | |
67 #endif /* defined (HAVE_MS_WINDOWS) */ | |
68 | |
69 #if defined (HAVE_MS_WINDOWS) | |
70 | |
71 /* Error if SetPrinter used: split-sized DEVMODE pointer in split PRINTER_INFO_2 */ | |
72 | |
73 #endif /* defined (HAVE_MS_WINDOWS) */ | |
74 | |
75 #if defined (HAVE_MS_WINDOWS) | |
76 | |
77 /* Error if GetPrinter used: split-sized DEVMODE pointer in split PRINTER_INFO_2 */ | |
78 | |
79 #endif /* defined (HAVE_MS_WINDOWS) */ | |
80 | |
81 #if defined (HAVE_MS_WINDOWS) | |
82 | |
83 /* Error if AddPrinterDriver used: not used, complicated interface with split structures */ | |
84 | |
85 #endif /* defined (HAVE_MS_WINDOWS) */ | |
86 | |
87 #if defined (HAVE_MS_WINDOWS) | |
88 | |
89 /* Error if AddPrinterDriverEx used: not used, complicated interface with split structures */ | |
90 | |
91 #endif /* defined (HAVE_MS_WINDOWS) */ | |
92 | |
93 #if defined (HAVE_MS_WINDOWS) | |
94 | |
95 /* Error if EnumPrinterDrivers used: not used, complicated interface with split structures */ | |
96 | |
97 #endif /* defined (HAVE_MS_WINDOWS) */ | |
98 | |
99 #if defined (HAVE_MS_WINDOWS) | |
100 | |
101 /* Error if GetPrinterDriver used: not used, complicated interface with split structures */ | |
102 | |
103 #endif /* defined (HAVE_MS_WINDOWS) */ | |
104 | |
105 #if defined (HAVE_MS_WINDOWS) | |
106 | |
107 /* Error if GetPrinterDriverDirectory used: not used, complicated interface with split structures */ | |
108 | |
109 #endif /* defined (HAVE_MS_WINDOWS) */ | |
110 | |
111 #if defined (HAVE_MS_WINDOWS) | |
112 | |
113 /* Error if DeletePrinterDriver used: not used, complicated interface with split structures */ | |
114 | |
115 #endif /* defined (HAVE_MS_WINDOWS) */ | |
116 | |
117 #if defined (HAVE_MS_WINDOWS) | |
118 | |
119 /* Error if DeletePrinterDriverEx used: not used, complicated interface with split structures */ | |
120 | |
121 #endif /* defined (HAVE_MS_WINDOWS) */ | |
122 | |
123 #if defined (HAVE_MS_WINDOWS) | |
124 | |
125 /* Error if AddPerMachineConnection used: not used, complicated interface with split structures */ | |
126 | |
127 #endif /* defined (HAVE_MS_WINDOWS) */ | |
128 | |
129 #if defined (HAVE_MS_WINDOWS) | |
130 | |
131 /* Error if DeletePerMachineConnection used: not used, complicated interface with split structures */ | |
132 | |
133 #endif /* defined (HAVE_MS_WINDOWS) */ | |
134 | |
135 #if defined (HAVE_MS_WINDOWS) | |
136 | |
137 /* Error if EnumPerMachineConnections used: not used, complicated interface with split structures */ | |
138 | |
139 #endif /* defined (HAVE_MS_WINDOWS) */ | |
140 | |
141 #if defined (HAVE_MS_WINDOWS) | |
142 | |
143 /* Error if AddPrintProcessor used: not used, complicated interface with split structures */ | |
144 | |
145 #endif /* defined (HAVE_MS_WINDOWS) */ | |
146 | |
147 #if defined (HAVE_MS_WINDOWS) | |
148 | |
149 /* Error if EnumPrintProcessors used: not used, complicated interface with split structures */ | |
150 | |
151 #endif /* defined (HAVE_MS_WINDOWS) */ | |
152 | |
153 #if defined (HAVE_MS_WINDOWS) | |
154 | |
155 /* Error if GetPrintProcessorDirectory used: not used, complicated interface with split structures */ | |
156 | |
157 #endif /* defined (HAVE_MS_WINDOWS) */ | |
158 | |
159 #if defined (HAVE_MS_WINDOWS) | |
160 | |
161 /* Error if EnumPrintProcessorDatatypes used: not used, complicated interface with split structures */ | |
162 | |
163 #endif /* defined (HAVE_MS_WINDOWS) */ | |
164 | |
165 #if defined (HAVE_MS_WINDOWS) | |
166 | |
167 /* Error if DeletePrintProcessor used: not used, complicated interface with split structures */ | |
168 | |
169 #endif /* defined (HAVE_MS_WINDOWS) */ | |
170 | |
171 #if defined (HAVE_MS_WINDOWS) | |
172 | |
173 /* Error if StartDocPrinter used: not used, complicated interface with split structures */ | |
174 | |
175 #endif /* defined (HAVE_MS_WINDOWS) */ | |
176 | |
177 #if defined (HAVE_MS_WINDOWS) | |
178 | |
179 /* Error if AddJob used: not used, complicated interface with split structures */ | |
180 | |
181 #endif /* defined (HAVE_MS_WINDOWS) */ | |
182 | |
183 #if defined (HAVE_MS_WINDOWS) | |
184 | |
185 /* Skipping DocumentProperties because split-sized DEVMODE, error in Cygwin prototype */ | |
186 | |
187 #endif /* defined (HAVE_MS_WINDOWS) */ | |
188 | |
189 #if defined (HAVE_MS_WINDOWS) | |
190 | |
191 /* Error if AdvancedDocumentProperties used: not used, complicated interface with split structures */ | |
192 | |
193 #endif /* defined (HAVE_MS_WINDOWS) */ | |
194 | |
195 #if defined (HAVE_MS_WINDOWS) | |
196 | |
197 /* Error if GetPrinterData used: not used, complicated interface with split structures */ | |
198 | |
199 #endif /* defined (HAVE_MS_WINDOWS) */ | |
200 | |
201 #if defined (HAVE_MS_WINDOWS) | |
202 | |
203 /* Error if GetPrinterDataEx used: not used, complicated interface with split structures */ | |
204 | |
205 #endif /* defined (HAVE_MS_WINDOWS) */ | |
206 | |
207 #if defined (HAVE_MS_WINDOWS) | |
208 | |
209 /* Error if EnumPrinterData used: not used, complicated interface with split structures */ | |
210 | |
211 #endif /* defined (HAVE_MS_WINDOWS) */ | |
212 | |
213 #if defined (HAVE_MS_WINDOWS) | |
214 | |
215 /* Error if EnumPrinterDataEx used: not used, complicated interface with split structures */ | |
216 | |
217 #endif /* defined (HAVE_MS_WINDOWS) */ | |
218 | |
219 #if defined (HAVE_MS_WINDOWS) | |
220 | |
221 /* Error if EnumPrinterKey used: not used, complicated interface with split structures */ | |
222 | |
223 #endif /* defined (HAVE_MS_WINDOWS) */ | |
224 | |
225 #if defined (HAVE_MS_WINDOWS) | |
226 | |
227 /* Error if SetPrinterData used: not used, complicated interface with split structures */ | |
228 | |
229 #endif /* defined (HAVE_MS_WINDOWS) */ | |
230 | |
231 #if defined (HAVE_MS_WINDOWS) | |
232 | |
233 /* Error if SetPrinterDataEx used: not used, complicated interface with split structures */ | |
234 | |
235 #endif /* defined (HAVE_MS_WINDOWS) */ | |
236 | |
237 #if defined (HAVE_MS_WINDOWS) | |
238 | |
239 /* Error if DeletePrinterData used: not used, complicated interface with split structures */ | |
240 | |
241 #endif /* defined (HAVE_MS_WINDOWS) */ | |
242 | |
243 #if defined (HAVE_MS_WINDOWS) | |
244 | |
245 /* Error if DeletePrinterDataEx used: not used, complicated interface with split structures */ | |
246 | |
247 #endif /* defined (HAVE_MS_WINDOWS) */ | |
248 | |
249 #if defined (HAVE_MS_WINDOWS) | |
250 | |
251 /* Error if DeletePrinterKey used: not used, complicated interface with split structures */ | |
252 | |
253 #endif /* defined (HAVE_MS_WINDOWS) */ | |
254 | |
255 #if defined (HAVE_MS_WINDOWS) | |
256 | |
257 /* Error if PrinterMessageBox used: not used, complicated interface with split structures */ | |
258 | |
259 #endif /* defined (HAVE_MS_WINDOWS) */ | |
260 | |
261 #if defined (HAVE_MS_WINDOWS) | |
262 | |
263 /* Error if AddForm used: not used, complicated interface with split structures */ | |
264 | |
265 #endif /* defined (HAVE_MS_WINDOWS) */ | |
266 | |
267 #if defined (HAVE_MS_WINDOWS) | |
268 | |
269 /* Error if DeleteForm used: not used, complicated interface with split structures */ | |
270 | |
271 #endif /* defined (HAVE_MS_WINDOWS) */ | |
272 | |
273 #if defined (HAVE_MS_WINDOWS) | |
274 | |
275 /* Error if GetForm used: not used, complicated interface with split structures */ | |
276 | |
277 #endif /* defined (HAVE_MS_WINDOWS) */ | |
278 | |
279 #if defined (HAVE_MS_WINDOWS) | |
280 | |
281 /* Error if SetForm used: not used, complicated interface with split structures */ | |
282 | |
283 #endif /* defined (HAVE_MS_WINDOWS) */ | |
284 | |
285 #if defined (HAVE_MS_WINDOWS) | |
286 | |
287 /* Error if EnumForms used: not used, complicated interface with split structures */ | |
288 | |
289 #endif /* defined (HAVE_MS_WINDOWS) */ | |
290 | |
291 #if defined (HAVE_MS_WINDOWS) | |
292 | |
293 /* Error if EnumMonitors used: not used, complicated interface with split structures */ | |
294 | |
295 #endif /* defined (HAVE_MS_WINDOWS) */ | |
296 | |
297 #if defined (HAVE_MS_WINDOWS) | |
298 | |
299 /* Error if AddMonitor used: not used, complicated interface with split structures */ | |
300 | |
301 #endif /* defined (HAVE_MS_WINDOWS) */ | |
302 | |
303 #if defined (HAVE_MS_WINDOWS) | |
304 | |
305 /* Error if DeleteMonitor used: not used, complicated interface with split structures */ | |
306 | |
307 #endif /* defined (HAVE_MS_WINDOWS) */ | |
308 | |
309 #if defined (HAVE_MS_WINDOWS) | |
310 | |
311 /* Error if EnumPorts used: not used, complicated interface with split structures */ | |
312 | |
313 #endif /* defined (HAVE_MS_WINDOWS) */ | |
314 | |
315 #if defined (HAVE_MS_WINDOWS) | |
316 | |
317 /* Error if AddPort used: not used, complicated interface with split structures */ | |
318 | |
319 #endif /* defined (HAVE_MS_WINDOWS) */ | |
320 | |
321 #if defined (HAVE_MS_WINDOWS) | |
322 | |
323 /* Error if ConfigurePort used: not used, complicated interface with split structures */ | |
324 | |
325 #endif /* defined (HAVE_MS_WINDOWS) */ | |
326 | |
327 #if defined (HAVE_MS_WINDOWS) | |
328 | |
329 /* Error if DeletePort used: not used, complicated interface with split structures */ | |
330 | |
331 #endif /* defined (HAVE_MS_WINDOWS) */ | |
332 | |
333 #if defined (HAVE_MS_WINDOWS) | |
334 | |
335 /* Error if XcvData used: not used, complicated interface with split structures */ | |
336 | |
337 #endif /* defined (HAVE_MS_WINDOWS) */ | |
338 | |
339 #if defined (HAVE_MS_WINDOWS) | |
340 | |
341 /* Error if SetPort used: not used, complicated interface with split structures */ | |
342 | |
343 #endif /* defined (HAVE_MS_WINDOWS) */ | |
344 | |
345 #if defined (HAVE_MS_WINDOWS) | |
346 | |
347 /* Error if AddPrinterConnection used: not used, complicated interface with split structures */ | |
348 | |
349 #endif /* defined (HAVE_MS_WINDOWS) */ | |
350 | |
351 #if defined (HAVE_MS_WINDOWS) | |
352 | |
353 /* Error if DeletePrinterConnection used: not used, complicated interface with split structures */ | |
354 | |
355 #endif /* defined (HAVE_MS_WINDOWS) */ | |
356 | |
357 #if defined (HAVE_MS_WINDOWS) | |
358 | |
359 /* Error if AddPrintProvidor used: not used, complicated interface with split structures */ | |
360 | |
361 #endif /* defined (HAVE_MS_WINDOWS) */ | |
362 | |
363 #if defined (HAVE_MS_WINDOWS) | |
364 | |
365 /* Error if DeletePrintProvidor used: not used, complicated interface with split structures */ | |
366 | |
367 #endif /* defined (HAVE_MS_WINDOWS) */ | |
368 | |
369 #if defined (HAVE_MS_WINDOWS) | |
370 | |
371 /* Error if SetPrinterHTMLView used: not used, complicated interface with split structures */ | |
372 | |
373 #endif /* defined (HAVE_MS_WINDOWS) */ | |
374 | |
375 #if defined (HAVE_MS_WINDOWS) | |
376 | |
377 /* Error if GetPrinterHTMLView used: not used, complicated interface with split structures */ | |
378 | |
379 #endif /* defined (HAVE_MS_WINDOWS) */ | |
380 | |
381 | |
382 /*----------------------------------------------------------------------*/ | |
383 /* Processing file WINNETWK.H */ | |
384 /*----------------------------------------------------------------------*/ | |
385 | |
386 #if defined (HAVE_MS_WINDOWS) | |
387 | |
388 DWORD | |
389 qxeWNetAddConnection (const Extbyte * lpRemoteName, const Extbyte * lpPassword, const Extbyte * lpLocalName) | |
390 { | |
391 if (XEUNICODE_P) | |
392 return WNetAddConnectionW ((LPCWSTR) lpRemoteName, (LPCWSTR) lpPassword, (LPCWSTR) lpLocalName); | |
393 else | |
394 return WNetAddConnectionA ((LPCSTR) lpRemoteName, (LPCSTR) lpPassword, (LPCSTR) lpLocalName); | |
395 } | |
396 | |
397 #endif /* defined (HAVE_MS_WINDOWS) */ | |
398 | |
399 #if defined (HAVE_MS_WINDOWS) | |
400 | |
401 DWORD | |
402 qxeWNetAddConnection2 (LPNETRESOURCEW lpNetResource, const Extbyte * lpPassword, const Extbyte * lpUserName, DWORD dwFlags) | |
403 { | |
404 if (XEUNICODE_P) | |
405 return WNetAddConnection2W (lpNetResource, (LPCWSTR) lpPassword, (LPCWSTR) lpUserName, dwFlags); | |
406 else | |
407 return WNetAddConnection2A ((LPNETRESOURCEA) lpNetResource, (LPCSTR) lpPassword, (LPCSTR) lpUserName, dwFlags); | |
408 } | |
409 | |
410 #endif /* defined (HAVE_MS_WINDOWS) */ | |
411 | |
412 #if defined (HAVE_MS_WINDOWS) | |
413 | |
414 DWORD | |
415 qxeWNetAddConnection3 (HWND hwndOwner, LPNETRESOURCEW lpNetResource, const Extbyte * lpPassword, const Extbyte * lpUserName, DWORD dwFlags) | |
416 { | |
417 if (XEUNICODE_P) | |
418 return WNetAddConnection3W (hwndOwner, lpNetResource, (LPCWSTR) lpPassword, (LPCWSTR) lpUserName, dwFlags); | |
419 else | |
420 return WNetAddConnection3A (hwndOwner, (LPNETRESOURCEA) lpNetResource, (LPCSTR) lpPassword, (LPCSTR) lpUserName, dwFlags); | |
421 } | |
422 | |
423 #endif /* defined (HAVE_MS_WINDOWS) */ | |
424 | |
425 #if defined (HAVE_MS_WINDOWS) | |
426 | |
427 DWORD | |
428 qxeWNetCancelConnection (const Extbyte * lpName, BOOL fForce) | |
429 { | |
430 if (XEUNICODE_P) | |
431 return WNetCancelConnectionW ((LPCWSTR) lpName, fForce); | |
432 else | |
433 return WNetCancelConnectionA ((LPCSTR) lpName, fForce); | |
434 } | |
435 | |
436 #endif /* defined (HAVE_MS_WINDOWS) */ | |
437 | |
438 #if defined (HAVE_MS_WINDOWS) | |
439 | |
440 DWORD | |
441 qxeWNetCancelConnection2 (const Extbyte * lpName, DWORD dwFlags, BOOL fForce) | |
442 { | |
443 if (XEUNICODE_P) | |
444 return WNetCancelConnection2W ((LPCWSTR) lpName, dwFlags, fForce); | |
445 else | |
446 return WNetCancelConnection2A ((LPCSTR) lpName, dwFlags, fForce); | |
447 } | |
448 | |
449 #endif /* defined (HAVE_MS_WINDOWS) */ | |
450 | |
451 #if defined (HAVE_MS_WINDOWS) | |
452 | |
453 DWORD | |
454 qxeWNetGetConnection (const Extbyte * lpLocalName, Extbyte * lpRemoteName, LPDWORD lpnLength) | |
455 { | |
456 if (XEUNICODE_P) | |
457 return WNetGetConnectionW ((LPCWSTR) lpLocalName, (LPWSTR) lpRemoteName, lpnLength); | |
458 else | |
459 return WNetGetConnectionA ((LPCSTR) lpLocalName, (LPSTR) lpRemoteName, lpnLength); | |
460 } | |
461 | |
462 #endif /* defined (HAVE_MS_WINDOWS) */ | |
463 | |
464 #if defined (HAVE_MS_WINDOWS) | |
465 | |
466 DWORD | |
467 qxeWNetUseConnection (HWND hwndOwner, LPNETRESOURCEW lpNetResource, const Extbyte * lpUserID, const Extbyte * lpPassword, DWORD dwFlags, Extbyte * lpAccessName, LPDWORD lpBufferSize, LPDWORD lpResult) | |
468 { | |
469 if (XEUNICODE_P) | |
470 return WNetUseConnectionW (hwndOwner, lpNetResource, (LPCWSTR) lpUserID, (LPCWSTR) lpPassword, dwFlags, (LPWSTR) lpAccessName, lpBufferSize, lpResult); | |
471 else | |
472 return WNetUseConnectionA (hwndOwner, (LPNETRESOURCEA) lpNetResource, (LPCSTR) lpUserID, (LPCSTR) lpPassword, dwFlags, (LPSTR) lpAccessName, lpBufferSize, lpResult); | |
473 } | |
474 | |
475 #endif /* defined (HAVE_MS_WINDOWS) */ | |
476 | |
477 #if defined (HAVE_MS_WINDOWS) | |
478 | |
479 /* NOTE: contains split-simple LPNETRESOURCE */ | |
480 DWORD | |
481 qxeWNetConnectionDialog1 (LPCONNECTDLGSTRUCTW lpConnDlgStruct) | |
482 { | |
483 if (XEUNICODE_P) | |
484 return WNetConnectionDialog1W (lpConnDlgStruct); | |
485 else | |
486 return WNetConnectionDialog1A ((LPCONNECTDLGSTRUCTA) lpConnDlgStruct); | |
487 } | |
488 | |
489 #endif /* defined (HAVE_MS_WINDOWS) */ | |
490 | |
491 #if defined (HAVE_MS_WINDOWS) | |
492 | |
493 DWORD | |
494 qxeWNetDisconnectDialog1 (LPDISCDLGSTRUCTW lpConnDlgStruct) | |
495 { | |
496 if (XEUNICODE_P) | |
497 return WNetDisconnectDialog1W (lpConnDlgStruct); | |
498 else | |
499 return WNetDisconnectDialog1A ((LPDISCDLGSTRUCTA) lpConnDlgStruct); | |
500 } | |
501 | |
502 #endif /* defined (HAVE_MS_WINDOWS) */ | |
503 | |
504 #if defined (HAVE_MS_WINDOWS) | |
505 | |
506 DWORD | |
507 qxeWNetOpenEnum (DWORD dwScope, DWORD dwType, DWORD dwUsage, LPNETRESOURCEW lpNetResource, LPHANDLE lphEnum) | |
508 { | |
509 if (XEUNICODE_P) | |
510 return WNetOpenEnumW (dwScope, dwType, dwUsage, lpNetResource, lphEnum); | |
511 else | |
512 return WNetOpenEnumA (dwScope, dwType, dwUsage, (LPNETRESOURCEA) lpNetResource, lphEnum); | |
513 } | |
514 | |
515 #endif /* defined (HAVE_MS_WINDOWS) */ | |
516 | |
517 #if defined (HAVE_MS_WINDOWS) | |
518 | |
519 DWORD | |
520 qxeWNetEnumResource (HANDLE hEnum, LPDWORD lpcCount, LPVOID lpBuffer, LPDWORD lpBufferSize) | |
521 { | |
522 if (XEUNICODE_P) | |
523 return WNetEnumResourceW (hEnum, lpcCount, lpBuffer, lpBufferSize); | |
524 else | |
525 return WNetEnumResourceA (hEnum, lpcCount, lpBuffer, lpBufferSize); | |
526 } | |
527 | |
528 #endif /* defined (HAVE_MS_WINDOWS) */ | |
529 | |
530 #if defined (HAVE_MS_WINDOWS) | |
531 | |
532 DWORD | |
533 qxeWNetGetUniversalName (const Extbyte * lpLocalPath, DWORD dwInfoLevel, LPVOID lpBuffer, LPDWORD lpBufferSize) | |
534 { | |
535 if (XEUNICODE_P) | |
536 return WNetGetUniversalNameW ((LPCWSTR) lpLocalPath, dwInfoLevel, lpBuffer, lpBufferSize); | |
537 else | |
538 return WNetGetUniversalNameA ((LPCSTR) lpLocalPath, dwInfoLevel, lpBuffer, lpBufferSize); | |
539 } | |
540 | |
541 #endif /* defined (HAVE_MS_WINDOWS) */ | |
542 | |
543 #if defined (HAVE_MS_WINDOWS) | |
544 | |
545 DWORD | |
546 qxeWNetGetUser (const Extbyte * lpName, Extbyte * lpUserName, LPDWORD lpnLength) | |
547 { | |
548 if (XEUNICODE_P) | |
549 return WNetGetUserW ((LPCWSTR) lpName, (LPWSTR) lpUserName, lpnLength); | |
550 else | |
551 return WNetGetUserA ((LPCSTR) lpName, (LPSTR) lpUserName, lpnLength); | |
552 } | |
553 | |
554 #endif /* defined (HAVE_MS_WINDOWS) */ | |
555 | |
556 #if defined (HAVE_MS_WINDOWS) | |
557 | |
558 DWORD | |
559 qxeWNetGetProviderName (DWORD dwNetType, Extbyte * lpProviderName, LPDWORD lpBufferSize) | |
560 { | |
561 if (XEUNICODE_P) | |
562 return WNetGetProviderNameW (dwNetType, (LPWSTR) lpProviderName, lpBufferSize); | |
563 else | |
564 return WNetGetProviderNameA (dwNetType, (LPSTR) lpProviderName, lpBufferSize); | |
565 } | |
566 | |
567 #endif /* defined (HAVE_MS_WINDOWS) */ | |
568 | |
569 #if defined (HAVE_MS_WINDOWS) | |
570 | |
571 DWORD | |
572 qxeWNetGetNetworkInformation (const Extbyte * lpProvider, LPNETINFOSTRUCT lpNetInfoStruct) | |
573 { | |
574 if (XEUNICODE_P) | |
575 return WNetGetNetworkInformationW ((LPCWSTR) lpProvider, lpNetInfoStruct); | |
576 else | |
577 return WNetGetNetworkInformationA ((LPCSTR) lpProvider, lpNetInfoStruct); | |
578 } | |
579 | |
580 #endif /* defined (HAVE_MS_WINDOWS) */ | |
581 | |
582 #if defined (HAVE_MS_WINDOWS) | |
583 | |
584 DWORD | |
585 qxeWNetGetLastError (LPDWORD lpError, Extbyte * lpErrorBuf, DWORD nErrorBufSize, Extbyte * lpNameBuf, DWORD nNameBufSize) | |
586 { | |
587 if (XEUNICODE_P) | |
588 return WNetGetLastErrorW (lpError, (LPWSTR) lpErrorBuf, nErrorBufSize, (LPWSTR) lpNameBuf, nNameBufSize); | |
589 else | |
590 return WNetGetLastErrorA (lpError, (LPSTR) lpErrorBuf, nErrorBufSize, (LPSTR) lpNameBuf, nNameBufSize); | |
591 } | |
592 | |
593 #endif /* defined (HAVE_MS_WINDOWS) */ | |
594 | |
595 #if defined (HAVE_MS_WINDOWS) | |
596 | |
597 DWORD | |
598 qxeMultinetGetConnectionPerformance (LPNETRESOURCEW lpNetResource, LPNETCONNECTINFOSTRUCT lpNetConnectInfoStruct) | |
599 { | |
600 if (XEUNICODE_P) | |
601 return MultinetGetConnectionPerformanceW (lpNetResource, lpNetConnectInfoStruct); | |
602 else | |
603 return MultinetGetConnectionPerformanceA ((LPNETRESOURCEA) lpNetResource, lpNetConnectInfoStruct); | |
604 } | |
605 | |
606 #endif /* defined (HAVE_MS_WINDOWS) */ | |
607 | |
608 | |
609 /*----------------------------------------------------------------------*/ | |
610 /* Processing file WINREG.H */ | |
611 /*----------------------------------------------------------------------*/ | |
612 | |
613 /* Skipping RegConnectRegistry because error in Cygwin prototype */ | |
614 | |
615 LONG | |
616 | |
617 qxeRegCreateKey (HKEY hKey, const Extbyte * lpSubKey, PHKEY phkResult) | |
618 { | |
619 if (XEUNICODE_P) | |
620 return RegCreateKeyW (hKey, (LPCWSTR) lpSubKey, phkResult); | |
621 else | |
622 return RegCreateKeyA (hKey, (LPCSTR) lpSubKey, phkResult); | |
623 } | |
624 | |
625 LONG | |
626 | |
627 qxeRegCreateKeyEx (HKEY hKey, const Extbyte * lpSubKey, DWORD Reserved, Extbyte * lpClass, DWORD dwOptions, REGSAM samDesired, LPSECURITY_ATTRIBUTES lpSecurityAttributes, PHKEY phkResult, LPDWORD lpdwDisposition) | |
628 { | |
629 if (XEUNICODE_P) | |
630 return RegCreateKeyExW (hKey, (LPCWSTR) lpSubKey, Reserved, (LPWSTR) lpClass, dwOptions, samDesired, lpSecurityAttributes, phkResult, lpdwDisposition); | |
631 else | |
632 return RegCreateKeyExA (hKey, (LPCSTR) lpSubKey, Reserved, (LPSTR) lpClass, dwOptions, samDesired, lpSecurityAttributes, phkResult, lpdwDisposition); | |
633 } | |
634 | |
635 LONG | |
636 | |
637 qxeRegDeleteKey (HKEY hKey, const Extbyte * lpSubKey) | |
638 { | |
639 if (XEUNICODE_P) | |
640 return RegDeleteKeyW (hKey, (LPCWSTR) lpSubKey); | |
641 else | |
642 return RegDeleteKeyA (hKey, (LPCSTR) lpSubKey); | |
643 } | |
644 | |
645 LONG | |
646 | |
647 qxeRegDeleteValue (HKEY hKey, const Extbyte * lpValueName) | |
648 { | |
649 if (XEUNICODE_P) | |
650 return RegDeleteValueW (hKey, (LPCWSTR) lpValueName); | |
651 else | |
652 return RegDeleteValueA (hKey, (LPCSTR) lpValueName); | |
653 } | |
654 | |
655 LONG | |
656 | |
657 qxeRegEnumKey (HKEY hKey, DWORD dwIndex, Extbyte * lpName, DWORD cbName) | |
658 { | |
659 if (XEUNICODE_P) | |
660 return RegEnumKeyW (hKey, dwIndex, (LPWSTR) lpName, cbName); | |
661 else | |
662 return RegEnumKeyA (hKey, dwIndex, (LPSTR) lpName, cbName); | |
663 } | |
664 | |
665 LONG | |
666 | |
667 qxeRegEnumKeyEx (HKEY hKey, DWORD dwIndex, Extbyte * lpName, LPDWORD lpcbName, LPDWORD lpReserved, Extbyte * lpClass, LPDWORD lpcbClass, PFILETIME lpftLastWriteTime) | |
668 { | |
669 if (XEUNICODE_P) | |
670 return RegEnumKeyExW (hKey, dwIndex, (LPWSTR) lpName, lpcbName, lpReserved, (LPWSTR) lpClass, lpcbClass, lpftLastWriteTime); | |
671 else | |
672 return RegEnumKeyExA (hKey, dwIndex, (LPSTR) lpName, lpcbName, lpReserved, (LPSTR) lpClass, lpcbClass, lpftLastWriteTime); | |
673 } | |
674 | |
675 LONG | |
676 | |
677 qxeRegEnumValue (HKEY hKey, DWORD dwIndex, Extbyte * lpValueName, LPDWORD lpcbValueName, LPDWORD lpReserved, LPDWORD lpType, LPBYTE lpData, LPDWORD lpcbData) | |
678 { | |
679 if (XEUNICODE_P) | |
680 return RegEnumValueW (hKey, dwIndex, (LPWSTR) lpValueName, lpcbValueName, lpReserved, lpType, lpData, lpcbData); | |
681 else | |
682 return RegEnumValueA (hKey, dwIndex, (LPSTR) lpValueName, lpcbValueName, lpReserved, lpType, lpData, lpcbData); | |
683 } | |
684 | |
685 LONG | |
686 | |
687 qxeRegLoadKey (HKEY hKey, const Extbyte * lpSubKey, const Extbyte * lpFile) | |
688 { | |
689 if (XEUNICODE_P) | |
690 return RegLoadKeyW (hKey, (LPCWSTR) lpSubKey, (LPCWSTR) lpFile); | |
691 else | |
692 return RegLoadKeyA (hKey, (LPCSTR) lpSubKey, (LPCSTR) lpFile); | |
693 } | |
694 | |
695 LONG | |
696 | |
697 qxeRegOpenKey (HKEY hKey, const Extbyte * lpSubKey, PHKEY phkResult) | |
698 { | |
699 if (XEUNICODE_P) | |
700 return RegOpenKeyW (hKey, (LPCWSTR) lpSubKey, phkResult); | |
701 else | |
702 return RegOpenKeyA (hKey, (LPCSTR) lpSubKey, phkResult); | |
703 } | |
704 | |
705 LONG | |
706 | |
707 qxeRegOpenKeyEx (HKEY hKey, const Extbyte * lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult) | |
708 { | |
709 if (XEUNICODE_P) | |
710 return RegOpenKeyExW (hKey, (LPCWSTR) lpSubKey, ulOptions, samDesired, phkResult); | |
711 else | |
712 return RegOpenKeyExA (hKey, (LPCSTR) lpSubKey, ulOptions, samDesired, phkResult); | |
713 } | |
714 | |
715 LONG | |
716 | |
717 qxeRegQueryInfoKey (HKEY hKey, Extbyte * lpClass, LPDWORD lpcbClass, LPDWORD lpReserved, LPDWORD lpcSubKeys, LPDWORD lpcbMaxSubKeyLen, LPDWORD lpcbMaxClassLen, LPDWORD lpcValues, LPDWORD lpcbMaxValueNameLen, LPDWORD lpcbMaxValueLen, LPDWORD lpcbSecurityDescriptor, PFILETIME lpftLastWriteTime) | |
718 { | |
719 if (XEUNICODE_P) | |
720 return RegQueryInfoKeyW (hKey, (LPWSTR) lpClass, lpcbClass, lpReserved, lpcSubKeys, lpcbMaxSubKeyLen, lpcbMaxClassLen, lpcValues, lpcbMaxValueNameLen, lpcbMaxValueLen, lpcbSecurityDescriptor, lpftLastWriteTime); | |
721 else | |
722 return RegQueryInfoKeyA (hKey, (LPSTR) lpClass, lpcbClass, lpReserved, lpcSubKeys, lpcbMaxSubKeyLen, lpcbMaxClassLen, lpcValues, lpcbMaxValueNameLen, lpcbMaxValueLen, lpcbSecurityDescriptor, lpftLastWriteTime); | |
723 } | |
724 | |
725 LONG | |
726 | |
727 qxeRegQueryValue (HKEY hKey, const Extbyte * lpSubKey, Extbyte * lpValue, PLONG lpcbValue) | |
728 { | |
729 if (XEUNICODE_P) | |
730 return RegQueryValueW (hKey, (LPCWSTR) lpSubKey, (LPWSTR) lpValue, lpcbValue); | |
731 else | |
732 return RegQueryValueA (hKey, (LPCSTR) lpSubKey, (LPSTR) lpValue, lpcbValue); | |
733 } | |
734 | |
735 LONG | |
736 | |
737 qxeRegQueryMultipleValues (HKEY hKey, PVALENTW val_list, DWORD num_vals, Extbyte * lpValueBuf, LPDWORD ldwTotsize) | |
738 { | |
739 if (XEUNICODE_P) | |
740 return RegQueryMultipleValuesW (hKey, val_list, num_vals, (LPWSTR) lpValueBuf, ldwTotsize); | |
741 else | |
742 return RegQueryMultipleValuesA (hKey, (PVALENTA) val_list, num_vals, (LPSTR) lpValueBuf, ldwTotsize); | |
743 } | |
744 | |
745 LONG | |
746 | |
747 qxeRegQueryValueEx (HKEY hKey, const Extbyte * lpValueName, LPDWORD lpReserved, LPDWORD lpType, LPBYTE lpData, LPDWORD lpcbData) | |
748 { | |
749 if (XEUNICODE_P) | |
750 return RegQueryValueExW (hKey, (LPCWSTR) lpValueName, lpReserved, lpType, lpData, lpcbData); | |
751 else | |
752 return RegQueryValueExA (hKey, (LPCSTR) lpValueName, lpReserved, lpType, lpData, lpcbData); | |
753 } | |
754 | |
755 LONG | |
756 | |
757 qxeRegReplaceKey (HKEY hKey, const Extbyte * lpSubKey, const Extbyte * lpNewFile, const Extbyte * lpOldFile) | |
758 { | |
759 if (XEUNICODE_P) | |
760 return RegReplaceKeyW (hKey, (LPCWSTR) lpSubKey, (LPCWSTR) lpNewFile, (LPCWSTR) lpOldFile); | |
761 else | |
762 return RegReplaceKeyA (hKey, (LPCSTR) lpSubKey, (LPCSTR) lpNewFile, (LPCSTR) lpOldFile); | |
763 } | |
764 | |
765 LONG | |
766 | |
767 qxeRegRestoreKey (HKEY hKey, const Extbyte * lpFile, DWORD dwFlags) | |
768 { | |
769 if (XEUNICODE_P) | |
770 return RegRestoreKeyW (hKey, (LPCWSTR) lpFile, dwFlags); | |
771 else | |
772 return RegRestoreKeyA (hKey, (LPCSTR) lpFile, dwFlags); | |
773 } | |
774 | |
775 LONG | |
776 | |
777 qxeRegSaveKey (HKEY hKey, const Extbyte * lpFile, LPSECURITY_ATTRIBUTES lpSecurityAttributes) | |
778 { | |
779 if (XEUNICODE_P) | |
780 return RegSaveKeyW (hKey, (LPCWSTR) lpFile, lpSecurityAttributes); | |
781 else | |
782 return RegSaveKeyA (hKey, (LPCSTR) lpFile, lpSecurityAttributes); | |
783 } | |
784 | |
785 LONG | |
786 | |
787 qxeRegSetValue (HKEY hKey, const Extbyte * lpSubKey, DWORD dwType, const Extbyte * lpData, DWORD cbData) | |
788 { | |
789 if (XEUNICODE_P) | |
790 return RegSetValueW (hKey, (LPCWSTR) lpSubKey, dwType, (LPCWSTR) lpData, cbData); | |
791 else | |
792 return RegSetValueA (hKey, (LPCSTR) lpSubKey, dwType, (LPCSTR) lpData, cbData); | |
793 } | |
794 | |
795 LONG | |
796 | |
797 qxeRegSetValueEx (HKEY hKey, const Extbyte * lpValueName, DWORD Reserved, DWORD dwType, CONST BYTE* lpData, DWORD cbData) | |
798 { | |
799 if (XEUNICODE_P) | |
800 return RegSetValueExW (hKey, (LPCWSTR) lpValueName, Reserved, dwType, lpData, cbData); | |
801 else | |
802 return RegSetValueExA (hKey, (LPCSTR) lpValueName, Reserved, dwType, lpData, cbData); | |
803 } | |
804 | |
805 LONG | |
806 | |
807 qxeRegUnLoadKey (HKEY hKey, const Extbyte * lpSubKey) | |
808 { | |
809 if (XEUNICODE_P) | |
810 return RegUnLoadKeyW (hKey, (LPCWSTR) lpSubKey); | |
811 else | |
812 return RegUnLoadKeyA (hKey, (LPCSTR) lpSubKey); | |
813 } | |
814 | |
815 BOOL | |
816 | |
817 qxeInitiateSystemShutdown (Extbyte * lpMachineName, Extbyte * lpMessage, DWORD dwTimeout, BOOL bForceAppsClosed, BOOL bRebootAfterShutdown) | |
818 { | |
819 if (XEUNICODE_P) | |
820 return InitiateSystemShutdownW ((LPWSTR) lpMachineName, (LPWSTR) lpMessage, dwTimeout, bForceAppsClosed, bRebootAfterShutdown); | |
821 else | |
822 return InitiateSystemShutdownA ((LPSTR) lpMachineName, (LPSTR) lpMessage, dwTimeout, bForceAppsClosed, bRebootAfterShutdown); | |
823 } | |
824 | |
825 BOOL | |
826 | |
827 qxeAbortSystemShutdown (Extbyte * lpMachineName) | |
828 { | |
829 if (XEUNICODE_P) | |
830 return AbortSystemShutdownW ((LPWSTR) lpMachineName); | |
831 else | |
832 return AbortSystemShutdownA ((LPSTR) lpMachineName); | |
833 } | |
834 | |
835 | |
836 /*----------------------------------------------------------------------*/ | |
837 /* Processing file SHELLAPI.H */ | |
838 /*----------------------------------------------------------------------*/ | |
839 | |
840 UINT | |
841 qxeDragQueryFile (HDROP arg1, UINT arg2, Extbyte * arg3, UINT arg4) | |
842 { | |
843 if (XEUNICODE_P) | |
844 return DragQueryFileW (arg1, arg2, (LPWSTR) arg3, arg4); | |
845 else | |
846 return DragQueryFileA (arg1, arg2, (LPSTR) arg3, arg4); | |
847 } | |
848 | |
849 HINSTANCE | |
850 qxeShellExecute (HWND hwnd, const Extbyte * lpOperation, const Extbyte * lpFile, const Extbyte * lpParameters, const Extbyte * lpDirectory, INT nShowCmd) | |
851 { | |
852 if (XEUNICODE_P) | |
853 return ShellExecuteW (hwnd, (LPCWSTR) lpOperation, (LPCWSTR) lpFile, (LPCWSTR) lpParameters, (LPCWSTR) lpDirectory, nShowCmd); | |
854 else | |
855 return ShellExecuteA (hwnd, (LPCSTR) lpOperation, (LPCSTR) lpFile, (LPCSTR) lpParameters, (LPCSTR) lpDirectory, nShowCmd); | |
856 } | |
857 | |
858 HINSTANCE | |
859 qxeFindExecutable (const Extbyte * lpFile, const Extbyte * lpDirectory, Extbyte * lpResult) | |
860 { | |
861 if (XEUNICODE_P) | |
862 return FindExecutableW ((LPCWSTR) lpFile, (LPCWSTR) lpDirectory, (LPWSTR) lpResult); | |
863 else | |
864 return FindExecutableA ((LPCSTR) lpFile, (LPCSTR) lpDirectory, (LPSTR) lpResult); | |
865 } | |
866 | |
867 /* Error if CommandLineToArgv used: Unicode-only */ | |
868 | |
869 INT | |
870 qxeShellAbout (HWND hWnd, const Extbyte * szApp, const Extbyte * szOtherStuff, HICON hIcon) | |
871 { | |
872 if (XEUNICODE_P) | |
873 return ShellAboutW (hWnd, (LPCWSTR) szApp, (LPCWSTR) szOtherStuff, hIcon); | |
874 else | |
875 return ShellAboutA (hWnd, (LPCSTR) szApp, (LPCSTR) szOtherStuff, hIcon); | |
876 } | |
877 | |
878 HICON | |
879 qxeExtractAssociatedIcon (HINSTANCE hInst, Extbyte * lpIconPath, LPWORD lpiIcon) | |
880 { | |
881 if (XEUNICODE_P) | |
882 return ExtractAssociatedIconW (hInst, (LPWSTR) lpIconPath, lpiIcon); | |
883 else | |
884 return ExtractAssociatedIconA (hInst, (LPSTR) lpIconPath, lpiIcon); | |
885 } | |
886 | |
887 HICON | |
888 qxeExtractIcon (HINSTANCE hInst, const Extbyte * lpszExeFileName, UINT nIconIndex) | |
889 { | |
890 if (XEUNICODE_P) | |
891 return ExtractIconW (hInst, (LPCWSTR) lpszExeFileName, nIconIndex); | |
892 else | |
893 return ExtractIconA (hInst, (LPCSTR) lpszExeFileName, nIconIndex); | |
894 } | |
895 | |
896 #if !defined (CYGWIN_HEADERS) | |
897 | |
898 /* NOTE: NT 4.0+ only */ | |
899 DWORD | |
900 qxeDoEnvironmentSubst (Extbyte * szString, UINT cbString) | |
901 { | |
902 if (XEUNICODE_P) | |
903 return DoEnvironmentSubstW ((LPWSTR) szString, cbString); | |
904 else | |
905 return DoEnvironmentSubstA ((LPSTR) szString, cbString); | |
906 } | |
907 | |
908 #endif /* !defined (CYGWIN_HEADERS) */ | |
909 | |
910 /* Error if FindEnvironmentString used: causes link error; NT 4.0+ only */ | |
911 | |
912 /* Skipping ExtractIconEx because NT 4.0+ only, error in Cygwin prototype */ | |
913 | |
914 /* NOTE: NT 4.0+ only */ | |
915 int | |
916 qxeSHFileOperation (LPSHFILEOPSTRUCTW lpFileOp) | |
917 { | |
918 if (XEUNICODE_P) | |
919 return SHFileOperationW (lpFileOp); | |
920 else | |
921 return SHFileOperationA ((LPSHFILEOPSTRUCTA) lpFileOp); | |
922 } | |
923 | |
924 /* NOTE: NT 4.0+ only */ | |
925 BOOL | |
926 qxeShellExecuteEx (LPSHELLEXECUTEINFOW lpExecInfo) | |
927 { | |
928 if (XEUNICODE_P) | |
929 return ShellExecuteExW (lpExecInfo); | |
930 else | |
931 return ShellExecuteExA ((LPSHELLEXECUTEINFOA) lpExecInfo); | |
932 } | |
933 | |
934 /* Error if WinExecError used: causes link error; NT 4.0+ only */ | |
935 | |
936 #if !defined (CYGWIN_HEADERS) | |
937 | |
938 /* NOTE: NT 4.0+ only */ | |
939 HRESULT | |
940 qxeSHQueryRecycleBin (const Extbyte * pszRootPath, LPSHQUERYRBINFO pSHQueryRBInfo) | |
941 { | |
942 if (XEUNICODE_P) | |
943 return SHQueryRecycleBinW ((LPCWSTR) pszRootPath, pSHQueryRBInfo); | |
944 else | |
945 return SHQueryRecycleBinA ((LPCSTR) pszRootPath, pSHQueryRBInfo); | |
946 } | |
947 | |
948 #endif /* !defined (CYGWIN_HEADERS) */ | |
949 | |
950 #if !defined (CYGWIN_HEADERS) | |
951 | |
952 /* NOTE: NT 4.0+ only */ | |
953 HRESULT | |
954 qxeSHEmptyRecycleBin (HWND hwnd, const Extbyte * pszRootPath, DWORD dwFlags) | |
955 { | |
956 if (XEUNICODE_P) | |
957 return SHEmptyRecycleBinW (hwnd, (LPCWSTR) pszRootPath, dwFlags); | |
958 else | |
959 return SHEmptyRecycleBinA (hwnd, (LPCSTR) pszRootPath, dwFlags); | |
960 } | |
961 | |
962 #endif /* !defined (CYGWIN_HEADERS) */ | |
963 | |
964 /* Error if Shell_NotifyIcon used: split-sized NOTIFYICONDATA, NT 4.0+ only */ | |
965 | |
966 /* Skipping SHGetFileInfo because split-sized SHFILEINFO, NT 4.0+ only */ | |
967 | |
968 /* Error if SHGetDiskFreeSpace used: causes link error; NT 4.0+ only */ | |
969 | |
970 #if !defined (CYGWIN_HEADERS) | |
971 | |
972 /* NOTE: NT 4.0+ only */ | |
973 BOOL | |
974 qxeSHGetNewLinkInfo (const Extbyte * pszLinkTo, const Extbyte * pszDir, Extbyte * pszName, BOOL * pfMustCopy, UINT uFlags) | |
975 { | |
976 if (XEUNICODE_P) | |
977 return SHGetNewLinkInfoW ((LPCWSTR) pszLinkTo, (LPCWSTR) pszDir, (LPWSTR) pszName, pfMustCopy, uFlags); | |
978 else | |
979 return SHGetNewLinkInfoA ((LPCSTR) pszLinkTo, (LPCSTR) pszDir, (LPSTR) pszName, pfMustCopy, uFlags); | |
980 } | |
981 | |
982 #endif /* !defined (CYGWIN_HEADERS) */ | |
983 | |
984 #if !defined (CYGWIN_HEADERS) | |
985 | |
986 /* NOTE: NT 4.0+ only */ | |
987 BOOL | |
988 qxeSHInvokePrinterCommand (HWND hwnd, UINT uAction, const Extbyte * lpBuf1, const Extbyte * lpBuf2, BOOL fModal) | |
989 { | |
990 if (XEUNICODE_P) | |
991 return SHInvokePrinterCommandW (hwnd, uAction, (LPCWSTR) lpBuf1, (LPCWSTR) lpBuf2, fModal); | |
992 else | |
993 return SHInvokePrinterCommandA (hwnd, uAction, (LPCSTR) lpBuf1, (LPCSTR) lpBuf2, fModal); | |
994 } | |
995 | |
996 #endif /* !defined (CYGWIN_HEADERS) */ | |
997 | |
998 | |
999 /*----------------------------------------------------------------------*/ | |
1000 /* Processing file WINCON.H */ | |
1001 /*----------------------------------------------------------------------*/ | |
1002 | |
1003 BOOL | |
1004 qxePeekConsoleInput (HANDLE hConsoleInput, PINPUT_RECORD lpBuffer, DWORD nLength, LPDWORD lpNumberOfEventsRead) | |
1005 { | |
1006 if (XEUNICODE_P) | |
1007 return PeekConsoleInputW (hConsoleInput, lpBuffer, nLength, lpNumberOfEventsRead); | |
1008 else | |
1009 return PeekConsoleInputA (hConsoleInput, lpBuffer, nLength, lpNumberOfEventsRead); | |
1010 } | |
1011 | |
1012 BOOL | |
1013 qxeReadConsoleInput (HANDLE hConsoleInput, PINPUT_RECORD lpBuffer, DWORD nLength, LPDWORD lpNumberOfEventsRead) | |
1014 { | |
1015 if (XEUNICODE_P) | |
1016 return ReadConsoleInputW (hConsoleInput, lpBuffer, nLength, lpNumberOfEventsRead); | |
1017 else | |
1018 return ReadConsoleInputA (hConsoleInput, lpBuffer, nLength, lpNumberOfEventsRead); | |
1019 } | |
1020 | |
1021 BOOL | |
1022 qxeWriteConsoleInput (HANDLE hConsoleInput, CONST INPUT_RECORD * lpBuffer, DWORD nLength, LPDWORD lpNumberOfEventsWritten) | |
1023 { | |
1024 if (XEUNICODE_P) | |
1025 return WriteConsoleInputW (hConsoleInput, lpBuffer, nLength, lpNumberOfEventsWritten); | |
1026 else | |
1027 return WriteConsoleInputA (hConsoleInput, lpBuffer, nLength, lpNumberOfEventsWritten); | |
1028 } | |
1029 | |
1030 BOOL | |
1031 qxeReadConsoleOutput (HANDLE hConsoleOutput, PCHAR_INFO lpBuffer, COORD dwBufferSize, COORD dwBufferCoord, PSMALL_RECT lpReadRegion) | |
1032 { | |
1033 if (XEUNICODE_P) | |
1034 return ReadConsoleOutputW (hConsoleOutput, lpBuffer, dwBufferSize, dwBufferCoord, lpReadRegion); | |
1035 else | |
1036 return ReadConsoleOutputA (hConsoleOutput, lpBuffer, dwBufferSize, dwBufferCoord, lpReadRegion); | |
1037 } | |
1038 | |
1039 BOOL | |
1040 qxeWriteConsoleOutput (HANDLE hConsoleOutput, CONST CHAR_INFO * lpBuffer, COORD dwBufferSize, COORD dwBufferCoord, PSMALL_RECT lpWriteRegion) | |
1041 { | |
1042 if (XEUNICODE_P) | |
1043 return WriteConsoleOutputW (hConsoleOutput, lpBuffer, dwBufferSize, dwBufferCoord, lpWriteRegion); | |
1044 else | |
1045 return WriteConsoleOutputA (hConsoleOutput, lpBuffer, dwBufferSize, dwBufferCoord, lpWriteRegion); | |
1046 } | |
1047 | |
1048 BOOL | |
1049 qxeReadConsoleOutputCharacter (HANDLE hConsoleOutput, Extbyte * lpCharacter, DWORD nLength, COORD dwReadCoord, LPDWORD lpNumberOfCharsRead) | |
1050 { | |
1051 if (XEUNICODE_P) | |
1052 return ReadConsoleOutputCharacterW (hConsoleOutput, (LPWSTR) lpCharacter, nLength, dwReadCoord, lpNumberOfCharsRead); | |
1053 else | |
1054 return ReadConsoleOutputCharacterA (hConsoleOutput, (LPSTR) lpCharacter, nLength, dwReadCoord, lpNumberOfCharsRead); | |
1055 } | |
1056 | |
1057 BOOL | |
1058 qxeWriteConsoleOutputCharacter (HANDLE hConsoleOutput, const Extbyte * lpCharacter, DWORD nLength, COORD dwWriteCoord, LPDWORD lpNumberOfCharsWritten) | |
1059 { | |
1060 if (XEUNICODE_P) | |
1061 return WriteConsoleOutputCharacterW (hConsoleOutput, (LPCWSTR) lpCharacter, nLength, dwWriteCoord, lpNumberOfCharsWritten); | |
1062 else | |
1063 return WriteConsoleOutputCharacterA (hConsoleOutput, (LPCSTR) lpCharacter, nLength, dwWriteCoord, lpNumberOfCharsWritten); | |
1064 } | |
1065 | |
1066 /* Error if FillConsoleOutputCharacter used: split CHAR */ | |
1067 | |
1068 BOOL | |
1069 qxeScrollConsoleScreenBuffer (HANDLE hConsoleOutput, CONST SMALL_RECT * lpScrollRectangle, CONST SMALL_RECT * lpClipRectangle, COORD dwDestinationOrigin, CONST CHAR_INFO * lpFill) | |
1070 { | |
1071 if (XEUNICODE_P) | |
1072 return ScrollConsoleScreenBufferW (hConsoleOutput, lpScrollRectangle, lpClipRectangle, dwDestinationOrigin, lpFill); | |
1073 else | |
1074 return ScrollConsoleScreenBufferA (hConsoleOutput, lpScrollRectangle, lpClipRectangle, dwDestinationOrigin, lpFill); | |
1075 } | |
1076 | |
1077 DWORD | |
1078 qxeGetConsoleTitle (Extbyte * lpConsoleTitle, DWORD nSize) | |
1079 { | |
1080 if (XEUNICODE_P) | |
1081 return GetConsoleTitleW ((LPWSTR) lpConsoleTitle, nSize); | |
1082 else | |
1083 return GetConsoleTitleA ((LPSTR) lpConsoleTitle, nSize); | |
1084 } | |
1085 | |
1086 BOOL | |
1087 qxeSetConsoleTitle (const Extbyte * lpConsoleTitle) | |
1088 { | |
1089 if (XEUNICODE_P) | |
1090 return SetConsoleTitleW ((LPCWSTR) lpConsoleTitle); | |
1091 else | |
1092 return SetConsoleTitleA ((LPCSTR) lpConsoleTitle); | |
1093 } | |
1094 | |
1095 BOOL | |
1096 qxeReadConsole (HANDLE hConsoleInput, LPVOID lpBuffer, DWORD nNumberOfCharsToRead, LPDWORD lpNumberOfCharsRead, LPVOID lpReserved) | |
1097 { | |
1098 if (XEUNICODE_P) | |
1099 return ReadConsoleW (hConsoleInput, lpBuffer, nNumberOfCharsToRead, lpNumberOfCharsRead, lpReserved); | |
1100 else | |
1101 return ReadConsoleA (hConsoleInput, lpBuffer, nNumberOfCharsToRead, lpNumberOfCharsRead, lpReserved); | |
1102 } | |
1103 | |
1104 BOOL | |
1105 qxeWriteConsole (HANDLE hConsoleOutput, CONST VOID * lpBuffer, DWORD nNumberOfCharsToWrite, LPDWORD lpNumberOfCharsWritten, LPVOID lpReserved) | |
1106 { | |
1107 if (XEUNICODE_P) | |
1108 return WriteConsoleW (hConsoleOutput, lpBuffer, nNumberOfCharsToWrite, lpNumberOfCharsWritten, lpReserved); | |
1109 else | |
1110 return WriteConsoleA (hConsoleOutput, lpBuffer, nNumberOfCharsToWrite, lpNumberOfCharsWritten, lpReserved); | |
1111 } | |
1112 | |
1113 | |
1114 /*----------------------------------------------------------------------*/ | |
1115 /* Processing file IMM.H */ | |
1116 /*----------------------------------------------------------------------*/ | |
1117 | |
1118 #if defined (HAVE_MS_WINDOWS) | |
1119 | |
1120 HKL | |
1121 qxeImmInstallIME (const Extbyte * lpszIMEFileName, const Extbyte * lpszLayoutText) | |
1122 { | |
1123 if (XEUNICODE_P) | |
1124 return ImmInstallIMEW ((LPCWSTR) lpszIMEFileName, (LPCWSTR) lpszLayoutText); | |
1125 else | |
1126 return ImmInstallIMEA ((LPCSTR) lpszIMEFileName, (LPCSTR) lpszLayoutText); | |
1127 } | |
1128 | |
1129 #endif /* defined (HAVE_MS_WINDOWS) */ | |
1130 | |
1131 #if defined (HAVE_MS_WINDOWS) | |
1132 | |
1133 UINT | |
1134 qxeImmGetDescription (HKL arg1, Extbyte * arg2, UINT uBufLen) | |
1135 { | |
1136 if (XEUNICODE_P) | |
1137 return ImmGetDescriptionW (arg1, (LPWSTR) arg2, uBufLen); | |
1138 else | |
1139 return ImmGetDescriptionA (arg1, (LPSTR) arg2, uBufLen); | |
1140 } | |
1141 | |
1142 #endif /* defined (HAVE_MS_WINDOWS) */ | |
1143 | |
1144 #if defined (HAVE_MS_WINDOWS) | |
1145 | |
1146 UINT | |
1147 qxeImmGetIMEFileName (HKL arg1, Extbyte * arg2, UINT uBufLen) | |
1148 { | |
1149 if (XEUNICODE_P) | |
1150 return ImmGetIMEFileNameW (arg1, (LPWSTR) arg2, uBufLen); | |
1151 else | |
1152 return ImmGetIMEFileNameA (arg1, (LPSTR) arg2, uBufLen); | |
1153 } | |
1154 | |
1155 #endif /* defined (HAVE_MS_WINDOWS) */ | |
1156 | |
1157 #if defined (HAVE_MS_WINDOWS) | |
1158 | |
1159 LONG | |
1160 qxeImmGetCompositionString (HIMC arg1, DWORD arg2, LPVOID arg3, DWORD arg4) | |
1161 { | |
1162 if (XEUNICODE_P) | |
1163 return ImmGetCompositionStringW (arg1, arg2, arg3, arg4); | |
1164 else | |
1165 return ImmGetCompositionStringA (arg1, arg2, arg3, arg4); | |
1166 } | |
1167 | |
1168 #endif /* defined (HAVE_MS_WINDOWS) */ | |
1169 | |
1170 #if defined (HAVE_MS_WINDOWS) | |
1171 | |
1172 BOOL | |
1173 qxeImmSetCompositionString (HIMC arg1, DWORD dwIndex, LPCVOID lpComp, DWORD arg4, LPCVOID lpRead, DWORD arg6) | |
1174 { | |
1175 if (XEUNICODE_P) | |
1176 return ImmSetCompositionStringW (arg1, dwIndex, lpComp, arg4, lpRead, arg6); | |
1177 else | |
1178 return ImmSetCompositionStringA (arg1, dwIndex, lpComp, arg4, lpRead, arg6); | |
1179 } | |
1180 | |
1181 #endif /* defined (HAVE_MS_WINDOWS) */ | |
1182 | |
1183 #if defined (HAVE_MS_WINDOWS) | |
1184 | |
1185 DWORD | |
1186 qxeImmGetCandidateListCount (HIMC arg1, LPDWORD lpdwListCount) | |
1187 { | |
1188 if (XEUNICODE_P) | |
1189 return ImmGetCandidateListCountW (arg1, lpdwListCount); | |
1190 else | |
1191 return ImmGetCandidateListCountA (arg1, lpdwListCount); | |
1192 } | |
1193 | |
1194 #endif /* defined (HAVE_MS_WINDOWS) */ | |
1195 | |
1196 #if defined (HAVE_MS_WINDOWS) | |
1197 | |
1198 DWORD | |
1199 qxeImmGetCandidateList (HIMC arg1, DWORD deIndex, LPCANDIDATELIST arg3, DWORD dwBufLen) | |
1200 { | |
1201 if (XEUNICODE_P) | |
1202 return ImmGetCandidateListW (arg1, deIndex, arg3, dwBufLen); | |
1203 else | |
1204 return ImmGetCandidateListA (arg1, deIndex, arg3, dwBufLen); | |
1205 } | |
1206 | |
1207 #endif /* defined (HAVE_MS_WINDOWS) */ | |
1208 | |
1209 #if defined (HAVE_MS_WINDOWS) | |
1210 | |
1211 DWORD | |
1212 qxeImmGetGuideLine (HIMC arg1, DWORD dwIndex, Extbyte * arg3, DWORD dwBufLen) | |
1213 { | |
1214 if (XEUNICODE_P) | |
1215 return ImmGetGuideLineW (arg1, dwIndex, (LPWSTR) arg3, dwBufLen); | |
1216 else | |
1217 return ImmGetGuideLineA (arg1, dwIndex, (LPSTR) arg3, dwBufLen); | |
1218 } | |
1219 | |
1220 #endif /* defined (HAVE_MS_WINDOWS) */ | |
1221 | |
1222 #if defined (HAVE_MS_WINDOWS) | |
1223 | |
1224 /* Skipping ImmGetCompositionFont because split-sized LOGFONT */ | |
1225 | |
1226 #endif /* defined (HAVE_MS_WINDOWS) */ | |
1227 | |
1228 #if defined (HAVE_MS_WINDOWS) | |
1229 | |
1230 /* Skipping ImmSetCompositionFont because split-sized LOGFONT */ | |
1231 | |
1232 #endif /* defined (HAVE_MS_WINDOWS) */ | |
1233 | |
1234 #if defined (HAVE_MS_WINDOWS) | |
1235 | |
1236 /* NOTE: // split-simple REGISTERWORD */ | |
1237 BOOL | |
1238 qxeImmConfigureIME (HKL arg1, HWND arg2, DWORD arg3, LPVOID arg4) | |
1239 { | |
1240 if (XEUNICODE_P) | |
1241 return ImmConfigureIMEW (arg1, arg2, arg3, arg4); | |
1242 else | |
1243 return ImmConfigureIMEA (arg1, arg2, arg3, arg4); | |
1244 } | |
1245 | |
1246 #endif /* defined (HAVE_MS_WINDOWS) */ | |
1247 | |
1248 #if defined (HAVE_MS_WINDOWS) | |
1249 | |
1250 /* NOTE: // strings of various sorts */ | |
1251 LRESULT | |
1252 qxeImmEscape (HKL arg1, HIMC arg2, UINT arg3, LPVOID arg4) | |
1253 { | |
1254 if (XEUNICODE_P) | |
1255 return ImmEscapeW (arg1, arg2, arg3, arg4); | |
1256 else | |
1257 return ImmEscapeA (arg1, arg2, arg3, arg4); | |
1258 } | |
1259 | |
1260 #endif /* defined (HAVE_MS_WINDOWS) */ | |
1261 | |
1262 #if defined (HAVE_MS_WINDOWS) | |
1263 | |
1264 DWORD | |
1265 qxeImmGetConversionList (HKL arg1, HIMC arg2, const Extbyte * arg3, LPCANDIDATELIST arg4, DWORD dwBufLen, UINT uFlag) | |
1266 { | |
1267 if (XEUNICODE_P) | |
1268 return ImmGetConversionListW (arg1, arg2, (LPCWSTR) arg3, arg4, dwBufLen, uFlag); | |
1269 else | |
1270 return ImmGetConversionListA (arg1, arg2, (LPCSTR) arg3, arg4, dwBufLen, uFlag); | |
1271 } | |
1272 | |
1273 #endif /* defined (HAVE_MS_WINDOWS) */ | |
1274 | |
1275 #if defined (HAVE_MS_WINDOWS) | |
1276 | |
1277 BOOL | |
1278 qxeImmIsUIMessage (HWND arg1, UINT arg2, WPARAM arg3, LPARAM arg4) | |
1279 { | |
1280 if (XEUNICODE_P) | |
1281 return ImmIsUIMessageW (arg1, arg2, arg3, arg4); | |
1282 else | |
1283 return ImmIsUIMessageA (arg1, arg2, arg3, arg4); | |
1284 } | |
1285 | |
1286 #endif /* defined (HAVE_MS_WINDOWS) */ | |
1287 | |
1288 #if defined (HAVE_MS_WINDOWS) | |
1289 | |
1290 BOOL | |
1291 qxeImmRegisterWord (HKL arg1, const Extbyte * lpszReading, DWORD arg3, const Extbyte * lpszRegister) | |
1292 { | |
1293 if (XEUNICODE_P) | |
1294 return ImmRegisterWordW (arg1, (LPCWSTR) lpszReading, arg3, (LPCWSTR) lpszRegister); | |
1295 else | |
1296 return ImmRegisterWordA (arg1, (LPCSTR) lpszReading, arg3, (LPCSTR) lpszRegister); | |
1297 } | |
1298 | |
1299 #endif /* defined (HAVE_MS_WINDOWS) */ | |
1300 | |
1301 #if defined (HAVE_MS_WINDOWS) | |
1302 | |
1303 BOOL | |
1304 qxeImmUnregisterWord (HKL arg1, const Extbyte * lpszReading, DWORD arg3, const Extbyte * lpszUnregister) | |
1305 { | |
1306 if (XEUNICODE_P) | |
1307 return ImmUnregisterWordW (arg1, (LPCWSTR) lpszReading, arg3, (LPCWSTR) lpszUnregister); | |
1308 else | |
1309 return ImmUnregisterWordA (arg1, (LPCSTR) lpszReading, arg3, (LPCSTR) lpszUnregister); | |
1310 } | |
1311 | |
1312 #endif /* defined (HAVE_MS_WINDOWS) */ | |
1313 | |
1314 #if defined (HAVE_MS_WINDOWS) | |
1315 | |
1316 /* Error if ImmGetRegisterWordStyle used: split-sized STYLEBUF */ | |
1317 | |
1318 #endif /* defined (HAVE_MS_WINDOWS) */ | |
1319 | |
1320 #if defined (HAVE_MS_WINDOWS) | |
1321 | |
1322 UINT | |
1323 qxeImmEnumRegisterWord (HKL arg1, REGISTERWORDENUMPROCW arg2, const Extbyte * lpszReading, DWORD arg4, const Extbyte * lpszRegister, LPVOID arg6) | |
1324 { | |
1325 if (XEUNICODE_P) | |
1326 return ImmEnumRegisterWordW (arg1, arg2, (LPCWSTR) lpszReading, arg4, (LPCWSTR) lpszRegister, arg6); | |
1327 else | |
1328 return ImmEnumRegisterWordA (arg1, (REGISTERWORDENUMPROCA) arg2, (LPCSTR) lpszReading, arg4, (LPCSTR) lpszRegister, arg6); | |
1329 } | |
1330 | |
1331 #endif /* defined (HAVE_MS_WINDOWS) */ | |
1332 | |
1333 #if defined (HAVE_MS_WINDOWS) | |
1334 | |
1335 /* Error if ImmGetImeMenuItems used: split-sized IMEMENUITEMINFO */ | |
1336 | |
1337 #endif /* defined (HAVE_MS_WINDOWS) */ | |
1338 | |
1339 | |
1340 /*----------------------------------------------------------------------*/ | |
1341 /* Processing file DDEML.H */ | |
1342 /*----------------------------------------------------------------------*/ | |
1343 | |
1344 UINT | |
1345 qxeDdeInitialize (LPDWORD pidInst, PFNCALLBACK pfnCallback, DWORD afCmd, DWORD ulRes) | |
1346 { | |
1347 if (XEUNICODE_P) | |
1348 return DdeInitializeW (pidInst, pfnCallback, afCmd, ulRes); | |
1349 else | |
1350 return DdeInitializeA (pidInst, pfnCallback, afCmd, ulRes); | |
1351 } | |
1352 | |
1353 HSZ | |
1354 qxeDdeCreateStringHandle (DWORD idInst, const Extbyte * psz, int iCodePage) | |
1355 { | |
1356 if (XEUNICODE_P) | |
1357 return DdeCreateStringHandleW (idInst, (LPCWSTR) psz, iCodePage); | |
1358 else | |
1359 return DdeCreateStringHandleA (idInst, (LPCSTR) psz, iCodePage); | |
1360 } | |
1361 | |
1362 DWORD | |
1363 qxeDdeQueryString (DWORD idInst, HSZ hsz, Extbyte * psz, DWORD cchMax, int iCodePage) | |
1364 { | |
1365 if (XEUNICODE_P) | |
1366 return DdeQueryStringW (idInst, hsz, (LPWSTR) psz, cchMax, iCodePage); | |
1367 else | |
1368 return DdeQueryStringA (idInst, hsz, (LPSTR) psz, cchMax, iCodePage); | |
1369 } | |
1370 | |
1371 | |
1372 /*----------------------------------------------------------------------*/ | |
1373 /* Processing file WINUSER.H */ | |
1374 /*----------------------------------------------------------------------*/ | |
1375 | |
1376 int | |
1377 qxewvsprintf (Extbyte * arg1, const Extbyte * arg2, va_list arglist) | |
1378 { | |
1379 if (XEUNICODE_P) | |
1380 return wvsprintfW ((LPWSTR) arg1, (LPCWSTR) arg2, arglist); | |
1381 else | |
1382 return wvsprintfA ((LPSTR) arg1, (LPCSTR) arg2, arglist); | |
1383 } | |
1384 | |
1385 HKL | |
1386 qxeLoadKeyboardLayout (const Extbyte * pwszKLID, UINT Flags) | |
1387 { | |
1388 if (XEUNICODE_P) | |
1389 return LoadKeyboardLayoutW ((LPCWSTR) pwszKLID, Flags); | |
1390 else | |
1391 return LoadKeyboardLayoutA ((LPCSTR) pwszKLID, Flags); | |
1392 } | |
1393 | |
1394 BOOL | |
1395 qxeGetKeyboardLayoutName (Extbyte * pwszKLID) | |
1396 { | |
1397 if (XEUNICODE_P) | |
1398 return GetKeyboardLayoutNameW ((LPWSTR) pwszKLID); | |
1399 else | |
1400 return GetKeyboardLayoutNameA ((LPSTR) pwszKLID); | |
1401 } | |
1402 | |
1403 /* Error if CreateDesktop used: split-sized LPDEVMODE */ | |
1404 | |
1405 HDESK | |
1406 qxeOpenDesktop (Extbyte * lpszDesktop, DWORD dwFlags, BOOL fInherit, ACCESS_MASK dwDesiredAccess) | |
1407 { | |
1408 if (XEUNICODE_P) | |
1409 return OpenDesktopW ((LPWSTR) lpszDesktop, dwFlags, fInherit, dwDesiredAccess); | |
1410 else | |
1411 return OpenDesktopA ((LPSTR) lpszDesktop, dwFlags, fInherit, dwDesiredAccess); | |
1412 } | |
1413 | |
1414 /* NOTE: // callback fun differs only in string pointer type */ | |
1415 BOOL | |
1416 qxeEnumDesktops (HWINSTA hwinsta, DESKTOPENUMPROCW lpEnumFunc, LPARAM lParam) | |
1417 { | |
1418 if (XEUNICODE_P) | |
1419 return EnumDesktopsW (hwinsta, lpEnumFunc, lParam); | |
1420 else | |
1421 return EnumDesktopsA (hwinsta, (DESKTOPENUMPROCA) lpEnumFunc, lParam); | |
1422 } | |
1423 | |
1424 HWINSTA | |
1425 qxeCreateWindowStation (Extbyte * lpwinsta, DWORD dwReserved, ACCESS_MASK dwDesiredAccess, LPSECURITY_ATTRIBUTES lpsa) | |
1426 { | |
1427 if (XEUNICODE_P) | |
1428 return CreateWindowStationW ((LPWSTR) lpwinsta, dwReserved, dwDesiredAccess, lpsa); | |
1429 else | |
1430 return CreateWindowStationA ((LPSTR) lpwinsta, dwReserved, dwDesiredAccess, lpsa); | |
1431 } | |
1432 | |
1433 HWINSTA | |
1434 qxeOpenWindowStation (Extbyte * lpszWinSta, BOOL fInherit, ACCESS_MASK dwDesiredAccess) | |
1435 { | |
1436 if (XEUNICODE_P) | |
1437 return OpenWindowStationW ((LPWSTR) lpszWinSta, fInherit, dwDesiredAccess); | |
1438 else | |
1439 return OpenWindowStationA ((LPSTR) lpszWinSta, fInherit, dwDesiredAccess); | |
1440 } | |
1441 | |
1442 /* NOTE: // callback fun differs only in string pointer type */ | |
1443 BOOL | |
1444 qxeEnumWindowStations (WINSTAENUMPROCW lpEnumFunc, LPARAM lParam) | |
1445 { | |
1446 if (XEUNICODE_P) | |
1447 return EnumWindowStationsW (lpEnumFunc, lParam); | |
1448 else | |
1449 return EnumWindowStationsA ((WINSTAENUMPROCA) lpEnumFunc, lParam); | |
1450 } | |
1451 | |
1452 BOOL | |
1453 qxeGetUserObjectInformation (HANDLE hObj, int nIndex, PVOID pvInfo, DWORD nLength, LPDWORD lpnLengthNeeded) | |
1454 { | |
1455 if (XEUNICODE_P) | |
1456 return GetUserObjectInformationW (hObj, nIndex, pvInfo, nLength, lpnLengthNeeded); | |
1457 else | |
1458 return GetUserObjectInformationA (hObj, nIndex, pvInfo, nLength, lpnLengthNeeded); | |
1459 } | |
1460 | |
1461 BOOL | |
1462 qxeSetUserObjectInformation (HANDLE hObj, int nIndex, PVOID pvInfo, DWORD nLength) | |
1463 { | |
1464 if (XEUNICODE_P) | |
1465 return SetUserObjectInformationW (hObj, nIndex, pvInfo, nLength); | |
1466 else | |
1467 return SetUserObjectInformationA (hObj, nIndex, pvInfo, nLength); | |
1468 } | |
1469 | |
1470 UINT | |
1471 qxeRegisterWindowMessage (const Extbyte * lpString) | |
1472 { | |
1473 if (XEUNICODE_P) | |
1474 return RegisterWindowMessageW ((LPCWSTR) lpString); | |
1475 else | |
1476 return RegisterWindowMessageA ((LPCSTR) lpString); | |
1477 } | |
1478 | |
1479 BOOL | |
1480 qxeGetMessage (LPMSG lpMsg, HWND hWnd, UINT wMsgFilterMin, UINT wMsgFilterMax) | |
1481 { | |
1482 if (XEUNICODE_P) | |
1483 return GetMessageW (lpMsg, hWnd, wMsgFilterMin, wMsgFilterMax); | |
1484 else | |
1485 return GetMessageA (lpMsg, hWnd, wMsgFilterMin, wMsgFilterMax); | |
1486 } | |
1487 | |
1488 LONG | |
1489 qxeDispatchMessage (CONST MSG * lpMsg) | |
1490 { | |
1491 if (XEUNICODE_P) | |
1492 return DispatchMessageW (lpMsg); | |
1493 else | |
1494 return DispatchMessageA (lpMsg); | |
1495 } | |
1496 | |
1497 BOOL | |
1498 qxePeekMessage (LPMSG lpMsg, HWND hWnd, UINT wMsgFilterMin, UINT wMsgFilterMax, UINT wRemoveMsg) | |
1499 { | |
1500 if (XEUNICODE_P) | |
1501 return PeekMessageW (lpMsg, hWnd, wMsgFilterMin, wMsgFilterMax, wRemoveMsg); | |
1502 else | |
1503 return PeekMessageA (lpMsg, hWnd, wMsgFilterMin, wMsgFilterMax, wRemoveMsg); | |
1504 } | |
1505 | |
1506 /* Skipping SendMessage because split messages and structures */ | |
1507 | |
1508 LRESULT | |
1509 qxeSendMessageTimeout (HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam, UINT fuFlags, UINT uTimeout, LPDWORD lpdwResult) | |
1510 { | |
1511 if (XEUNICODE_P) | |
1512 return SendMessageTimeoutW (hWnd, Msg, wParam, lParam, fuFlags, uTimeout, lpdwResult); | |
1513 else | |
1514 return SendMessageTimeoutA (hWnd, Msg, wParam, lParam, fuFlags, uTimeout, lpdwResult); | |
1515 } | |
1516 | |
1517 BOOL | |
1518 qxeSendNotifyMessage (HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam) | |
1519 { | |
1520 if (XEUNICODE_P) | |
1521 return SendNotifyMessageW (hWnd, Msg, wParam, lParam); | |
1522 else | |
1523 return SendNotifyMessageA (hWnd, Msg, wParam, lParam); | |
1524 } | |
1525 | |
1526 BOOL | |
1527 qxeSendMessageCallback (HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam, SENDASYNCPROC lpResultCallBack, DWORD dwData) | |
1528 { | |
1529 if (XEUNICODE_P) | |
1530 return SendMessageCallbackW (hWnd, Msg, wParam, lParam, lpResultCallBack, dwData); | |
1531 else | |
1532 return SendMessageCallbackA (hWnd, Msg, wParam, lParam, lpResultCallBack, dwData); | |
1533 } | |
1534 | |
1535 /* Error if BroadcastSystemMessage used: win95 version not split; NT 4.0+ only */ | |
1536 | |
1537 /* Error if RegisterDeviceNotification used: NT 5.0+ only */ | |
1538 | |
1539 BOOL | |
1540 qxePostMessage (HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam) | |
1541 { | |
1542 if (XEUNICODE_P) | |
1543 return PostMessageW (hWnd, Msg, wParam, lParam); | |
1544 else | |
1545 return PostMessageA (hWnd, Msg, wParam, lParam); | |
1546 } | |
1547 | |
1548 BOOL | |
1549 qxePostThreadMessage (DWORD idThread, UINT Msg, WPARAM wParam, LPARAM lParam) | |
1550 { | |
1551 if (XEUNICODE_P) | |
1552 return PostThreadMessageW (idThread, Msg, wParam, lParam); | |
1553 else | |
1554 return PostThreadMessageA (idThread, Msg, wParam, lParam); | |
1555 } | |
1556 | |
1557 /* Skipping DefWindowProc because return value is conditionalized on _MAC, messes up parser */ | |
1558 | |
1559 /* Error if CallWindowProc used: two versions, STRICT and non-STRICT */ | |
1560 | |
1561 /* Error if CallWindowProc used: two versions, STRICT and non-STRICT */ | |
1562 | |
1563 /* Skipping RegisterClass because need to intercept so we can provide our own window procedure and handle split notify messages; split-simple WNDCLASS */ | |
1564 | |
1565 /* Skipping UnregisterClass because need to intercept for reasons related to RegisterClass */ | |
1566 | |
1567 BOOL | |
1568 qxeGetClassInfo (HINSTANCE hInstance, const Extbyte * lpClassName, LPWNDCLASSW lpWndClass) | |
1569 { | |
1570 if (XEUNICODE_P) | |
1571 return GetClassInfoW (hInstance, (LPCWSTR) lpClassName, lpWndClass); | |
1572 else | |
1573 return GetClassInfoA (hInstance, (LPCSTR) lpClassName, (LPWNDCLASSA) lpWndClass); | |
1574 } | |
1575 | |
1576 /* Skipping RegisterClassEx because need to intercept so we can provide our own window procedure and handle split notify messages; split-simple WNDCLASSEX; NT 4.0+ only */ | |
1577 | |
1578 /* NOTE: NT 4.0+ only */ | |
1579 BOOL | |
1580 qxeGetClassInfoEx (HINSTANCE arg1, const Extbyte * arg2, LPWNDCLASSEXW arg3) | |
1581 { | |
1582 if (XEUNICODE_P) | |
1583 return GetClassInfoExW (arg1, (LPCWSTR) arg2, arg3); | |
1584 else | |
1585 return GetClassInfoExA (arg1, (LPCSTR) arg2, (LPWNDCLASSEXA) arg3); | |
1586 } | |
1587 | |
1588 HWND | |
1589 qxeCreateWindowEx (DWORD dwExStyle, const Extbyte * lpClassName, const Extbyte * lpWindowName, DWORD dwStyle, int X, int Y, int nWidth, int nHeight, HWND hWndParent, HMENU hMenu, HINSTANCE hInstance, LPVOID lpParam) | |
1590 { | |
1591 if (XEUNICODE_P) | |
1592 return CreateWindowExW (dwExStyle, (LPCWSTR) lpClassName, (LPCWSTR) lpWindowName, dwStyle, X, Y, nWidth, nHeight, hWndParent, hMenu, hInstance, lpParam); | |
1593 else | |
1594 return CreateWindowExA (dwExStyle, (LPCSTR) lpClassName, (LPCSTR) lpWindowName, dwStyle, X, Y, nWidth, nHeight, hWndParent, hMenu, hInstance, lpParam); | |
1595 } | |
1596 | |
1597 HWND | |
1598 qxeCreateDialogParam (HINSTANCE hInstance, const Extbyte * lpTemplateName, HWND hWndParent, DLGPROC lpDialogFunc, LPARAM dwInitParam) | |
1599 { | |
1600 if (XEUNICODE_P) | |
1601 return CreateDialogParamW (hInstance, (LPCWSTR) lpTemplateName, hWndParent, lpDialogFunc, dwInitParam); | |
1602 else | |
1603 return CreateDialogParamA (hInstance, (LPCSTR) lpTemplateName, hWndParent, lpDialogFunc, dwInitParam); | |
1604 } | |
1605 | |
1606 /* NOTE: error in Cygwin prototype (no split) but fixable with typedef */ | |
1607 HWND | |
1608 qxeCreateDialogIndirectParam (HINSTANCE hInstance, LPCDLGTEMPLATEW lpTemplate, HWND hWndParent, DLGPROC lpDialogFunc, LPARAM dwInitParam) | |
1609 { | |
1610 if (XEUNICODE_P) | |
1611 return CreateDialogIndirectParamW (hInstance, lpTemplate, hWndParent, lpDialogFunc, dwInitParam); | |
1612 else | |
1613 return CreateDialogIndirectParamA (hInstance, (LPCDLGTEMPLATEA) lpTemplate, hWndParent, lpDialogFunc, dwInitParam); | |
1614 } | |
1615 | |
1616 int | |
1617 qxeDialogBoxParam (HINSTANCE hInstance, const Extbyte * lpTemplateName, HWND hWndParent, DLGPROC lpDialogFunc, LPARAM dwInitParam) | |
1618 { | |
1619 if (XEUNICODE_P) | |
1620 return DialogBoxParamW (hInstance, (LPCWSTR) lpTemplateName, hWndParent, lpDialogFunc, dwInitParam); | |
1621 else | |
1622 return DialogBoxParamA (hInstance, (LPCSTR) lpTemplateName, hWndParent, lpDialogFunc, dwInitParam); | |
1623 } | |
1624 | |
1625 /* NOTE: error in Cygwin prototype (no split) but fixable with typedef */ | |
1626 int | |
1627 qxeDialogBoxIndirectParam (HINSTANCE hInstance, LPCDLGTEMPLATEW hDialogTemplate, HWND hWndParent, DLGPROC lpDialogFunc, LPARAM dwInitParam) | |
1628 { | |
1629 if (XEUNICODE_P) | |
1630 return DialogBoxIndirectParamW (hInstance, hDialogTemplate, hWndParent, lpDialogFunc, dwInitParam); | |
1631 else | |
1632 return DialogBoxIndirectParamA (hInstance, (LPCDLGTEMPLATEA) hDialogTemplate, hWndParent, lpDialogFunc, dwInitParam); | |
1633 } | |
1634 | |
1635 BOOL | |
1636 qxeSetDlgItemText (HWND hDlg, int nIDDlgItem, const Extbyte * lpString) | |
1637 { | |
1638 if (XEUNICODE_P) | |
1639 return SetDlgItemTextW (hDlg, nIDDlgItem, (LPCWSTR) lpString); | |
1640 else | |
1641 return SetDlgItemTextA (hDlg, nIDDlgItem, (LPCSTR) lpString); | |
1642 } | |
1643 | |
1644 UINT | |
1645 qxeGetDlgItemText (HWND hDlg, int nIDDlgItem, Extbyte * lpString, int nMaxCount) | |
1646 { | |
1647 if (XEUNICODE_P) | |
1648 return GetDlgItemTextW (hDlg, nIDDlgItem, (LPWSTR) lpString, nMaxCount); | |
1649 else | |
1650 return GetDlgItemTextA (hDlg, nIDDlgItem, (LPSTR) lpString, nMaxCount); | |
1651 } | |
1652 | |
1653 LONG | |
1654 qxeSendDlgItemMessage (HWND hDlg, int nIDDlgItem, UINT Msg, WPARAM wParam, LPARAM lParam) | |
1655 { | |
1656 if (XEUNICODE_P) | |
1657 return SendDlgItemMessageW (hDlg, nIDDlgItem, Msg, wParam, lParam); | |
1658 else | |
1659 return SendDlgItemMessageA (hDlg, nIDDlgItem, Msg, wParam, lParam); | |
1660 } | |
1661 | |
1662 /* Error if DefDlgProc used: return value is conditionalized on _MAC, messes up parser */ | |
1663 | |
1664 #if !defined (CYGWIN_HEADERS) | |
1665 | |
1666 BOOL | |
1667 qxeCallMsgFilter (LPMSG lpMsg, int nCode) | |
1668 { | |
1669 if (XEUNICODE_P) | |
1670 return CallMsgFilterW (lpMsg, nCode); | |
1671 else | |
1672 return CallMsgFilterA (lpMsg, nCode); | |
1673 } | |
1674 | |
1675 #endif /* !defined (CYGWIN_HEADERS) */ | |
1676 | |
1677 UINT | |
1678 qxeRegisterClipboardFormat (const Extbyte * lpszFormat) | |
1679 { | |
1680 if (XEUNICODE_P) | |
1681 return RegisterClipboardFormatW ((LPCWSTR) lpszFormat); | |
1682 else | |
1683 return RegisterClipboardFormatA ((LPCSTR) lpszFormat); | |
1684 } | |
1685 | |
1686 int | |
1687 qxeGetClipboardFormatName (UINT format, Extbyte * lpszFormatName, int cchMaxCount) | |
1688 { | |
1689 if (XEUNICODE_P) | |
1690 return GetClipboardFormatNameW (format, (LPWSTR) lpszFormatName, cchMaxCount); | |
1691 else | |
1692 return GetClipboardFormatNameA (format, (LPSTR) lpszFormatName, cchMaxCount); | |
1693 } | |
1694 | |
1695 BOOL | |
1696 qxeCharToOem (const Extbyte * lpszSrc, LPSTR lpszDst) | |
1697 { | |
1698 if (XEUNICODE_P) | |
1699 return CharToOemW ((LPCWSTR) lpszSrc, lpszDst); | |
1700 else | |
1701 return CharToOemA ((LPCSTR) lpszSrc, lpszDst); | |
1702 } | |
1703 | |
1704 BOOL | |
1705 qxeOemToChar (LPCSTR lpszSrc, Extbyte * lpszDst) | |
1706 { | |
1707 if (XEUNICODE_P) | |
1708 return OemToCharW (lpszSrc, (LPWSTR) lpszDst); | |
1709 else | |
1710 return OemToCharA (lpszSrc, (LPSTR) lpszDst); | |
1711 } | |
1712 | |
1713 BOOL | |
1714 qxeCharToOemBuff (const Extbyte * lpszSrc, LPSTR lpszDst, DWORD cchDstLength) | |
1715 { | |
1716 if (XEUNICODE_P) | |
1717 return CharToOemBuffW ((LPCWSTR) lpszSrc, lpszDst, cchDstLength); | |
1718 else | |
1719 return CharToOemBuffA ((LPCSTR) lpszSrc, lpszDst, cchDstLength); | |
1720 } | |
1721 | |
1722 BOOL | |
1723 qxeOemToCharBuff (LPCSTR lpszSrc, Extbyte * lpszDst, DWORD cchDstLength) | |
1724 { | |
1725 if (XEUNICODE_P) | |
1726 return OemToCharBuffW (lpszSrc, (LPWSTR) lpszDst, cchDstLength); | |
1727 else | |
1728 return OemToCharBuffA (lpszSrc, (LPSTR) lpszDst, cchDstLength); | |
1729 } | |
1730 | |
1731 Extbyte * | |
1732 qxeCharUpper (Extbyte * lpsz) | |
1733 { | |
1734 if (XEUNICODE_P) | |
1735 return (Extbyte *) CharUpperW ((LPWSTR) lpsz); | |
1736 else | |
1737 return (Extbyte *) CharUpperA ((LPSTR) lpsz); | |
1738 } | |
1739 | |
1740 DWORD | |
1741 qxeCharUpperBuff (Extbyte * lpsz, DWORD cchLength) | |
1742 { | |
1743 if (XEUNICODE_P) | |
1744 return CharUpperBuffW ((LPWSTR) lpsz, cchLength); | |
1745 else | |
1746 return CharUpperBuffA ((LPSTR) lpsz, cchLength); | |
1747 } | |
1748 | |
1749 Extbyte * | |
1750 qxeCharLower (Extbyte * lpsz) | |
1751 { | |
1752 if (XEUNICODE_P) | |
1753 return (Extbyte *) CharLowerW ((LPWSTR) lpsz); | |
1754 else | |
1755 return (Extbyte *) CharLowerA ((LPSTR) lpsz); | |
1756 } | |
1757 | |
1758 DWORD | |
1759 qxeCharLowerBuff (Extbyte * lpsz, DWORD cchLength) | |
1760 { | |
1761 if (XEUNICODE_P) | |
1762 return CharLowerBuffW ((LPWSTR) lpsz, cchLength); | |
1763 else | |
1764 return CharLowerBuffA ((LPSTR) lpsz, cchLength); | |
1765 } | |
1766 | |
1767 Extbyte * | |
1768 qxeCharNext (const Extbyte * lpsz) | |
1769 { | |
1770 if (XEUNICODE_P) | |
1771 return (Extbyte *) CharNextW ((LPCWSTR) lpsz); | |
1772 else | |
1773 return (Extbyte *) CharNextA ((LPCSTR) lpsz); | |
1774 } | |
1775 | |
1776 Extbyte * | |
1777 qxeCharPrev (const Extbyte * lpszStart, const Extbyte * lpszCurrent) | |
1778 { | |
1779 if (XEUNICODE_P) | |
1780 return (Extbyte *) CharPrevW ((LPCWSTR) lpszStart, (LPCWSTR) lpszCurrent); | |
1781 else | |
1782 return (Extbyte *) CharPrevA ((LPCSTR) lpszStart, (LPCSTR) lpszCurrent); | |
1783 } | |
1784 | |
1785 /* Error if IsCharAlpha used: split CHAR */ | |
1786 | |
1787 /* Error if IsCharAlphaNumeric used: split CHAR */ | |
1788 | |
1789 /* Error if IsCharUpper used: split CHAR */ | |
1790 | |
1791 /* Error if IsCharLower used: split CHAR */ | |
1792 | |
1793 int | |
1794 qxeGetKeyNameText (LONG lParam, Extbyte * lpString, int nSize) | |
1795 { | |
1796 if (XEUNICODE_P) | |
1797 return GetKeyNameTextW (lParam, (LPWSTR) lpString, nSize); | |
1798 else | |
1799 return GetKeyNameTextA (lParam, (LPSTR) lpString, nSize); | |
1800 } | |
1801 | |
1802 /* Skipping VkKeyScan because split CHAR */ | |
1803 | |
1804 /* Error if VkKeyScanEx used: split CHAR; NT 4.0+ only */ | |
1805 | |
1806 UINT | |
1807 qxeMapVirtualKey (UINT uCode, UINT uMapType) | |
1808 { | |
1809 if (XEUNICODE_P) | |
1810 return MapVirtualKeyW (uCode, uMapType); | |
1811 else | |
1812 return MapVirtualKeyA (uCode, uMapType); | |
1813 } | |
1814 | |
1815 /* NOTE: NT 4.0+ only */ | |
1816 UINT | |
1817 qxeMapVirtualKeyEx (UINT uCode, UINT uMapType, HKL dwhkl) | |
1818 { | |
1819 if (XEUNICODE_P) | |
1820 return MapVirtualKeyExW (uCode, uMapType, dwhkl); | |
1821 else | |
1822 return MapVirtualKeyExA (uCode, uMapType, dwhkl); | |
1823 } | |
1824 | |
1825 HACCEL | |
1826 qxeLoadAccelerators (HINSTANCE hInstance, const Extbyte * lpTableName) | |
1827 { | |
1828 if (XEUNICODE_P) | |
1829 return LoadAcceleratorsW (hInstance, (LPCWSTR) lpTableName); | |
1830 else | |
1831 return LoadAcceleratorsA (hInstance, (LPCSTR) lpTableName); | |
1832 } | |
1833 | |
1834 HACCEL | |
1835 qxeCreateAcceleratorTable (LPACCEL arg1, int arg2) | |
1836 { | |
1837 if (XEUNICODE_P) | |
1838 return CreateAcceleratorTableW (arg1, arg2); | |
1839 else | |
1840 return CreateAcceleratorTableA (arg1, arg2); | |
1841 } | |
1842 | |
1843 int | |
1844 qxeCopyAcceleratorTable (HACCEL hAccelSrc, LPACCEL lpAccelDst, int cAccelEntries) | |
1845 { | |
1846 if (XEUNICODE_P) | |
1847 return CopyAcceleratorTableW (hAccelSrc, lpAccelDst, cAccelEntries); | |
1848 else | |
1849 return CopyAcceleratorTableA (hAccelSrc, lpAccelDst, cAccelEntries); | |
1850 } | |
1851 | |
1852 int | |
1853 qxeTranslateAccelerator (HWND hWnd, HACCEL hAccTable, LPMSG lpMsg) | |
1854 { | |
1855 if (XEUNICODE_P) | |
1856 return TranslateAcceleratorW (hWnd, hAccTable, lpMsg); | |
1857 else | |
1858 return TranslateAcceleratorA (hWnd, hAccTable, lpMsg); | |
1859 } | |
1860 | |
1861 HMENU | |
1862 qxeLoadMenu (HINSTANCE hInstance, const Extbyte * lpMenuName) | |
1863 { | |
1864 if (XEUNICODE_P) | |
1865 return LoadMenuW (hInstance, (LPCWSTR) lpMenuName); | |
1866 else | |
1867 return LoadMenuA (hInstance, (LPCSTR) lpMenuName); | |
1868 } | |
1869 | |
1870 HMENU | |
1871 qxeLoadMenuIndirect (CONST MENUTEMPLATEW * lpMenuTemplate) | |
1872 { | |
1873 if (XEUNICODE_P) | |
1874 return LoadMenuIndirectW (lpMenuTemplate); | |
1875 else | |
1876 return LoadMenuIndirectA ((CONST MENUTEMPLATEA *) lpMenuTemplate); | |
1877 } | |
1878 | |
1879 BOOL | |
1880 qxeChangeMenu (HMENU hMenu, UINT cmd, const Extbyte * lpszNewItem, UINT cmdInsert, UINT flags) | |
1881 { | |
1882 if (XEUNICODE_P) | |
1883 return ChangeMenuW (hMenu, cmd, (LPCWSTR) lpszNewItem, cmdInsert, flags); | |
1884 else | |
1885 return ChangeMenuA (hMenu, cmd, (LPCSTR) lpszNewItem, cmdInsert, flags); | |
1886 } | |
1887 | |
1888 int | |
1889 qxeGetMenuString (HMENU hMenu, UINT uIDItem, Extbyte * lpString, int nMaxCount, UINT uFlag) | |
1890 { | |
1891 if (XEUNICODE_P) | |
1892 return GetMenuStringW (hMenu, uIDItem, (LPWSTR) lpString, nMaxCount, uFlag); | |
1893 else | |
1894 return GetMenuStringA (hMenu, uIDItem, (LPSTR) lpString, nMaxCount, uFlag); | |
1895 } | |
1896 | |
1897 BOOL | |
1898 qxeInsertMenu (HMENU hMenu, UINT uPosition, UINT uFlags, UINT uIDNewItem, const Extbyte * lpNewItem) | |
1899 { | |
1900 if (XEUNICODE_P) | |
1901 return InsertMenuW (hMenu, uPosition, uFlags, uIDNewItem, (LPCWSTR) lpNewItem); | |
1902 else | |
1903 return InsertMenuA (hMenu, uPosition, uFlags, uIDNewItem, (LPCSTR) lpNewItem); | |
1904 } | |
1905 | |
1906 BOOL | |
1907 qxeAppendMenu (HMENU hMenu, UINT uFlags, UINT uIDNewItem, const Extbyte * lpNewItem) | |
1908 { | |
1909 if (XEUNICODE_P) | |
1910 return AppendMenuW (hMenu, uFlags, uIDNewItem, (LPCWSTR) lpNewItem); | |
1911 else | |
1912 return AppendMenuA (hMenu, uFlags, uIDNewItem, (LPCSTR) lpNewItem); | |
1913 } | |
1914 | |
1915 BOOL | |
1916 qxeModifyMenu (HMENU hMnu, UINT uPosition, UINT uFlags, UINT uIDNewItem, const Extbyte * lpNewItem) | |
1917 { | |
1918 if (XEUNICODE_P) | |
1919 return ModifyMenuW (hMnu, uPosition, uFlags, uIDNewItem, (LPCWSTR) lpNewItem); | |
1920 else | |
1921 return ModifyMenuA (hMnu, uPosition, uFlags, uIDNewItem, (LPCSTR) lpNewItem); | |
1922 } | |
1923 | |
1924 /* NOTE: NT 4.0+ only */ | |
1925 BOOL | |
1926 qxeInsertMenuItem (HMENU arg1, UINT arg2, BOOL arg3, LPCMENUITEMINFOW arg4) | |
1927 { | |
1928 if (XEUNICODE_P) | |
1929 return InsertMenuItemW (arg1, arg2, arg3, arg4); | |
1930 else | |
1931 return InsertMenuItemA (arg1, arg2, arg3, (LPCMENUITEMINFOA) arg4); | |
1932 } | |
1933 | |
1934 /* NOTE: NT 4.0+ only */ | |
1935 BOOL | |
1936 qxeGetMenuItemInfo (HMENU arg1, UINT arg2, BOOL arg3, LPMENUITEMINFOW arg4) | |
1937 { | |
1938 if (XEUNICODE_P) | |
1939 return GetMenuItemInfoW (arg1, arg2, arg3, arg4); | |
1940 else | |
1941 return GetMenuItemInfoA (arg1, arg2, arg3, (LPMENUITEMINFOA) arg4); | |
1942 } | |
1943 | |
1944 /* NOTE: NT 4.0+ only */ | |
1945 BOOL | |
1946 qxeSetMenuItemInfo (HMENU arg1, UINT arg2, BOOL arg3, LPCMENUITEMINFOW arg4) | |
1947 { | |
1948 if (XEUNICODE_P) | |
1949 return SetMenuItemInfoW (arg1, arg2, arg3, arg4); | |
1950 else | |
1951 return SetMenuItemInfoA (arg1, arg2, arg3, (LPCMENUITEMINFOA) arg4); | |
1952 } | |
1953 | |
1954 int | |
1955 qxeDrawText (HDC hDC, const Extbyte * lpString, int nCount, LPRECT lpRect, UINT uFormat) | |
1956 { | |
1957 if (XEUNICODE_P) | |
1958 return DrawTextW (hDC, (LPCWSTR) lpString, nCount, lpRect, uFormat); | |
1959 else | |
1960 return DrawTextA (hDC, (LPCSTR) lpString, nCount, lpRect, uFormat); | |
1961 } | |
1962 | |
1963 /* NOTE: NT 4.0+ only */ | |
1964 int | |
1965 qxeDrawTextEx (HDC arg1, Extbyte * arg2, int arg3, LPRECT arg4, UINT arg5, LPDRAWTEXTPARAMS arg6) | |
1966 { | |
1967 if (XEUNICODE_P) | |
1968 return DrawTextExW (arg1, (LPWSTR) arg2, arg3, arg4, arg5, arg6); | |
1969 else | |
1970 return DrawTextExA (arg1, (LPSTR) arg2, arg3, arg4, arg5, arg6); | |
1971 } | |
1972 | |
1973 BOOL | |
1974 qxeGrayString (HDC hDC, HBRUSH hBrush, GRAYSTRINGPROC lpOutputFunc, LPARAM lpData, int nCount, int X, int Y, int nWidth, int nHeight) | |
1975 { | |
1976 if (XEUNICODE_P) | |
1977 return GrayStringW (hDC, hBrush, lpOutputFunc, lpData, nCount, X, Y, nWidth, nHeight); | |
1978 else | |
1979 return GrayStringA (hDC, hBrush, lpOutputFunc, lpData, nCount, X, Y, nWidth, nHeight); | |
1980 } | |
1981 | |
1982 /* NOTE: NT 4.0+ only */ | |
1983 BOOL | |
1984 qxeDrawState (HDC arg1, HBRUSH arg2, DRAWSTATEPROC arg3, LPARAM arg4, WPARAM arg5, int arg6, int arg7, int arg8, int arg9, UINT arg10) | |
1985 { | |
1986 if (XEUNICODE_P) | |
1987 return DrawStateW (arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10); | |
1988 else | |
1989 return DrawStateA (arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10); | |
1990 } | |
1991 | |
1992 LONG | |
1993 qxeTabbedTextOut (HDC hDC, int X, int Y, const Extbyte * lpString, int nCount, int nTabPositions, LPINT lpnTabStopPositions, int nTabOrigin) | |
1994 { | |
1995 if (XEUNICODE_P) | |
1996 return TabbedTextOutW (hDC, X, Y, (LPCWSTR) lpString, nCount, nTabPositions, lpnTabStopPositions, nTabOrigin); | |
1997 else | |
1998 return TabbedTextOutA (hDC, X, Y, (LPCSTR) lpString, nCount, nTabPositions, lpnTabStopPositions, nTabOrigin); | |
1999 } | |
2000 | |
2001 DWORD | |
2002 qxeGetTabbedTextExtent (HDC hDC, const Extbyte * lpString, int nCount, int nTabPositions, LPINT lpnTabStopPositions) | |
2003 { | |
2004 if (XEUNICODE_P) | |
2005 return GetTabbedTextExtentW (hDC, (LPCWSTR) lpString, nCount, nTabPositions, lpnTabStopPositions); | |
2006 else | |
2007 return GetTabbedTextExtentA (hDC, (LPCSTR) lpString, nCount, nTabPositions, lpnTabStopPositions); | |
2008 } | |
2009 | |
2010 BOOL | |
2011 qxeSetProp (HWND hWnd, const Extbyte * lpString, HANDLE hData) | |
2012 { | |
2013 if (XEUNICODE_P) | |
2014 return SetPropW (hWnd, (LPCWSTR) lpString, hData); | |
2015 else | |
2016 return SetPropA (hWnd, (LPCSTR) lpString, hData); | |
2017 } | |
2018 | |
2019 HANDLE | |
2020 qxeGetProp (HWND hWnd, const Extbyte * lpString) | |
2021 { | |
2022 if (XEUNICODE_P) | |
2023 return GetPropW (hWnd, (LPCWSTR) lpString); | |
2024 else | |
2025 return GetPropA (hWnd, (LPCSTR) lpString); | |
2026 } | |
2027 | |
2028 HANDLE | |
2029 qxeRemoveProp (HWND hWnd, const Extbyte * lpString) | |
2030 { | |
2031 if (XEUNICODE_P) | |
2032 return RemovePropW (hWnd, (LPCWSTR) lpString); | |
2033 else | |
2034 return RemovePropA (hWnd, (LPCSTR) lpString); | |
2035 } | |
2036 | |
2037 /* NOTE: // callback fun differs only in string pointer type */ | |
2038 int | |
2039 qxeEnumPropsEx (HWND hWnd, PROPENUMPROCEXW lpEnumFunc, LPARAM lParam) | |
2040 { | |
2041 if (XEUNICODE_P) | |
2042 return EnumPropsExW (hWnd, lpEnumFunc, lParam); | |
2043 else | |
2044 return EnumPropsExA (hWnd, (PROPENUMPROCEXA) lpEnumFunc, lParam); | |
2045 } | |
2046 | |
2047 /* NOTE: // callback fun differs only in string pointer type */ | |
2048 int | |
2049 qxeEnumProps (HWND hWnd, PROPENUMPROCW lpEnumFunc) | |
2050 { | |
2051 if (XEUNICODE_P) | |
2052 return EnumPropsW (hWnd, lpEnumFunc); | |
2053 else | |
2054 return EnumPropsA (hWnd, (PROPENUMPROCA) lpEnumFunc); | |
2055 } | |
2056 | |
2057 BOOL | |
2058 qxeSetWindowText (HWND hWnd, const Extbyte * lpString) | |
2059 { | |
2060 if (XEUNICODE_P) | |
2061 return SetWindowTextW (hWnd, (LPCWSTR) lpString); | |
2062 else | |
2063 return SetWindowTextA (hWnd, (LPCSTR) lpString); | |
2064 } | |
2065 | |
2066 int | |
2067 qxeGetWindowText (HWND hWnd, Extbyte * lpString, int nMaxCount) | |
2068 { | |
2069 if (XEUNICODE_P) | |
2070 return GetWindowTextW (hWnd, (LPWSTR) lpString, nMaxCount); | |
2071 else | |
2072 return GetWindowTextA (hWnd, (LPSTR) lpString, nMaxCount); | |
2073 } | |
2074 | |
2075 int | |
2076 qxeGetWindowTextLength (HWND hWnd) | |
2077 { | |
2078 if (XEUNICODE_P) | |
2079 return GetWindowTextLengthW (hWnd); | |
2080 else | |
2081 return GetWindowTextLengthA (hWnd); | |
2082 } | |
2083 | |
2084 int | |
2085 qxeMessageBox (HWND hWnd, const Extbyte * lpText, const Extbyte * lpCaption, UINT uType) | |
2086 { | |
2087 if (XEUNICODE_P) | |
2088 return MessageBoxW (hWnd, (LPCWSTR) lpText, (LPCWSTR) lpCaption, uType); | |
2089 else | |
2090 return MessageBoxA (hWnd, (LPCSTR) lpText, (LPCSTR) lpCaption, uType); | |
2091 } | |
2092 | |
2093 int | |
2094 qxeMessageBoxEx (HWND hWnd, const Extbyte * lpText, const Extbyte * lpCaption, UINT uType, WORD wLanguageId) | |
2095 { | |
2096 if (XEUNICODE_P) | |
2097 return MessageBoxExW (hWnd, (LPCWSTR) lpText, (LPCWSTR) lpCaption, uType, wLanguageId); | |
2098 else | |
2099 return MessageBoxExA (hWnd, (LPCSTR) lpText, (LPCSTR) lpCaption, uType, wLanguageId); | |
2100 } | |
2101 | |
2102 /* NOTE: NT 4.0+ only */ | |
2103 int | |
2104 qxeMessageBoxIndirect (LPMSGBOXPARAMSW arg1) | |
2105 { | |
2106 if (XEUNICODE_P) | |
2107 return MessageBoxIndirectW (arg1); | |
2108 else | |
2109 return MessageBoxIndirectA ((LPMSGBOXPARAMSA) arg1); | |
2110 } | |
2111 | |
2112 LONG | |
2113 qxeGetWindowLong (HWND hWnd, int nIndex) | |
2114 { | |
2115 if (XEUNICODE_P) | |
2116 return GetWindowLongW (hWnd, nIndex); | |
2117 else | |
2118 return GetWindowLongA (hWnd, nIndex); | |
2119 } | |
2120 | |
2121 LONG | |
2122 qxeSetWindowLong (HWND hWnd, int nIndex, LONG dwNewLong) | |
2123 { | |
2124 if (XEUNICODE_P) | |
2125 return SetWindowLongW (hWnd, nIndex, dwNewLong); | |
2126 else | |
2127 return SetWindowLongA (hWnd, nIndex, dwNewLong); | |
2128 } | |
2129 | |
2130 DWORD | |
2131 qxeGetClassLong (HWND hWnd, int nIndex) | |
2132 { | |
2133 if (XEUNICODE_P) | |
2134 return GetClassLongW (hWnd, nIndex); | |
2135 else | |
2136 return GetClassLongA (hWnd, nIndex); | |
2137 } | |
2138 | |
2139 DWORD | |
2140 qxeSetClassLong (HWND hWnd, int nIndex, LONG dwNewLong) | |
2141 { | |
2142 if (XEUNICODE_P) | |
2143 return SetClassLongW (hWnd, nIndex, dwNewLong); | |
2144 else | |
2145 return SetClassLongA (hWnd, nIndex, dwNewLong); | |
2146 } | |
2147 | |
2148 HWND | |
2149 qxeFindWindow (const Extbyte * lpClassName, const Extbyte * lpWindowName) | |
2150 { | |
2151 if (XEUNICODE_P) | |
2152 return FindWindowW ((LPCWSTR) lpClassName, (LPCWSTR) lpWindowName); | |
2153 else | |
2154 return FindWindowA ((LPCSTR) lpClassName, (LPCSTR) lpWindowName); | |
2155 } | |
2156 | |
2157 /* NOTE: NT 4.0+ only */ | |
2158 HWND | |
2159 qxeFindWindowEx (HWND arg1, HWND arg2, const Extbyte * arg3, const Extbyte * arg4) | |
2160 { | |
2161 if (XEUNICODE_P) | |
2162 return FindWindowExW (arg1, arg2, (LPCWSTR) arg3, (LPCWSTR) arg4); | |
2163 else | |
2164 return FindWindowExA (arg1, arg2, (LPCSTR) arg3, (LPCSTR) arg4); | |
2165 } | |
2166 | |
2167 int | |
2168 qxeGetClassName (HWND hWnd, Extbyte * lpClassName, int nMaxCount) | |
2169 { | |
2170 if (XEUNICODE_P) | |
2171 return GetClassNameW (hWnd, (LPWSTR) lpClassName, nMaxCount); | |
2172 else | |
2173 return GetClassNameA (hWnd, (LPSTR) lpClassName, nMaxCount); | |
2174 } | |
2175 | |
2176 /* Error if SetWindowsHook used: obsolete; two versions, STRICT and non-STRICT */ | |
2177 | |
2178 /* Error if SetWindowsHook used: obsolete; two versions, STRICT and non-STRICT */ | |
2179 | |
2180 HHOOK | |
2181 qxeSetWindowsHookEx (int idHook, HOOKPROC lpfn, HINSTANCE hmod, DWORD dwThreadId) | |
2182 { | |
2183 if (XEUNICODE_P) | |
2184 return SetWindowsHookExW (idHook, lpfn, hmod, dwThreadId); | |
2185 else | |
2186 return SetWindowsHookExA (idHook, lpfn, hmod, dwThreadId); | |
2187 } | |
2188 | |
2189 HBITMAP | |
2190 qxeLoadBitmap (HINSTANCE hInstance, const Extbyte * lpBitmapName) | |
2191 { | |
2192 if (XEUNICODE_P) | |
2193 return LoadBitmapW (hInstance, (LPCWSTR) lpBitmapName); | |
2194 else | |
2195 return LoadBitmapA (hInstance, (LPCSTR) lpBitmapName); | |
2196 } | |
2197 | |
2198 HCURSOR | |
2199 qxeLoadCursor (HINSTANCE hInstance, const Extbyte * lpCursorName) | |
2200 { | |
2201 if (XEUNICODE_P) | |
2202 return LoadCursorW (hInstance, (LPCWSTR) lpCursorName); | |
2203 else | |
2204 return LoadCursorA (hInstance, (LPCSTR) lpCursorName); | |
2205 } | |
2206 | |
2207 HCURSOR | |
2208 qxeLoadCursorFromFile (const Extbyte * lpFileName) | |
2209 { | |
2210 if (XEUNICODE_P) | |
2211 return LoadCursorFromFileW ((LPCWSTR) lpFileName); | |
2212 else | |
2213 return LoadCursorFromFileA ((LPCSTR) lpFileName); | |
2214 } | |
2215 | |
2216 HICON | |
2217 qxeLoadIcon (HINSTANCE hInstance, const Extbyte * lpIconName) | |
2218 { | |
2219 if (XEUNICODE_P) | |
2220 return LoadIconW (hInstance, (LPCWSTR) lpIconName); | |
2221 else | |
2222 return LoadIconA (hInstance, (LPCSTR) lpIconName); | |
2223 } | |
2224 | |
2225 /* NOTE: NT 4.0+ only */ | |
2226 HANDLE | |
2227 qxeLoadImage (HINSTANCE arg1, const Extbyte * arg2, UINT arg3, int arg4, int arg5, UINT arg6) | |
2228 { | |
2229 if (XEUNICODE_P) | |
2230 return LoadImageW (arg1, (LPCWSTR) arg2, arg3, arg4, arg5, arg6); | |
2231 else | |
2232 return LoadImageA (arg1, (LPCSTR) arg2, arg3, arg4, arg5, arg6); | |
2233 } | |
2234 | |
2235 int | |
2236 qxeLoadString (HINSTANCE hInstance, UINT uID, Extbyte * lpBuffer, int nBufferMax) | |
2237 { | |
2238 if (XEUNICODE_P) | |
2239 return LoadStringW (hInstance, uID, (LPWSTR) lpBuffer, nBufferMax); | |
2240 else | |
2241 return LoadStringA (hInstance, uID, (LPSTR) lpBuffer, nBufferMax); | |
2242 } | |
2243 | |
2244 BOOL | |
2245 qxeIsDialogMessage (HWND hDlg, LPMSG lpMsg) | |
2246 { | |
2247 if (XEUNICODE_P) | |
2248 return IsDialogMessageW (hDlg, lpMsg); | |
2249 else | |
2250 return IsDialogMessageA (hDlg, lpMsg); | |
2251 } | |
2252 | |
2253 int | |
2254 qxeDlgDirList (HWND hDlg, Extbyte * lpPathSpec, int nIDListBox, int nIDStaticPath, UINT uFileType) | |
2255 { | |
2256 if (XEUNICODE_P) | |
2257 return DlgDirListW (hDlg, (LPWSTR) lpPathSpec, nIDListBox, nIDStaticPath, uFileType); | |
2258 else | |
2259 return DlgDirListA (hDlg, (LPSTR) lpPathSpec, nIDListBox, nIDStaticPath, uFileType); | |
2260 } | |
2261 | |
2262 BOOL | |
2263 qxeDlgDirSelectEx (HWND hDlg, Extbyte * lpString, int nCount, int nIDListBox) | |
2264 { | |
2265 if (XEUNICODE_P) | |
2266 return DlgDirSelectExW (hDlg, (LPWSTR) lpString, nCount, nIDListBox); | |
2267 else | |
2268 return DlgDirSelectExA (hDlg, (LPSTR) lpString, nCount, nIDListBox); | |
2269 } | |
2270 | |
2271 int | |
2272 qxeDlgDirListComboBox (HWND hDlg, Extbyte * lpPathSpec, int nIDComboBox, int nIDStaticPath, UINT uFiletype) | |
2273 { | |
2274 if (XEUNICODE_P) | |
2275 return DlgDirListComboBoxW (hDlg, (LPWSTR) lpPathSpec, nIDComboBox, nIDStaticPath, uFiletype); | |
2276 else | |
2277 return DlgDirListComboBoxA (hDlg, (LPSTR) lpPathSpec, nIDComboBox, nIDStaticPath, uFiletype); | |
2278 } | |
2279 | |
2280 BOOL | |
2281 qxeDlgDirSelectComboBoxEx (HWND hDlg, Extbyte * lpString, int nCount, int nIDComboBox) | |
2282 { | |
2283 if (XEUNICODE_P) | |
2284 return DlgDirSelectComboBoxExW (hDlg, (LPWSTR) lpString, nCount, nIDComboBox); | |
2285 else | |
2286 return DlgDirSelectComboBoxExA (hDlg, (LPSTR) lpString, nCount, nIDComboBox); | |
2287 } | |
2288 | |
2289 LRESULT | |
2290 qxeDefFrameProc (HWND hWnd, HWND hWndMDIClient, UINT uMsg, WPARAM wParam, LPARAM lParam) | |
2291 { | |
2292 if (XEUNICODE_P) | |
2293 return DefFrameProcW (hWnd, hWndMDIClient, uMsg, wParam, lParam); | |
2294 else | |
2295 return DefFrameProcA (hWnd, hWndMDIClient, uMsg, wParam, lParam); | |
2296 } | |
2297 | |
2298 /* Error if DefMDIChildProc used: return value is conditionalized on _MAC, messes up parser */ | |
2299 | |
2300 HWND | |
2301 qxeCreateMDIWindow (Extbyte * lpClassName, Extbyte * lpWindowName, DWORD dwStyle, int X, int Y, int nWidth, int nHeight, HWND hWndParent, HINSTANCE hInstance, LPARAM lParam) | |
2302 { | |
2303 if (XEUNICODE_P) | |
2304 return CreateMDIWindowW ((LPWSTR) lpClassName, (LPWSTR) lpWindowName, dwStyle, X, Y, nWidth, nHeight, hWndParent, hInstance, lParam); | |
2305 else | |
2306 return CreateMDIWindowA ((LPSTR) lpClassName, (LPSTR) lpWindowName, dwStyle, X, Y, nWidth, nHeight, hWndParent, hInstance, lParam); | |
2307 } | |
2308 | |
2309 BOOL | |
2310 qxeWinHelp (HWND hWndMain, const Extbyte * lpszHelp, UINT uCommand, DWORD dwData) | |
2311 { | |
2312 if (XEUNICODE_P) | |
2313 return WinHelpW (hWndMain, (LPCWSTR) lpszHelp, uCommand, dwData); | |
2314 else | |
2315 return WinHelpA (hWndMain, (LPCSTR) lpszHelp, uCommand, dwData); | |
2316 } | |
2317 | |
2318 /* Error if ChangeDisplaySettings used: split-sized LPDEVMODE */ | |
2319 | |
2320 /* Error if ChangeDisplaySettingsEx used: split-sized LPDEVMODE; NT 5.0/Win98+ only */ | |
2321 | |
2322 /* Error if EnumDisplaySettings used: split-sized LPDEVMODE */ | |
2323 | |
2324 /* Error if EnumDisplayDevices used: split-sized PDISPLAY_DEVICE; NT 5.0+ only, no Win98 */ | |
2325 | |
2326 /* NOTE: probs w/ICONMETRICS, NONCLIENTMETRICS */ | |
2327 BOOL | |
2328 qxeSystemParametersInfo (UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni) | |
2329 { | |
2330 if (XEUNICODE_P) | |
2331 return SystemParametersInfoW (uiAction, uiParam, pvParam, fWinIni); | |
2332 else | |
2333 return SystemParametersInfoA (uiAction, uiParam, pvParam, fWinIni); | |
2334 } | |
2335 | |
2336 /* Error if GetMonitorInfo used: NT 5.0/Win98+ only */ | |
2337 | |
2338 /* Error if GetWindowModuleFileName used: NT 5.0+ only */ | |
2339 | |
2340 /* Error if RealGetWindowClass used: NT 5.0+ only */ | |
2341 | |
2342 /* Error if GetAltTabInfo used: NT 5.0+ only */ | |
2343 | |
2344 | |
2345 /*----------------------------------------------------------------------*/ | |
2346 /* Processing file MMSYSTEM.H */ | |
2347 /*----------------------------------------------------------------------*/ | |
2348 | |
2349 BOOL | |
2350 qxesndPlaySound (const Extbyte * pszSound, UINT fuSound) | |
2351 { | |
2352 if (XEUNICODE_P) | |
2353 return sndPlaySoundW ((LPCWSTR) pszSound, fuSound); | |
2354 else | |
2355 return sndPlaySoundA ((LPCSTR) pszSound, fuSound); | |
2356 } | |
2357 | |
2358 BOOL | |
2359 qxePlaySound (const Extbyte * pszSound, HMODULE hmod, DWORD fdwSound) | |
2360 { | |
2361 if (XEUNICODE_P) | |
2362 return PlaySoundW ((LPCWSTR) pszSound, hmod, fdwSound); | |
2363 else | |
2364 return PlaySoundA ((LPCSTR) pszSound, hmod, fdwSound); | |
2365 } | |
2366 | |
2367 /* Error if waveOutGetDevCaps used: split-sized LPWAVEOUTCAPS */ | |
2368 | |
2369 MMRESULT | |
2370 qxewaveOutGetErrorText (MMRESULT mmrError, Extbyte * pszText, UINT cchText) | |
2371 { | |
2372 if (XEUNICODE_P) | |
2373 return waveOutGetErrorTextW (mmrError, (LPWSTR) pszText, cchText); | |
2374 else | |
2375 return waveOutGetErrorTextA (mmrError, (LPSTR) pszText, cchText); | |
2376 } | |
2377 | |
2378 /* Error if waveInGetDevCaps used: split-sized LPWAVEINCAPS */ | |
2379 | |
2380 MMRESULT | |
2381 qxewaveInGetErrorText (MMRESULT mmrError, Extbyte * pszText, UINT cchText) | |
2382 { | |
2383 if (XEUNICODE_P) | |
2384 return waveInGetErrorTextW (mmrError, (LPWSTR) pszText, cchText); | |
2385 else | |
2386 return waveInGetErrorTextA (mmrError, (LPSTR) pszText, cchText); | |
2387 } | |
2388 | |
2389 /* Error if midiOutGetDevCaps used: split-sized LPMIDIOUTCAPS */ | |
2390 | |
2391 MMRESULT | |
2392 qxemidiOutGetErrorText (MMRESULT mmrError, Extbyte * pszText, UINT cchText) | |
2393 { | |
2394 if (XEUNICODE_P) | |
2395 return midiOutGetErrorTextW (mmrError, (LPWSTR) pszText, cchText); | |
2396 else | |
2397 return midiOutGetErrorTextA (mmrError, (LPSTR) pszText, cchText); | |
2398 } | |
2399 | |
2400 /* Error if midiInGetDevCaps used: split-sized LPMIDIOUTCAPS */ | |
2401 | |
2402 MMRESULT | |
2403 qxemidiInGetErrorText (MMRESULT mmrError, Extbyte * pszText, UINT cchText) | |
2404 { | |
2405 if (XEUNICODE_P) | |
2406 return midiInGetErrorTextW (mmrError, (LPWSTR) pszText, cchText); | |
2407 else | |
2408 return midiInGetErrorTextA (mmrError, (LPSTR) pszText, cchText); | |
2409 } | |
2410 | |
2411 /* Error if auxGetDevCaps used: split-sized LPAUXCAPS */ | |
2412 | |
2413 /* Error if mixerGetDevCaps used: split-sized LPMIXERCAPS */ | |
2414 | |
2415 /* Error if mixerGetLineInfo used: split-sized LPMIXERLINE */ | |
2416 | |
2417 /* Error if mixerGetLineControls used: split-sized LPMIXERCONTROL */ | |
2418 | |
2419 /* Error if mixerGetControlDetails used: split-sized LPMIXERCONTROL in LPMIXERLINECONTROLS in LPMIXERCONTROLDETAILS */ | |
2420 | |
2421 /* Error if joyGetDevCaps used: split-sized LPJOYCAPS */ | |
2422 | |
2423 FOURCC | |
2424 qxemmioStringToFOURCC (const Extbyte * sz, UINT uFlags) | |
2425 { | |
2426 if (XEUNICODE_P) | |
2427 return mmioStringToFOURCCW ((LPCWSTR) sz, uFlags); | |
2428 else | |
2429 return mmioStringToFOURCCA ((LPCSTR) sz, uFlags); | |
2430 } | |
2431 | |
2432 LPMMIOPROC | |
2433 qxemmioInstallIOProc (FOURCC fccIOProc, LPMMIOPROC pIOProc, DWORD dwFlags) | |
2434 { | |
2435 if (XEUNICODE_P) | |
2436 return mmioInstallIOProcW (fccIOProc, pIOProc, dwFlags); | |
2437 else | |
2438 return mmioInstallIOProcA (fccIOProc, pIOProc, dwFlags); | |
2439 } | |
2440 | |
2441 HMMIO | |
2442 qxemmioOpen (Extbyte * pszFileName, LPMMIOINFO pmmioinfo, DWORD fdwOpen) | |
2443 { | |
2444 if (XEUNICODE_P) | |
2445 return mmioOpenW ((LPWSTR) pszFileName, pmmioinfo, fdwOpen); | |
2446 else | |
2447 return mmioOpenA ((LPSTR) pszFileName, pmmioinfo, fdwOpen); | |
2448 } | |
2449 | |
2450 MMRESULT | |
2451 qxemmioRename (const Extbyte * pszFileName, const Extbyte * pszNewFileName, LPCMMIOINFO pmmioinfo, DWORD fdwRename) | |
2452 { | |
2453 if (XEUNICODE_P) | |
2454 return mmioRenameW ((LPCWSTR) pszFileName, (LPCWSTR) pszNewFileName, pmmioinfo, fdwRename); | |
2455 else | |
2456 return mmioRenameA ((LPCSTR) pszFileName, (LPCSTR) pszNewFileName, pmmioinfo, fdwRename); | |
2457 } | |
2458 | |
2459 MCIERROR | |
2460 qxemciSendCommand (MCIDEVICEID mciId, UINT uMsg, DWORD dwParam1, DWORD dwParam2) | |
2461 { | |
2462 if (XEUNICODE_P) | |
2463 return mciSendCommandW (mciId, uMsg, dwParam1, dwParam2); | |
2464 else | |
2465 return mciSendCommandA (mciId, uMsg, dwParam1, dwParam2); | |
2466 } | |
2467 | |
2468 MCIERROR | |
2469 qxemciSendString (const Extbyte * lpstrCommand, Extbyte * lpstrReturnString, UINT uReturnLength, HWND hwndCallback) | |
2470 { | |
2471 if (XEUNICODE_P) | |
2472 return mciSendStringW ((LPCWSTR) lpstrCommand, (LPWSTR) lpstrReturnString, uReturnLength, hwndCallback); | |
2473 else | |
2474 return mciSendStringA ((LPCSTR) lpstrCommand, (LPSTR) lpstrReturnString, uReturnLength, hwndCallback); | |
2475 } | |
2476 | |
2477 MCIDEVICEID | |
2478 qxemciGetDeviceID (const Extbyte * pszDevice) | |
2479 { | |
2480 if (XEUNICODE_P) | |
2481 return mciGetDeviceIDW ((LPCWSTR) pszDevice); | |
2482 else | |
2483 return mciGetDeviceIDA ((LPCSTR) pszDevice); | |
2484 } | |
2485 | |
2486 #if !defined (MINGW) | |
2487 | |
2488 MCIDEVICEID | |
2489 qxemciGetDeviceIDFromElementID (DWORD dwElementID, const Extbyte * lpstrType) | |
2490 { | |
2491 if (XEUNICODE_P) | |
2492 return mciGetDeviceIDFromElementIDW (dwElementID, (LPCWSTR) lpstrType); | |
2493 else | |
2494 return mciGetDeviceIDFromElementIDA (dwElementID, (LPCSTR) lpstrType); | |
2495 } | |
2496 | |
2497 #endif /* !defined (MINGW) */ | |
2498 | |
2499 BOOL | |
2500 qxemciGetErrorString (MCIERROR mcierr, Extbyte * pszText, UINT cchText) | |
2501 { | |
2502 if (XEUNICODE_P) | |
2503 return mciGetErrorStringW (mcierr, (LPWSTR) pszText, cchText); | |
2504 else | |
2505 return mciGetErrorStringA (mcierr, (LPSTR) pszText, cchText); | |
2506 } | |
2507 | |
2508 | |
2509 /*----------------------------------------------------------------------*/ | |
2510 /* Processing file WINBASE.H */ | |
2511 /*----------------------------------------------------------------------*/ | |
2512 | |
2513 BOOL | |
2514 qxeGetBinaryType (const Extbyte * lpApplicationName, LPDWORD lpBinaryType) | |
2515 { | |
2516 if (XEUNICODE_P) | |
2517 return GetBinaryTypeW ((LPCWSTR) lpApplicationName, lpBinaryType); | |
2518 else | |
2519 return GetBinaryTypeA ((LPCSTR) lpApplicationName, lpBinaryType); | |
2520 } | |
2521 | |
2522 DWORD | |
2523 qxeGetShortPathName (const Extbyte * lpszLongPath, Extbyte * lpszShortPath, DWORD cchBuffer) | |
2524 { | |
2525 if (XEUNICODE_P) | |
2526 return GetShortPathNameW ((LPCWSTR) lpszLongPath, (LPWSTR) lpszShortPath, cchBuffer); | |
2527 else | |
2528 return GetShortPathNameA ((LPCSTR) lpszLongPath, (LPSTR) lpszShortPath, cchBuffer); | |
2529 } | |
2530 | |
2531 DWORD | |
2532 qxeGetLongPathName (const Extbyte * lpszShortPath, Extbyte * lpszLongPath, DWORD cchBuffer) | |
2533 { | |
2534 if (XEUNICODE_P) | |
2535 return GetLongPathNameW ((LPCWSTR) lpszShortPath, (LPWSTR) lpszLongPath, cchBuffer); | |
2536 else | |
2537 return GetLongPathNameA ((LPCSTR) lpszShortPath, (LPSTR) lpszLongPath, cchBuffer); | |
2538 } | |
2539 | |
2540 Extbyte * | |
2541 qxeGetEnvironmentStrings (void) | |
2542 { | |
2543 if (XEUNICODE_P) | |
2544 return (Extbyte *) GetEnvironmentStringsW (); | |
2545 else | |
2546 return (Extbyte *) GetEnvironmentStringsA (); | |
2547 } | |
2548 | |
2549 BOOL | |
2550 qxeFreeEnvironmentStrings (Extbyte * arg1) | |
2551 { | |
2552 if (XEUNICODE_P) | |
2553 return FreeEnvironmentStringsW ((LPWSTR) arg1); | |
2554 else | |
2555 return FreeEnvironmentStringsA ((LPSTR) arg1); | |
2556 } | |
2557 | |
2558 DWORD | |
2559 qxeFormatMessage (DWORD dwFlags, LPCVOID lpSource, DWORD dwMessageId, DWORD dwLanguageId, Extbyte * lpBuffer, DWORD nSize, va_list * Arguments) | |
2560 { | |
2561 if (XEUNICODE_P) | |
2562 return FormatMessageW (dwFlags, lpSource, dwMessageId, dwLanguageId, (LPWSTR) lpBuffer, nSize, Arguments); | |
2563 else | |
2564 return FormatMessageA (dwFlags, lpSource, dwMessageId, dwLanguageId, (LPSTR) lpBuffer, nSize, Arguments); | |
2565 } | |
2566 | |
2567 HANDLE | |
2568 qxeCreateMailslot (const Extbyte * lpName, DWORD nMaxMessageSize, DWORD lReadTimeout, LPSECURITY_ATTRIBUTES lpSecurityAttributes) | |
2569 { | |
2570 if (XEUNICODE_P) | |
2571 return CreateMailslotW ((LPCWSTR) lpName, nMaxMessageSize, lReadTimeout, lpSecurityAttributes); | |
2572 else | |
2573 return CreateMailslotA ((LPCSTR) lpName, nMaxMessageSize, lReadTimeout, lpSecurityAttributes); | |
2574 } | |
2575 | |
2576 #if !defined (CYGWIN_HEADERS) | |
2577 | |
2578 BOOL | |
2579 qxeEncryptFile (const Extbyte * lpFileName) | |
2580 { | |
2581 if (XEUNICODE_P) | |
2582 return EncryptFileW ((LPCWSTR) lpFileName); | |
2583 else | |
2584 return EncryptFileA ((LPCSTR) lpFileName); | |
2585 } | |
2586 | |
2587 #endif /* !defined (CYGWIN_HEADERS) */ | |
2588 | |
2589 #if !defined (CYGWIN_HEADERS) | |
2590 | |
2591 BOOL | |
2592 qxeDecryptFile (const Extbyte * lpFileName, DWORD dwReserved) | |
2593 { | |
2594 if (XEUNICODE_P) | |
2595 return DecryptFileW ((LPCWSTR) lpFileName, dwReserved); | |
2596 else | |
2597 return DecryptFileA ((LPCSTR) lpFileName, dwReserved); | |
2598 } | |
2599 | |
2600 #endif /* !defined (CYGWIN_HEADERS) */ | |
2601 | |
2602 /* Error if OpenRaw used: error "The procedure entry point OpenRawW could not be located in the dynamic link library ADVAPI32.dll." */ | |
2603 | |
2604 /* Error if QueryRecoveryAgents used: split-sized LPRECOVERY_AGENT_INFORMATION */ | |
2605 | |
2606 int | |
2607 qxelstrcmp (const Extbyte * lpString1, const Extbyte * lpString2) | |
2608 { | |
2609 if (XEUNICODE_P) | |
2610 return lstrcmpW ((LPCWSTR) lpString1, (LPCWSTR) lpString2); | |
2611 else | |
2612 return lstrcmpA ((LPCSTR) lpString1, (LPCSTR) lpString2); | |
2613 } | |
2614 | |
2615 int | |
2616 qxelstrcmpi (const Extbyte * lpString1, const Extbyte * lpString2) | |
2617 { | |
2618 if (XEUNICODE_P) | |
2619 return lstrcmpiW ((LPCWSTR) lpString1, (LPCWSTR) lpString2); | |
2620 else | |
2621 return lstrcmpiA ((LPCSTR) lpString1, (LPCSTR) lpString2); | |
2622 } | |
2623 | |
2624 Extbyte * | |
2625 qxelstrcpyn (Extbyte * lpString1, const Extbyte * lpString2, int iMaxLength) | |
2626 { | |
2627 if (XEUNICODE_P) | |
2628 return (Extbyte *) lstrcpynW ((LPWSTR) lpString1, (LPCWSTR) lpString2, iMaxLength); | |
2629 else | |
2630 return (Extbyte *) lstrcpynA ((LPSTR) lpString1, (LPCSTR) lpString2, iMaxLength); | |
2631 } | |
2632 | |
2633 Extbyte * | |
2634 qxelstrcpy (Extbyte * lpString1, const Extbyte * lpString2) | |
2635 { | |
2636 if (XEUNICODE_P) | |
2637 return (Extbyte *) lstrcpyW ((LPWSTR) lpString1, (LPCWSTR) lpString2); | |
2638 else | |
2639 return (Extbyte *) lstrcpyA ((LPSTR) lpString1, (LPCSTR) lpString2); | |
2640 } | |
2641 | |
2642 Extbyte * | |
2643 qxelstrcat (Extbyte * lpString1, const Extbyte * lpString2) | |
2644 { | |
2645 if (XEUNICODE_P) | |
2646 return (Extbyte *) lstrcatW ((LPWSTR) lpString1, (LPCWSTR) lpString2); | |
2647 else | |
2648 return (Extbyte *) lstrcatA ((LPSTR) lpString1, (LPCSTR) lpString2); | |
2649 } | |
2650 | |
2651 int | |
2652 qxelstrlen (const Extbyte * lpString) | |
2653 { | |
2654 if (XEUNICODE_P) | |
2655 return lstrlenW ((LPCWSTR) lpString); | |
2656 else | |
2657 return lstrlenA ((LPCSTR) lpString); | |
2658 } | |
2659 | |
2660 HANDLE | |
2661 qxeCreateMutex (LPSECURITY_ATTRIBUTES lpMutexAttributes, BOOL bInitialOwner, const Extbyte * lpName) | |
2662 { | |
2663 if (XEUNICODE_P) | |
2664 return CreateMutexW (lpMutexAttributes, bInitialOwner, (LPCWSTR) lpName); | |
2665 else | |
2666 return CreateMutexA (lpMutexAttributes, bInitialOwner, (LPCSTR) lpName); | |
2667 } | |
2668 | |
2669 HANDLE | |
2670 qxeOpenMutex (DWORD dwDesiredAccess, BOOL bInheritHandle, const Extbyte * lpName) | |
2671 { | |
2672 if (XEUNICODE_P) | |
2673 return OpenMutexW (dwDesiredAccess, bInheritHandle, (LPCWSTR) lpName); | |
2674 else | |
2675 return OpenMutexA (dwDesiredAccess, bInheritHandle, (LPCSTR) lpName); | |
2676 } | |
2677 | |
2678 HANDLE | |
2679 qxeCreateEvent (LPSECURITY_ATTRIBUTES lpEventAttributes, BOOL bManualReset, BOOL bInitialState, const Extbyte * lpName) | |
2680 { | |
2681 if (XEUNICODE_P) | |
2682 return CreateEventW (lpEventAttributes, bManualReset, bInitialState, (LPCWSTR) lpName); | |
2683 else | |
2684 return CreateEventA (lpEventAttributes, bManualReset, bInitialState, (LPCSTR) lpName); | |
2685 } | |
2686 | |
2687 HANDLE | |
2688 qxeOpenEvent (DWORD dwDesiredAccess, BOOL bInheritHandle, const Extbyte * lpName) | |
2689 { | |
2690 if (XEUNICODE_P) | |
2691 return OpenEventW (dwDesiredAccess, bInheritHandle, (LPCWSTR) lpName); | |
2692 else | |
2693 return OpenEventA (dwDesiredAccess, bInheritHandle, (LPCSTR) lpName); | |
2694 } | |
2695 | |
2696 HANDLE | |
2697 qxeCreateSemaphore (LPSECURITY_ATTRIBUTES lpSemaphoreAttributes, LONG lInitialCount, LONG lMaximumCount, const Extbyte * lpName) | |
2698 { | |
2699 if (XEUNICODE_P) | |
2700 return CreateSemaphoreW (lpSemaphoreAttributes, lInitialCount, lMaximumCount, (LPCWSTR) lpName); | |
2701 else | |
2702 return CreateSemaphoreA (lpSemaphoreAttributes, lInitialCount, lMaximumCount, (LPCSTR) lpName); | |
2703 } | |
2704 | |
2705 HANDLE | |
2706 qxeOpenSemaphore (DWORD dwDesiredAccess, BOOL bInheritHandle, const Extbyte * lpName) | |
2707 { | |
2708 if (XEUNICODE_P) | |
2709 return OpenSemaphoreW (dwDesiredAccess, bInheritHandle, (LPCWSTR) lpName); | |
2710 else | |
2711 return OpenSemaphoreA (dwDesiredAccess, bInheritHandle, (LPCSTR) lpName); | |
2712 } | |
2713 | |
2714 HANDLE | |
2715 qxeCreateWaitableTimer (LPSECURITY_ATTRIBUTES lpTimerAttributes, BOOL bManualReset, const Extbyte * lpTimerName) | |
2716 { | |
2717 if (XEUNICODE_P) | |
2718 return CreateWaitableTimerW (lpTimerAttributes, bManualReset, (LPCWSTR) lpTimerName); | |
2719 else | |
2720 return CreateWaitableTimerA (lpTimerAttributes, bManualReset, (LPCSTR) lpTimerName); | |
2721 } | |
2722 | |
2723 HANDLE | |
2724 qxeOpenWaitableTimer (DWORD dwDesiredAccess, BOOL bInheritHandle, const Extbyte * lpTimerName) | |
2725 { | |
2726 if (XEUNICODE_P) | |
2727 return OpenWaitableTimerW (dwDesiredAccess, bInheritHandle, (LPCWSTR) lpTimerName); | |
2728 else | |
2729 return OpenWaitableTimerA (dwDesiredAccess, bInheritHandle, (LPCSTR) lpTimerName); | |
2730 } | |
2731 | |
2732 HANDLE | |
2733 qxeCreateFileMapping (HANDLE hFile, LPSECURITY_ATTRIBUTES lpFileMappingAttributes, DWORD flProtect, DWORD dwMaximumSizeHigh, DWORD dwMaximumSizeLow, const Extbyte * lpName) | |
2734 { | |
2735 if (XEUNICODE_P) | |
2736 return CreateFileMappingW (hFile, lpFileMappingAttributes, flProtect, dwMaximumSizeHigh, dwMaximumSizeLow, (LPCWSTR) lpName); | |
2737 else | |
2738 return CreateFileMappingA (hFile, lpFileMappingAttributes, flProtect, dwMaximumSizeHigh, dwMaximumSizeLow, (LPCSTR) lpName); | |
2739 } | |
2740 | |
2741 HANDLE | |
2742 qxeOpenFileMapping (DWORD dwDesiredAccess, BOOL bInheritHandle, const Extbyte * lpName) | |
2743 { | |
2744 if (XEUNICODE_P) | |
2745 return OpenFileMappingW (dwDesiredAccess, bInheritHandle, (LPCWSTR) lpName); | |
2746 else | |
2747 return OpenFileMappingA (dwDesiredAccess, bInheritHandle, (LPCSTR) lpName); | |
2748 } | |
2749 | |
2750 DWORD | |
2751 qxeGetLogicalDriveStrings (DWORD nBufferLength, Extbyte * lpBuffer) | |
2752 { | |
2753 if (XEUNICODE_P) | |
2754 return GetLogicalDriveStringsW (nBufferLength, (LPWSTR) lpBuffer); | |
2755 else | |
2756 return GetLogicalDriveStringsA (nBufferLength, (LPSTR) lpBuffer); | |
2757 } | |
2758 | |
2759 HMODULE | |
2760 qxeLoadLibrary (const Extbyte * lpLibFileName) | |
2761 { | |
2762 if (XEUNICODE_P) | |
2763 return LoadLibraryW ((LPCWSTR) lpLibFileName); | |
2764 else | |
2765 return LoadLibraryA ((LPCSTR) lpLibFileName); | |
2766 } | |
2767 | |
2768 HMODULE | |
2769 qxeLoadLibraryEx (const Extbyte * lpLibFileName, HANDLE hFile, DWORD dwFlags) | |
2770 { | |
2771 if (XEUNICODE_P) | |
2772 return LoadLibraryExW ((LPCWSTR) lpLibFileName, hFile, dwFlags); | |
2773 else | |
2774 return LoadLibraryExA ((LPCSTR) lpLibFileName, hFile, dwFlags); | |
2775 } | |
2776 | |
2777 DWORD | |
2778 qxeGetModuleFileName (HMODULE hModule, Extbyte * lpFilename, DWORD nSize) | |
2779 { | |
2780 if (XEUNICODE_P) | |
2781 return GetModuleFileNameW (hModule, (LPWSTR) lpFilename, nSize); | |
2782 else | |
2783 return GetModuleFileNameA (hModule, (LPSTR) lpFilename, nSize); | |
2784 } | |
2785 | |
2786 HMODULE | |
2787 qxeGetModuleHandle (const Extbyte * lpModuleName) | |
2788 { | |
2789 if (XEUNICODE_P) | |
2790 return GetModuleHandleW ((LPCWSTR) lpModuleName); | |
2791 else | |
2792 return GetModuleHandleA ((LPCSTR) lpModuleName); | |
2793 } | |
2794 | |
2795 BOOL | |
2796 qxeCreateProcess (const Extbyte * lpApplicationName, Extbyte * lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes, LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment, const Extbyte * lpCurrentDirectory, LPSTARTUPINFOW lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation) | |
2797 { | |
2798 if (XEUNICODE_P) | |
2799 return CreateProcessW ((LPCWSTR) lpApplicationName, (LPWSTR) lpCommandLine, lpProcessAttributes, lpThreadAttributes, bInheritHandles, dwCreationFlags, lpEnvironment, (LPCWSTR) lpCurrentDirectory, lpStartupInfo, lpProcessInformation); | |
2800 else | |
2801 return CreateProcessA ((LPCSTR) lpApplicationName, (LPSTR) lpCommandLine, lpProcessAttributes, lpThreadAttributes, bInheritHandles, dwCreationFlags, lpEnvironment, (LPCSTR) lpCurrentDirectory, (LPSTARTUPINFOA) lpStartupInfo, lpProcessInformation); | |
2802 } | |
2803 | |
2804 VOID | |
2805 qxeFatalAppExit (UINT uAction, const Extbyte * lpMessageText) | |
2806 { | |
2807 if (XEUNICODE_P) | |
2808 FatalAppExitW (uAction, (LPCWSTR) lpMessageText); | |
2809 else | |
2810 FatalAppExitA (uAction, (LPCSTR) lpMessageText); | |
2811 } | |
2812 | |
2813 VOID | |
2814 qxeGetStartupInfo (LPSTARTUPINFOW lpStartupInfo) | |
2815 { | |
2816 if (XEUNICODE_P) | |
2817 GetStartupInfoW (lpStartupInfo); | |
2818 else | |
2819 GetStartupInfoA ((LPSTARTUPINFOA) lpStartupInfo); | |
2820 } | |
2821 | |
2822 Extbyte * | |
2823 qxeGetCommandLine (void) | |
2824 { | |
2825 if (XEUNICODE_P) | |
2826 return (Extbyte *) GetCommandLineW (); | |
2827 else | |
2828 return (Extbyte *) GetCommandLineA (); | |
2829 } | |
2830 | |
2831 DWORD | |
2832 qxeGetEnvironmentVariable (const Extbyte * lpName, Extbyte * lpBuffer, DWORD nSize) | |
2833 { | |
2834 if (XEUNICODE_P) | |
2835 return GetEnvironmentVariableW ((LPCWSTR) lpName, (LPWSTR) lpBuffer, nSize); | |
2836 else | |
2837 return GetEnvironmentVariableA ((LPCSTR) lpName, (LPSTR) lpBuffer, nSize); | |
2838 } | |
2839 | |
2840 BOOL | |
2841 qxeSetEnvironmentVariable (const Extbyte * lpName, const Extbyte * lpValue) | |
2842 { | |
2843 if (XEUNICODE_P) | |
2844 return SetEnvironmentVariableW ((LPCWSTR) lpName, (LPCWSTR) lpValue); | |
2845 else | |
2846 return SetEnvironmentVariableA ((LPCSTR) lpName, (LPCSTR) lpValue); | |
2847 } | |
2848 | |
2849 DWORD | |
2850 qxeExpandEnvironmentStrings (const Extbyte * lpSrc, Extbyte * lpDst, DWORD nSize) | |
2851 { | |
2852 if (XEUNICODE_P) | |
2853 return ExpandEnvironmentStringsW ((LPCWSTR) lpSrc, (LPWSTR) lpDst, nSize); | |
2854 else | |
2855 return ExpandEnvironmentStringsA ((LPCSTR) lpSrc, (LPSTR) lpDst, nSize); | |
2856 } | |
2857 | |
2858 VOID | |
2859 qxeOutputDebugString (const Extbyte * lpOutputString) | |
2860 { | |
2861 if (XEUNICODE_P) | |
2862 OutputDebugStringW ((LPCWSTR) lpOutputString); | |
2863 else | |
2864 OutputDebugStringA ((LPCSTR) lpOutputString); | |
2865 } | |
2866 | |
2867 HRSRC | |
2868 qxeFindResource (HMODULE hModule, const Extbyte * lpName, const Extbyte * lpType) | |
2869 { | |
2870 if (XEUNICODE_P) | |
2871 return FindResourceW (hModule, (LPCWSTR) lpName, (LPCWSTR) lpType); | |
2872 else | |
2873 return FindResourceA (hModule, (LPCSTR) lpName, (LPCSTR) lpType); | |
2874 } | |
2875 | |
2876 HRSRC | |
2877 qxeFindResourceEx (HMODULE hModule, const Extbyte * lpType, const Extbyte * lpName, WORD wLanguage) | |
2878 { | |
2879 if (XEUNICODE_P) | |
2880 return FindResourceExW (hModule, (LPCWSTR) lpType, (LPCWSTR) lpName, wLanguage); | |
2881 else | |
2882 return FindResourceExA (hModule, (LPCSTR) lpType, (LPCSTR) lpName, wLanguage); | |
2883 } | |
2884 | |
2885 BOOL | |
2886 qxeEnumResourceTypes (HMODULE hModule, ENUMRESTYPEPROC lpEnumFunc, LONG lParam) | |
2887 { | |
2888 if (XEUNICODE_P) | |
2889 return EnumResourceTypesW (hModule, lpEnumFunc, lParam); | |
2890 else | |
2891 return EnumResourceTypesA (hModule, lpEnumFunc, lParam); | |
2892 } | |
2893 | |
2894 BOOL | |
2895 qxeEnumResourceNames (HMODULE hModule, const Extbyte * lpType, ENUMRESNAMEPROC lpEnumFunc, LONG lParam) | |
2896 { | |
2897 if (XEUNICODE_P) | |
2898 return EnumResourceNamesW (hModule, (LPCWSTR) lpType, lpEnumFunc, lParam); | |
2899 else | |
2900 return EnumResourceNamesA (hModule, (LPCSTR) lpType, lpEnumFunc, lParam); | |
2901 } | |
2902 | |
2903 BOOL | |
2904 qxeEnumResourceLanguages (HMODULE hModule, const Extbyte * lpType, const Extbyte * lpName, ENUMRESLANGPROC lpEnumFunc, LONG lParam) | |
2905 { | |
2906 if (XEUNICODE_P) | |
2907 return EnumResourceLanguagesW (hModule, (LPCWSTR) lpType, (LPCWSTR) lpName, lpEnumFunc, lParam); | |
2908 else | |
2909 return EnumResourceLanguagesA (hModule, (LPCSTR) lpType, (LPCSTR) lpName, lpEnumFunc, lParam); | |
2910 } | |
2911 | |
2912 HANDLE | |
2913 qxeBeginUpdateResource (const Extbyte * pFileName, BOOL bDeleteExistingResources) | |
2914 { | |
2915 if (XEUNICODE_P) | |
2916 return BeginUpdateResourceW ((LPCWSTR) pFileName, bDeleteExistingResources); | |
2917 else | |
2918 return BeginUpdateResourceA ((LPCSTR) pFileName, bDeleteExistingResources); | |
2919 } | |
2920 | |
2921 BOOL | |
2922 qxeUpdateResource (HANDLE hUpdate, const Extbyte * lpType, const Extbyte * lpName, WORD wLanguage, LPVOID lpData, DWORD cbData) | |
2923 { | |
2924 if (XEUNICODE_P) | |
2925 return UpdateResourceW (hUpdate, (LPCWSTR) lpType, (LPCWSTR) lpName, wLanguage, lpData, cbData); | |
2926 else | |
2927 return UpdateResourceA (hUpdate, (LPCSTR) lpType, (LPCSTR) lpName, wLanguage, lpData, cbData); | |
2928 } | |
2929 | |
2930 BOOL | |
2931 qxeEndUpdateResource (HANDLE hUpdate, BOOL fDiscard) | |
2932 { | |
2933 if (XEUNICODE_P) | |
2934 return EndUpdateResourceW (hUpdate, fDiscard); | |
2935 else | |
2936 return EndUpdateResourceA (hUpdate, fDiscard); | |
2937 } | |
2938 | |
2939 ATOM | |
2940 qxeGlobalAddAtom (const Extbyte * lpString) | |
2941 { | |
2942 if (XEUNICODE_P) | |
2943 return GlobalAddAtomW ((LPCWSTR) lpString); | |
2944 else | |
2945 return GlobalAddAtomA ((LPCSTR) lpString); | |
2946 } | |
2947 | |
2948 ATOM | |
2949 qxeGlobalFindAtom (const Extbyte * lpString) | |
2950 { | |
2951 if (XEUNICODE_P) | |
2952 return GlobalFindAtomW ((LPCWSTR) lpString); | |
2953 else | |
2954 return GlobalFindAtomA ((LPCSTR) lpString); | |
2955 } | |
2956 | |
2957 UINT | |
2958 qxeGlobalGetAtomName (ATOM nAtom, Extbyte * lpBuffer, int nSize) | |
2959 { | |
2960 if (XEUNICODE_P) | |
2961 return GlobalGetAtomNameW (nAtom, (LPWSTR) lpBuffer, nSize); | |
2962 else | |
2963 return GlobalGetAtomNameA (nAtom, (LPSTR) lpBuffer, nSize); | |
2964 } | |
2965 | |
2966 ATOM | |
2967 qxeAddAtom (const Extbyte * lpString) | |
2968 { | |
2969 if (XEUNICODE_P) | |
2970 return AddAtomW ((LPCWSTR) lpString); | |
2971 else | |
2972 return AddAtomA ((LPCSTR) lpString); | |
2973 } | |
2974 | |
2975 ATOM | |
2976 qxeFindAtom (const Extbyte * lpString) | |
2977 { | |
2978 if (XEUNICODE_P) | |
2979 return FindAtomW ((LPCWSTR) lpString); | |
2980 else | |
2981 return FindAtomA ((LPCSTR) lpString); | |
2982 } | |
2983 | |
2984 UINT | |
2985 qxeGetAtomName (ATOM nAtom, Extbyte * lpBuffer, int nSize) | |
2986 { | |
2987 if (XEUNICODE_P) | |
2988 return GetAtomNameW (nAtom, (LPWSTR) lpBuffer, nSize); | |
2989 else | |
2990 return GetAtomNameA (nAtom, (LPSTR) lpBuffer, nSize); | |
2991 } | |
2992 | |
2993 UINT | |
2994 qxeGetProfileInt (const Extbyte * lpAppName, const Extbyte * lpKeyName, INT nDefault) | |
2995 { | |
2996 if (XEUNICODE_P) | |
2997 return GetProfileIntW ((LPCWSTR) lpAppName, (LPCWSTR) lpKeyName, nDefault); | |
2998 else | |
2999 return GetProfileIntA ((LPCSTR) lpAppName, (LPCSTR) lpKeyName, nDefault); | |
3000 } | |
3001 | |
3002 DWORD | |
3003 qxeGetProfileString (const Extbyte * lpAppName, const Extbyte * lpKeyName, const Extbyte * lpDefault, Extbyte * lpReturnedString, DWORD nSize) | |
3004 { | |
3005 if (XEUNICODE_P) | |
3006 return GetProfileStringW ((LPCWSTR) lpAppName, (LPCWSTR) lpKeyName, (LPCWSTR) lpDefault, (LPWSTR) lpReturnedString, nSize); | |
3007 else | |
3008 return GetProfileStringA ((LPCSTR) lpAppName, (LPCSTR) lpKeyName, (LPCSTR) lpDefault, (LPSTR) lpReturnedString, nSize); | |
3009 } | |
3010 | |
3011 BOOL | |
3012 qxeWriteProfileString (const Extbyte * lpAppName, const Extbyte * lpKeyName, const Extbyte * lpString) | |
3013 { | |
3014 if (XEUNICODE_P) | |
3015 return WriteProfileStringW ((LPCWSTR) lpAppName, (LPCWSTR) lpKeyName, (LPCWSTR) lpString); | |
3016 else | |
3017 return WriteProfileStringA ((LPCSTR) lpAppName, (LPCSTR) lpKeyName, (LPCSTR) lpString); | |
3018 } | |
3019 | |
3020 DWORD | |
3021 qxeGetProfileSection (const Extbyte * lpAppName, Extbyte * lpReturnedString, DWORD nSize) | |
3022 { | |
3023 if (XEUNICODE_P) | |
3024 return GetProfileSectionW ((LPCWSTR) lpAppName, (LPWSTR) lpReturnedString, nSize); | |
3025 else | |
3026 return GetProfileSectionA ((LPCSTR) lpAppName, (LPSTR) lpReturnedString, nSize); | |
3027 } | |
3028 | |
3029 BOOL | |
3030 qxeWriteProfileSection (const Extbyte * lpAppName, const Extbyte * lpString) | |
3031 { | |
3032 if (XEUNICODE_P) | |
3033 return WriteProfileSectionW ((LPCWSTR) lpAppName, (LPCWSTR) lpString); | |
3034 else | |
3035 return WriteProfileSectionA ((LPCSTR) lpAppName, (LPCSTR) lpString); | |
3036 } | |
3037 | |
3038 UINT | |
3039 qxeGetPrivateProfileInt (const Extbyte * lpAppName, const Extbyte * lpKeyName, INT nDefault, const Extbyte * lpFileName) | |
3040 { | |
3041 if (XEUNICODE_P) | |
3042 return GetPrivateProfileIntW ((LPCWSTR) lpAppName, (LPCWSTR) lpKeyName, nDefault, (LPCWSTR) lpFileName); | |
3043 else | |
3044 return GetPrivateProfileIntA ((LPCSTR) lpAppName, (LPCSTR) lpKeyName, nDefault, (LPCSTR) lpFileName); | |
3045 } | |
3046 | |
3047 DWORD | |
3048 qxeGetPrivateProfileString (const Extbyte * lpAppName, const Extbyte * lpKeyName, const Extbyte * lpDefault, Extbyte * lpReturnedString, DWORD nSize, const Extbyte * lpFileName) | |
3049 { | |
3050 if (XEUNICODE_P) | |
3051 return GetPrivateProfileStringW ((LPCWSTR) lpAppName, (LPCWSTR) lpKeyName, (LPCWSTR) lpDefault, (LPWSTR) lpReturnedString, nSize, (LPCWSTR) lpFileName); | |
3052 else | |
3053 return GetPrivateProfileStringA ((LPCSTR) lpAppName, (LPCSTR) lpKeyName, (LPCSTR) lpDefault, (LPSTR) lpReturnedString, nSize, (LPCSTR) lpFileName); | |
3054 } | |
3055 | |
3056 BOOL | |
3057 qxeWritePrivateProfileString (const Extbyte * lpAppName, const Extbyte * lpKeyName, const Extbyte * lpString, const Extbyte * lpFileName) | |
3058 { | |
3059 if (XEUNICODE_P) | |
3060 return WritePrivateProfileStringW ((LPCWSTR) lpAppName, (LPCWSTR) lpKeyName, (LPCWSTR) lpString, (LPCWSTR) lpFileName); | |
3061 else | |
3062 return WritePrivateProfileStringA ((LPCSTR) lpAppName, (LPCSTR) lpKeyName, (LPCSTR) lpString, (LPCSTR) lpFileName); | |
3063 } | |
3064 | |
3065 DWORD | |
3066 qxeGetPrivateProfileSection (const Extbyte * lpAppName, Extbyte * lpReturnedString, DWORD nSize, const Extbyte * lpFileName) | |
3067 { | |
3068 if (XEUNICODE_P) | |
3069 return GetPrivateProfileSectionW ((LPCWSTR) lpAppName, (LPWSTR) lpReturnedString, nSize, (LPCWSTR) lpFileName); | |
3070 else | |
3071 return GetPrivateProfileSectionA ((LPCSTR) lpAppName, (LPSTR) lpReturnedString, nSize, (LPCSTR) lpFileName); | |
3072 } | |
3073 | |
3074 BOOL | |
3075 qxeWritePrivateProfileSection (const Extbyte * lpAppName, const Extbyte * lpString, const Extbyte * lpFileName) | |
3076 { | |
3077 if (XEUNICODE_P) | |
3078 return WritePrivateProfileSectionW ((LPCWSTR) lpAppName, (LPCWSTR) lpString, (LPCWSTR) lpFileName); | |
3079 else | |
3080 return WritePrivateProfileSectionA ((LPCSTR) lpAppName, (LPCSTR) lpString, (LPCSTR) lpFileName); | |
3081 } | |
3082 | |
3083 DWORD | |
3084 qxeGetPrivateProfileSectionNames (Extbyte * lpszReturnBuffer, DWORD nSize, const Extbyte * lpFileName) | |
3085 { | |
3086 if (XEUNICODE_P) | |
3087 return GetPrivateProfileSectionNamesW ((LPWSTR) lpszReturnBuffer, nSize, (LPCWSTR) lpFileName); | |
3088 else | |
3089 return GetPrivateProfileSectionNamesA ((LPSTR) lpszReturnBuffer, nSize, (LPCSTR) lpFileName); | |
3090 } | |
3091 | |
3092 BOOL | |
3093 qxeGetPrivateProfileStruct (const Extbyte * lpszSection, const Extbyte * lpszKey, LPVOID lpStruct, UINT uSizeStruct, const Extbyte * szFile) | |
3094 { | |
3095 if (XEUNICODE_P) | |
3096 return GetPrivateProfileStructW ((LPCWSTR) lpszSection, (LPCWSTR) lpszKey, lpStruct, uSizeStruct, (LPCWSTR) szFile); | |
3097 else | |
3098 return GetPrivateProfileStructA ((LPCSTR) lpszSection, (LPCSTR) lpszKey, lpStruct, uSizeStruct, (LPCSTR) szFile); | |
3099 } | |
3100 | |
3101 BOOL | |
3102 qxeWritePrivateProfileStruct (const Extbyte * lpszSection, const Extbyte * lpszKey, LPVOID lpStruct, UINT uSizeStruct, const Extbyte * szFile) | |
3103 { | |
3104 if (XEUNICODE_P) | |
3105 return WritePrivateProfileStructW ((LPCWSTR) lpszSection, (LPCWSTR) lpszKey, lpStruct, uSizeStruct, (LPCWSTR) szFile); | |
3106 else | |
3107 return WritePrivateProfileStructA ((LPCSTR) lpszSection, (LPCSTR) lpszKey, lpStruct, uSizeStruct, (LPCSTR) szFile); | |
3108 } | |
3109 | |
3110 UINT | |
3111 qxeGetDriveType (const Extbyte * lpRootPathName) | |
3112 { | |
3113 if (XEUNICODE_P) | |
3114 return GetDriveTypeW ((LPCWSTR) lpRootPathName); | |
3115 else | |
3116 return GetDriveTypeA ((LPCSTR) lpRootPathName); | |
3117 } | |
3118 | |
3119 UINT | |
3120 qxeGetSystemDirectory (Extbyte * lpBuffer, UINT uSize) | |
3121 { | |
3122 if (XEUNICODE_P) | |
3123 return GetSystemDirectoryW ((LPWSTR) lpBuffer, uSize); | |
3124 else | |
3125 return GetSystemDirectoryA ((LPSTR) lpBuffer, uSize); | |
3126 } | |
3127 | |
3128 DWORD | |
3129 qxeGetTempPath (DWORD nBufferLength, Extbyte * lpBuffer) | |
3130 { | |
3131 if (XEUNICODE_P) | |
3132 return GetTempPathW (nBufferLength, (LPWSTR) lpBuffer); | |
3133 else | |
3134 return GetTempPathA (nBufferLength, (LPSTR) lpBuffer); | |
3135 } | |
3136 | |
3137 UINT | |
3138 qxeGetTempFileName (const Extbyte * lpPathName, const Extbyte * lpPrefixString, UINT uUnique, Extbyte * lpTempFileName) | |
3139 { | |
3140 if (XEUNICODE_P) | |
3141 return GetTempFileNameW ((LPCWSTR) lpPathName, (LPCWSTR) lpPrefixString, uUnique, (LPWSTR) lpTempFileName); | |
3142 else | |
3143 return GetTempFileNameA ((LPCSTR) lpPathName, (LPCSTR) lpPrefixString, uUnique, (LPSTR) lpTempFileName); | |
3144 } | |
3145 | |
3146 UINT | |
3147 qxeGetWindowsDirectory (Extbyte * lpBuffer, UINT uSize) | |
3148 { | |
3149 if (XEUNICODE_P) | |
3150 return GetWindowsDirectoryW ((LPWSTR) lpBuffer, uSize); | |
3151 else | |
3152 return GetWindowsDirectoryA ((LPSTR) lpBuffer, uSize); | |
3153 } | |
3154 | |
3155 BOOL | |
3156 qxeSetCurrentDirectory (const Extbyte * lpPathName) | |
3157 { | |
3158 if (XEUNICODE_P) | |
3159 return SetCurrentDirectoryW ((LPCWSTR) lpPathName); | |
3160 else | |
3161 return SetCurrentDirectoryA ((LPCSTR) lpPathName); | |
3162 } | |
3163 | |
3164 DWORD | |
3165 qxeGetCurrentDirectory (DWORD nBufferLength, Extbyte * lpBuffer) | |
3166 { | |
3167 if (XEUNICODE_P) | |
3168 return GetCurrentDirectoryW (nBufferLength, (LPWSTR) lpBuffer); | |
3169 else | |
3170 return GetCurrentDirectoryA (nBufferLength, (LPSTR) lpBuffer); | |
3171 } | |
3172 | |
3173 BOOL | |
3174 qxeGetDiskFreeSpace (const Extbyte * lpRootPathName, LPDWORD lpSectorsPerCluster, LPDWORD lpBytesPerSector, LPDWORD lpNumberOfFreeClusters, LPDWORD lpTotalNumberOfClusters) | |
3175 { | |
3176 if (XEUNICODE_P) | |
3177 return GetDiskFreeSpaceW ((LPCWSTR) lpRootPathName, lpSectorsPerCluster, lpBytesPerSector, lpNumberOfFreeClusters, lpTotalNumberOfClusters); | |
3178 else | |
3179 return GetDiskFreeSpaceA ((LPCSTR) lpRootPathName, lpSectorsPerCluster, lpBytesPerSector, lpNumberOfFreeClusters, lpTotalNumberOfClusters); | |
3180 } | |
3181 | |
3182 BOOL | |
3183 qxeGetDiskFreeSpaceEx (const Extbyte * lpDirectoryName, PULARGE_INTEGER lpFreeBytesAvailableToCaller, PULARGE_INTEGER lpTotalNumberOfBytes, PULARGE_INTEGER lpTotalNumberOfFreeBytes) | |
3184 { | |
3185 if (XEUNICODE_P) | |
3186 return GetDiskFreeSpaceExW ((LPCWSTR) lpDirectoryName, lpFreeBytesAvailableToCaller, lpTotalNumberOfBytes, lpTotalNumberOfFreeBytes); | |
3187 else | |
3188 return GetDiskFreeSpaceExA ((LPCSTR) lpDirectoryName, lpFreeBytesAvailableToCaller, lpTotalNumberOfBytes, lpTotalNumberOfFreeBytes); | |
3189 } | |
3190 | |
3191 BOOL | |
3192 qxeCreateDirectory (const Extbyte * lpPathName, LPSECURITY_ATTRIBUTES lpSecurityAttributes) | |
3193 { | |
3194 if (XEUNICODE_P) | |
3195 return CreateDirectoryW ((LPCWSTR) lpPathName, lpSecurityAttributes); | |
3196 else | |
3197 return CreateDirectoryA ((LPCSTR) lpPathName, lpSecurityAttributes); | |
3198 } | |
3199 | |
3200 BOOL | |
3201 qxeCreateDirectoryEx (const Extbyte * lpTemplateDirectory, const Extbyte * lpNewDirectory, LPSECURITY_ATTRIBUTES lpSecurityAttributes) | |
3202 { | |
3203 if (XEUNICODE_P) | |
3204 return CreateDirectoryExW ((LPCWSTR) lpTemplateDirectory, (LPCWSTR) lpNewDirectory, lpSecurityAttributes); | |
3205 else | |
3206 return CreateDirectoryExA ((LPCSTR) lpTemplateDirectory, (LPCSTR) lpNewDirectory, lpSecurityAttributes); | |
3207 } | |
3208 | |
3209 BOOL | |
3210 qxeRemoveDirectory (const Extbyte * lpPathName) | |
3211 { | |
3212 if (XEUNICODE_P) | |
3213 return RemoveDirectoryW ((LPCWSTR) lpPathName); | |
3214 else | |
3215 return RemoveDirectoryA ((LPCSTR) lpPathName); | |
3216 } | |
3217 | |
3218 DWORD | |
3219 qxeGetFullPathName (const Extbyte * lpFileName, DWORD nBufferLength, Extbyte * lpBuffer, Extbyte * * lpFilePart) | |
3220 { | |
3221 if (XEUNICODE_P) | |
3222 return GetFullPathNameW ((LPCWSTR) lpFileName, nBufferLength, (LPWSTR) lpBuffer, (LPWSTR *) lpFilePart); | |
3223 else | |
3224 return GetFullPathNameA ((LPCSTR) lpFileName, nBufferLength, (LPSTR) lpBuffer, (LPSTR *) lpFilePart); | |
3225 } | |
3226 | |
3227 BOOL | |
3228 qxeDefineDosDevice (DWORD dwFlags, const Extbyte * lpDeviceName, const Extbyte * lpTargetPath) | |
3229 { | |
3230 if (XEUNICODE_P) | |
3231 return DefineDosDeviceW (dwFlags, (LPCWSTR) lpDeviceName, (LPCWSTR) lpTargetPath); | |
3232 else | |
3233 return DefineDosDeviceA (dwFlags, (LPCSTR) lpDeviceName, (LPCSTR) lpTargetPath); | |
3234 } | |
3235 | |
3236 DWORD | |
3237 qxeQueryDosDevice (const Extbyte * lpDeviceName, Extbyte * lpTargetPath, DWORD ucchMax) | |
3238 { | |
3239 if (XEUNICODE_P) | |
3240 return QueryDosDeviceW ((LPCWSTR) lpDeviceName, (LPWSTR) lpTargetPath, ucchMax); | |
3241 else | |
3242 return QueryDosDeviceA ((LPCSTR) lpDeviceName, (LPSTR) lpTargetPath, ucchMax); | |
3243 } | |
3244 | |
3245 HANDLE | |
3246 qxeCreateFile (const Extbyte * lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile) | |
3247 { | |
3248 if (XEUNICODE_P) | |
3249 return CreateFileW ((LPCWSTR) lpFileName, dwDesiredAccess, dwShareMode, lpSecurityAttributes, dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile); | |
3250 else | |
3251 return CreateFileA ((LPCSTR) lpFileName, dwDesiredAccess, dwShareMode, lpSecurityAttributes, dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile); | |
3252 } | |
3253 | |
3254 BOOL | |
3255 qxeSetFileAttributes (const Extbyte * lpFileName, DWORD dwFileAttributes) | |
3256 { | |
3257 if (XEUNICODE_P) | |
3258 return SetFileAttributesW ((LPCWSTR) lpFileName, dwFileAttributes); | |
3259 else | |
3260 return SetFileAttributesA ((LPCSTR) lpFileName, dwFileAttributes); | |
3261 } | |
3262 | |
3263 DWORD | |
3264 qxeGetFileAttributes (const Extbyte * lpFileName) | |
3265 { | |
3266 if (XEUNICODE_P) | |
3267 return GetFileAttributesW ((LPCWSTR) lpFileName); | |
3268 else | |
3269 return GetFileAttributesA ((LPCSTR) lpFileName); | |
3270 } | |
3271 | |
3272 BOOL | |
3273 qxeGetFileAttributesEx (const Extbyte * lpFileName, GET_FILEEX_INFO_LEVELS fInfoLevelId, LPVOID lpFileInformation) | |
3274 { | |
3275 if (XEUNICODE_P) | |
3276 return GetFileAttributesExW ((LPCWSTR) lpFileName, fInfoLevelId, lpFileInformation); | |
3277 else | |
3278 return GetFileAttributesExA ((LPCSTR) lpFileName, fInfoLevelId, lpFileInformation); | |
3279 } | |
3280 | |
3281 DWORD | |
3282 qxeGetCompressedFileSize (const Extbyte * lpFileName, LPDWORD lpFileSizeHigh) | |
3283 { | |
3284 if (XEUNICODE_P) | |
3285 return GetCompressedFileSizeW ((LPCWSTR) lpFileName, lpFileSizeHigh); | |
3286 else | |
3287 return GetCompressedFileSizeA ((LPCSTR) lpFileName, lpFileSizeHigh); | |
3288 } | |
3289 | |
3290 BOOL | |
3291 qxeDeleteFile (const Extbyte * lpFileName) | |
3292 { | |
3293 if (XEUNICODE_P) | |
3294 return DeleteFileW ((LPCWSTR) lpFileName); | |
3295 else | |
3296 return DeleteFileA ((LPCSTR) lpFileName); | |
3297 } | |
3298 | |
3299 /* Error if FindFirstFileEx used: split-sized LPWIN32_FIND_DATA; not used, NT 4.0+ only */ | |
3300 | |
3301 /* Skipping FindFirstFile because split-sized LPWIN32_FIND_DATA */ | |
3302 | |
3303 /* Skipping FindNextFile because split-sized LPWIN32_FIND_DATA */ | |
3304 | |
3305 DWORD | |
3306 qxeSearchPath (const Extbyte * lpPath, const Extbyte * lpFileName, const Extbyte * lpExtension, DWORD nBufferLength, Extbyte * lpBuffer, Extbyte * * lpFilePart) | |
3307 { | |
3308 if (XEUNICODE_P) | |
3309 return SearchPathW ((LPCWSTR) lpPath, (LPCWSTR) lpFileName, (LPCWSTR) lpExtension, nBufferLength, (LPWSTR) lpBuffer, (LPWSTR *) lpFilePart); | |
3310 else | |
3311 return SearchPathA ((LPCSTR) lpPath, (LPCSTR) lpFileName, (LPCSTR) lpExtension, nBufferLength, (LPSTR) lpBuffer, (LPSTR *) lpFilePart); | |
3312 } | |
3313 | |
3314 BOOL | |
3315 qxeCopyFile (const Extbyte * lpExistingFileName, const Extbyte * lpNewFileName, BOOL bFailIfExists) | |
3316 { | |
3317 if (XEUNICODE_P) | |
3318 return CopyFileW ((LPCWSTR) lpExistingFileName, (LPCWSTR) lpNewFileName, bFailIfExists); | |
3319 else | |
3320 return CopyFileA ((LPCSTR) lpExistingFileName, (LPCSTR) lpNewFileName, bFailIfExists); | |
3321 } | |
3322 | |
3323 /* NOTE: NT 4.0+ only */ | |
3324 BOOL | |
3325 qxeCopyFileEx (const Extbyte * lpExistingFileName, const Extbyte * lpNewFileName, LPPROGRESS_ROUTINE lpProgressRoutine, LPVOID lpData, LPBOOL pbCancel, DWORD dwCopyFlags) | |
3326 { | |
3327 if (XEUNICODE_P) | |
3328 return CopyFileExW ((LPCWSTR) lpExistingFileName, (LPCWSTR) lpNewFileName, lpProgressRoutine, lpData, pbCancel, dwCopyFlags); | |
3329 else | |
3330 return CopyFileExA ((LPCSTR) lpExistingFileName, (LPCSTR) lpNewFileName, lpProgressRoutine, lpData, pbCancel, dwCopyFlags); | |
3331 } | |
3332 | |
3333 BOOL | |
3334 qxeMoveFile (const Extbyte * lpExistingFileName, const Extbyte * lpNewFileName) | |
3335 { | |
3336 if (XEUNICODE_P) | |
3337 return MoveFileW ((LPCWSTR) lpExistingFileName, (LPCWSTR) lpNewFileName); | |
3338 else | |
3339 return MoveFileA ((LPCSTR) lpExistingFileName, (LPCSTR) lpNewFileName); | |
3340 } | |
3341 | |
3342 BOOL | |
3343 qxeMoveFileEx (const Extbyte * lpExistingFileName, const Extbyte * lpNewFileName, DWORD dwFlags) | |
3344 { | |
3345 if (XEUNICODE_P) | |
3346 return MoveFileExW ((LPCWSTR) lpExistingFileName, (LPCWSTR) lpNewFileName, dwFlags); | |
3347 else | |
3348 return MoveFileExA ((LPCSTR) lpExistingFileName, (LPCSTR) lpNewFileName, dwFlags); | |
3349 } | |
3350 | |
3351 /* Error if MoveFileWithProgress used: NT 5.0+ only */ | |
3352 | |
3353 /* Error if CreateHardLink used: NT 5.0+ only */ | |
3354 | |
3355 HANDLE | |
3356 qxeCreateNamedPipe (const Extbyte * lpName, DWORD dwOpenMode, DWORD dwPipeMode, DWORD nMaxInstances, DWORD nOutBufferSize, DWORD nInBufferSize, DWORD nDefaultTimeOut, LPSECURITY_ATTRIBUTES lpSecurityAttributes) | |
3357 { | |
3358 if (XEUNICODE_P) | |
3359 return CreateNamedPipeW ((LPCWSTR) lpName, dwOpenMode, dwPipeMode, nMaxInstances, nOutBufferSize, nInBufferSize, nDefaultTimeOut, lpSecurityAttributes); | |
3360 else | |
3361 return CreateNamedPipeA ((LPCSTR) lpName, dwOpenMode, dwPipeMode, nMaxInstances, nOutBufferSize, nInBufferSize, nDefaultTimeOut, lpSecurityAttributes); | |
3362 } | |
3363 | |
3364 BOOL | |
3365 qxeGetNamedPipeHandleState (HANDLE hNamedPipe, LPDWORD lpState, LPDWORD lpCurInstances, LPDWORD lpMaxCollectionCount, LPDWORD lpCollectDataTimeout, Extbyte * lpUserName, DWORD nMaxUserNameSize) | |
3366 { | |
3367 if (XEUNICODE_P) | |
3368 return GetNamedPipeHandleStateW (hNamedPipe, lpState, lpCurInstances, lpMaxCollectionCount, lpCollectDataTimeout, (LPWSTR) lpUserName, nMaxUserNameSize); | |
3369 else | |
3370 return GetNamedPipeHandleStateA (hNamedPipe, lpState, lpCurInstances, lpMaxCollectionCount, lpCollectDataTimeout, (LPSTR) lpUserName, nMaxUserNameSize); | |
3371 } | |
3372 | |
3373 BOOL | |
3374 qxeCallNamedPipe (const Extbyte * lpNamedPipeName, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesRead, DWORD nTimeOut) | |
3375 { | |
3376 if (XEUNICODE_P) | |
3377 return CallNamedPipeW ((LPCWSTR) lpNamedPipeName, lpInBuffer, nInBufferSize, lpOutBuffer, nOutBufferSize, lpBytesRead, nTimeOut); | |
3378 else | |
3379 return CallNamedPipeA ((LPCSTR) lpNamedPipeName, lpInBuffer, nInBufferSize, lpOutBuffer, nOutBufferSize, lpBytesRead, nTimeOut); | |
3380 } | |
3381 | |
3382 BOOL | |
3383 qxeWaitNamedPipe (const Extbyte * lpNamedPipeName, DWORD nTimeOut) | |
3384 { | |
3385 if (XEUNICODE_P) | |
3386 return WaitNamedPipeW ((LPCWSTR) lpNamedPipeName, nTimeOut); | |
3387 else | |
3388 return WaitNamedPipeA ((LPCSTR) lpNamedPipeName, nTimeOut); | |
3389 } | |
3390 | |
3391 BOOL | |
3392 qxeSetVolumeLabel (const Extbyte * lpRootPathName, const Extbyte * lpVolumeName) | |
3393 { | |
3394 if (XEUNICODE_P) | |
3395 return SetVolumeLabelW ((LPCWSTR) lpRootPathName, (LPCWSTR) lpVolumeName); | |
3396 else | |
3397 return SetVolumeLabelA ((LPCSTR) lpRootPathName, (LPCSTR) lpVolumeName); | |
3398 } | |
3399 | |
3400 BOOL | |
3401 qxeGetVolumeInformation (const Extbyte * lpRootPathName, Extbyte * lpVolumeNameBuffer, DWORD nVolumeNameSize, LPDWORD lpVolumeSerialNumber, LPDWORD lpMaximumComponentLength, LPDWORD lpFileSystemFlags, Extbyte * lpFileSystemNameBuffer, DWORD nFileSystemNameSize) | |
3402 { | |
3403 if (XEUNICODE_P) | |
3404 return GetVolumeInformationW ((LPCWSTR) lpRootPathName, (LPWSTR) lpVolumeNameBuffer, nVolumeNameSize, lpVolumeSerialNumber, lpMaximumComponentLength, lpFileSystemFlags, (LPWSTR) lpFileSystemNameBuffer, nFileSystemNameSize); | |
3405 else | |
3406 return GetVolumeInformationA ((LPCSTR) lpRootPathName, (LPSTR) lpVolumeNameBuffer, nVolumeNameSize, lpVolumeSerialNumber, lpMaximumComponentLength, lpFileSystemFlags, (LPSTR) lpFileSystemNameBuffer, nFileSystemNameSize); | |
3407 } | |
3408 | |
3409 BOOL | |
3410 qxeClearEventLog (HANDLE hEventLog, const Extbyte * lpBackupFileName) | |
3411 { | |
3412 if (XEUNICODE_P) | |
3413 return ClearEventLogW (hEventLog, (LPCWSTR) lpBackupFileName); | |
3414 else | |
3415 return ClearEventLogA (hEventLog, (LPCSTR) lpBackupFileName); | |
3416 } | |
3417 | |
3418 BOOL | |
3419 qxeBackupEventLog (HANDLE hEventLog, const Extbyte * lpBackupFileName) | |
3420 { | |
3421 if (XEUNICODE_P) | |
3422 return BackupEventLogW (hEventLog, (LPCWSTR) lpBackupFileName); | |
3423 else | |
3424 return BackupEventLogA (hEventLog, (LPCSTR) lpBackupFileName); | |
3425 } | |
3426 | |
3427 HANDLE | |
3428 qxeOpenEventLog (const Extbyte * lpUNCServerName, const Extbyte * lpSourceName) | |
3429 { | |
3430 if (XEUNICODE_P) | |
3431 return OpenEventLogW ((LPCWSTR) lpUNCServerName, (LPCWSTR) lpSourceName); | |
3432 else | |
3433 return OpenEventLogA ((LPCSTR) lpUNCServerName, (LPCSTR) lpSourceName); | |
3434 } | |
3435 | |
3436 HANDLE | |
3437 qxeRegisterEventSource (const Extbyte * lpUNCServerName, const Extbyte * lpSourceName) | |
3438 { | |
3439 if (XEUNICODE_P) | |
3440 return RegisterEventSourceW ((LPCWSTR) lpUNCServerName, (LPCWSTR) lpSourceName); | |
3441 else | |
3442 return RegisterEventSourceA ((LPCSTR) lpUNCServerName, (LPCSTR) lpSourceName); | |
3443 } | |
3444 | |
3445 HANDLE | |
3446 qxeOpenBackupEventLog (const Extbyte * lpUNCServerName, const Extbyte * lpFileName) | |
3447 { | |
3448 if (XEUNICODE_P) | |
3449 return OpenBackupEventLogW ((LPCWSTR) lpUNCServerName, (LPCWSTR) lpFileName); | |
3450 else | |
3451 return OpenBackupEventLogA ((LPCSTR) lpUNCServerName, (LPCSTR) lpFileName); | |
3452 } | |
3453 | |
3454 BOOL | |
3455 qxeReadEventLog (HANDLE hEventLog, DWORD dwReadFlags, DWORD dwRecordOffset, LPVOID lpBuffer, DWORD nNumberOfBytesToRead, DWORD * pnBytesRead, DWORD * pnMinNumberOfBytesNeeded) | |
3456 { | |
3457 if (XEUNICODE_P) | |
3458 return ReadEventLogW (hEventLog, dwReadFlags, dwRecordOffset, lpBuffer, nNumberOfBytesToRead, pnBytesRead, pnMinNumberOfBytesNeeded); | |
3459 else | |
3460 return ReadEventLogA (hEventLog, dwReadFlags, dwRecordOffset, lpBuffer, nNumberOfBytesToRead, pnBytesRead, pnMinNumberOfBytesNeeded); | |
3461 } | |
3462 | |
3463 BOOL | |
3464 qxeReportEvent (HANDLE hEventLog, WORD wType, WORD wCategory, DWORD dwEventID, PSID lpUserSid, WORD wNumStrings, DWORD dwDataSize, const Extbyte * * lpStrings, LPVOID lpRawData) | |
3465 { | |
3466 if (XEUNICODE_P) | |
3467 return ReportEventW (hEventLog, wType, wCategory, dwEventID, lpUserSid, wNumStrings, dwDataSize, (LPCWSTR *) lpStrings, lpRawData); | |
3468 else | |
3469 return ReportEventA (hEventLog, wType, wCategory, dwEventID, lpUserSid, wNumStrings, dwDataSize, (LPCSTR *) lpStrings, lpRawData); | |
3470 } | |
3471 | |
3472 BOOL | |
3473 qxeAccessCheckAndAuditAlarm (const Extbyte * SubsystemName, LPVOID HandleId, Extbyte * ObjectTypeName, Extbyte * ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, DWORD DesiredAccess, PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess, LPBOOL AccessStatus, LPBOOL pfGenerateOnClose) | |
3474 { | |
3475 if (XEUNICODE_P) | |
3476 return AccessCheckAndAuditAlarmW ((LPCWSTR) SubsystemName, HandleId, (LPWSTR) ObjectTypeName, (LPWSTR) ObjectName, SecurityDescriptor, DesiredAccess, GenericMapping, ObjectCreation, GrantedAccess, AccessStatus, pfGenerateOnClose); | |
3477 else | |
3478 return AccessCheckAndAuditAlarmA ((LPCSTR) SubsystemName, HandleId, (LPSTR) ObjectTypeName, (LPSTR) ObjectName, SecurityDescriptor, DesiredAccess, GenericMapping, ObjectCreation, GrantedAccess, AccessStatus, pfGenerateOnClose); | |
3479 } | |
3480 | |
3481 /* Error if AccessCheckByTypeAndAuditAlarm used: NT 5.0+ only */ | |
3482 | |
3483 /* Error if AccessCheckByTypeResultListAndAuditAlarm used: NT 5.0+ only */ | |
3484 | |
3485 BOOL | |
3486 qxeObjectOpenAuditAlarm (const Extbyte * SubsystemName, LPVOID HandleId, Extbyte * ObjectTypeName, Extbyte * ObjectName, PSECURITY_DESCRIPTOR pSecurityDescriptor, HANDLE ClientToken, DWORD DesiredAccess, DWORD GrantedAccess, PPRIVILEGE_SET Privileges, BOOL ObjectCreation, BOOL AccessGranted, LPBOOL GenerateOnClose) | |
3487 { | |
3488 if (XEUNICODE_P) | |
3489 return ObjectOpenAuditAlarmW ((LPCWSTR) SubsystemName, HandleId, (LPWSTR) ObjectTypeName, (LPWSTR) ObjectName, pSecurityDescriptor, ClientToken, DesiredAccess, GrantedAccess, Privileges, ObjectCreation, AccessGranted, GenerateOnClose); | |
3490 else | |
3491 return ObjectOpenAuditAlarmA ((LPCSTR) SubsystemName, HandleId, (LPSTR) ObjectTypeName, (LPSTR) ObjectName, pSecurityDescriptor, ClientToken, DesiredAccess, GrantedAccess, Privileges, ObjectCreation, AccessGranted, GenerateOnClose); | |
3492 } | |
3493 | |
3494 BOOL | |
3495 qxeObjectPrivilegeAuditAlarm (const Extbyte * SubsystemName, LPVOID HandleId, HANDLE ClientToken, DWORD DesiredAccess, PPRIVILEGE_SET Privileges, BOOL AccessGranted) | |
3496 { | |
3497 if (XEUNICODE_P) | |
3498 return ObjectPrivilegeAuditAlarmW ((LPCWSTR) SubsystemName, HandleId, ClientToken, DesiredAccess, Privileges, AccessGranted); | |
3499 else | |
3500 return ObjectPrivilegeAuditAlarmA ((LPCSTR) SubsystemName, HandleId, ClientToken, DesiredAccess, Privileges, AccessGranted); | |
3501 } | |
3502 | |
3503 BOOL | |
3504 qxeObjectCloseAuditAlarm (const Extbyte * SubsystemName, LPVOID HandleId, BOOL GenerateOnClose) | |
3505 { | |
3506 if (XEUNICODE_P) | |
3507 return ObjectCloseAuditAlarmW ((LPCWSTR) SubsystemName, HandleId, GenerateOnClose); | |
3508 else | |
3509 return ObjectCloseAuditAlarmA ((LPCSTR) SubsystemName, HandleId, GenerateOnClose); | |
3510 } | |
3511 | |
3512 BOOL | |
3513 qxeObjectDeleteAuditAlarm (const Extbyte * SubsystemName, LPVOID HandleId, BOOL GenerateOnClose) | |
3514 { | |
3515 if (XEUNICODE_P) | |
3516 return ObjectDeleteAuditAlarmW ((LPCWSTR) SubsystemName, HandleId, GenerateOnClose); | |
3517 else | |
3518 return ObjectDeleteAuditAlarmA ((LPCSTR) SubsystemName, HandleId, GenerateOnClose); | |
3519 } | |
3520 | |
3521 BOOL | |
3522 qxePrivilegedServiceAuditAlarm (const Extbyte * SubsystemName, const Extbyte * ServiceName, HANDLE ClientToken, PPRIVILEGE_SET Privileges, BOOL AccessGranted) | |
3523 { | |
3524 if (XEUNICODE_P) | |
3525 return PrivilegedServiceAuditAlarmW ((LPCWSTR) SubsystemName, (LPCWSTR) ServiceName, ClientToken, Privileges, AccessGranted); | |
3526 else | |
3527 return PrivilegedServiceAuditAlarmA ((LPCSTR) SubsystemName, (LPCSTR) ServiceName, ClientToken, Privileges, AccessGranted); | |
3528 } | |
3529 | |
3530 BOOL | |
3531 qxeSetFileSecurity (const Extbyte * lpFileName, SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor) | |
3532 { | |
3533 if (XEUNICODE_P) | |
3534 return SetFileSecurityW ((LPCWSTR) lpFileName, SecurityInformation, pSecurityDescriptor); | |
3535 else | |
3536 return SetFileSecurityA ((LPCSTR) lpFileName, SecurityInformation, pSecurityDescriptor); | |
3537 } | |
3538 | |
3539 BOOL | |
3540 qxeGetFileSecurity (const Extbyte * lpFileName, SECURITY_INFORMATION RequestedInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor, DWORD nLength, LPDWORD lpnLengthNeeded) | |
3541 { | |
3542 if (XEUNICODE_P) | |
3543 return GetFileSecurityW ((LPCWSTR) lpFileName, RequestedInformation, pSecurityDescriptor, nLength, lpnLengthNeeded); | |
3544 else | |
3545 return GetFileSecurityA ((LPCSTR) lpFileName, RequestedInformation, pSecurityDescriptor, nLength, lpnLengthNeeded); | |
3546 } | |
3547 | |
3548 HANDLE | |
3549 qxeFindFirstChangeNotification (const Extbyte * lpPathName, BOOL bWatchSubtree, DWORD dwNotifyFilter) | |
3550 { | |
3551 if (XEUNICODE_P) | |
3552 return FindFirstChangeNotificationW ((LPCWSTR) lpPathName, bWatchSubtree, dwNotifyFilter); | |
3553 else | |
3554 return FindFirstChangeNotificationA ((LPCSTR) lpPathName, bWatchSubtree, dwNotifyFilter); | |
3555 } | |
3556 | |
3557 /* Error if ReadDirectoryChanges used: Unicode-only */ | |
3558 | |
3559 BOOL | |
3560 qxeIsBadStringPtr (const Extbyte * lpsz, UINT ucchMax) | |
3561 { | |
3562 if (XEUNICODE_P) | |
3563 return IsBadStringPtrW ((LPCWSTR) lpsz, ucchMax); | |
3564 else | |
3565 return IsBadStringPtrA ((LPCSTR) lpsz, ucchMax); | |
3566 } | |
3567 | |
3568 BOOL | |
3569 qxeLookupAccountSid (const Extbyte * lpSystemName, PSID Sid, Extbyte * Name, LPDWORD cbName, Extbyte * ReferencedDomainName, LPDWORD cbReferencedDomainName, PSID_NAME_USE peUse) | |
3570 { | |
3571 if (XEUNICODE_P) | |
3572 return LookupAccountSidW ((LPCWSTR) lpSystemName, Sid, (LPWSTR) Name, cbName, (LPWSTR) ReferencedDomainName, cbReferencedDomainName, peUse); | |
3573 else | |
3574 return LookupAccountSidA ((LPCSTR) lpSystemName, Sid, (LPSTR) Name, cbName, (LPSTR) ReferencedDomainName, cbReferencedDomainName, peUse); | |
3575 } | |
3576 | |
3577 BOOL | |
3578 qxeLookupAccountName (const Extbyte * lpSystemName, const Extbyte * lpAccountName, PSID Sid, LPDWORD cbSid, Extbyte * ReferencedDomainName, LPDWORD cbReferencedDomainName, PSID_NAME_USE peUse) | |
3579 { | |
3580 if (XEUNICODE_P) | |
3581 return LookupAccountNameW ((LPCWSTR) lpSystemName, (LPCWSTR) lpAccountName, Sid, cbSid, (LPWSTR) ReferencedDomainName, cbReferencedDomainName, peUse); | |
3582 else | |
3583 return LookupAccountNameA ((LPCSTR) lpSystemName, (LPCSTR) lpAccountName, Sid, cbSid, (LPSTR) ReferencedDomainName, cbReferencedDomainName, peUse); | |
3584 } | |
3585 | |
3586 BOOL | |
3587 qxeLookupPrivilegeValue (const Extbyte * lpSystemName, const Extbyte * lpName, PLUID lpLuid) | |
3588 { | |
3589 if (XEUNICODE_P) | |
3590 return LookupPrivilegeValueW ((LPCWSTR) lpSystemName, (LPCWSTR) lpName, lpLuid); | |
3591 else | |
3592 return LookupPrivilegeValueA ((LPCSTR) lpSystemName, (LPCSTR) lpName, lpLuid); | |
3593 } | |
3594 | |
3595 BOOL | |
3596 qxeLookupPrivilegeName (const Extbyte * lpSystemName, PLUID lpLuid, Extbyte * lpName, LPDWORD cbName) | |
3597 { | |
3598 if (XEUNICODE_P) | |
3599 return LookupPrivilegeNameW ((LPCWSTR) lpSystemName, lpLuid, (LPWSTR) lpName, cbName); | |
3600 else | |
3601 return LookupPrivilegeNameA ((LPCSTR) lpSystemName, lpLuid, (LPSTR) lpName, cbName); | |
3602 } | |
3603 | |
3604 BOOL | |
3605 qxeLookupPrivilegeDisplayName (const Extbyte * lpSystemName, const Extbyte * lpName, Extbyte * lpDisplayName, LPDWORD cbDisplayName, LPDWORD lpLanguageId) | |
3606 { | |
3607 if (XEUNICODE_P) | |
3608 return LookupPrivilegeDisplayNameW ((LPCWSTR) lpSystemName, (LPCWSTR) lpName, (LPWSTR) lpDisplayName, cbDisplayName, lpLanguageId); | |
3609 else | |
3610 return LookupPrivilegeDisplayNameA ((LPCSTR) lpSystemName, (LPCSTR) lpName, (LPSTR) lpDisplayName, cbDisplayName, lpLanguageId); | |
3611 } | |
3612 | |
3613 BOOL | |
3614 qxeBuildCommDCB (const Extbyte * lpDef, LPDCB lpDCB) | |
3615 { | |
3616 if (XEUNICODE_P) | |
3617 return BuildCommDCBW ((LPCWSTR) lpDef, lpDCB); | |
3618 else | |
3619 return BuildCommDCBA ((LPCSTR) lpDef, lpDCB); | |
3620 } | |
3621 | |
3622 BOOL | |
3623 qxeBuildCommDCBAndTimeouts (const Extbyte * lpDef, LPDCB lpDCB, LPCOMMTIMEOUTS lpCommTimeouts) | |
3624 { | |
3625 if (XEUNICODE_P) | |
3626 return BuildCommDCBAndTimeoutsW ((LPCWSTR) lpDef, lpDCB, lpCommTimeouts); | |
3627 else | |
3628 return BuildCommDCBAndTimeoutsA ((LPCSTR) lpDef, lpDCB, lpCommTimeouts); | |
3629 } | |
3630 | |
3631 BOOL | |
3632 qxeCommConfigDialog (const Extbyte * lpszName, HWND hWnd, LPCOMMCONFIG lpCC) | |
3633 { | |
3634 if (XEUNICODE_P) | |
3635 return CommConfigDialogW ((LPCWSTR) lpszName, hWnd, lpCC); | |
3636 else | |
3637 return CommConfigDialogA ((LPCSTR) lpszName, hWnd, lpCC); | |
3638 } | |
3639 | |
3640 BOOL | |
3641 qxeGetDefaultCommConfig (const Extbyte * lpszName, LPCOMMCONFIG lpCC, LPDWORD lpdwSize) | |
3642 { | |
3643 if (XEUNICODE_P) | |
3644 return GetDefaultCommConfigW ((LPCWSTR) lpszName, lpCC, lpdwSize); | |
3645 else | |
3646 return GetDefaultCommConfigA ((LPCSTR) lpszName, lpCC, lpdwSize); | |
3647 } | |
3648 | |
3649 BOOL | |
3650 qxeSetDefaultCommConfig (const Extbyte * lpszName, LPCOMMCONFIG lpCC, DWORD dwSize) | |
3651 { | |
3652 if (XEUNICODE_P) | |
3653 return SetDefaultCommConfigW ((LPCWSTR) lpszName, lpCC, dwSize); | |
3654 else | |
3655 return SetDefaultCommConfigA ((LPCSTR) lpszName, lpCC, dwSize); | |
3656 } | |
3657 | |
3658 BOOL | |
3659 qxeGetComputerName (Extbyte * lpBuffer, LPDWORD nSize) | |
3660 { | |
3661 if (XEUNICODE_P) | |
3662 return GetComputerNameW ((LPWSTR) lpBuffer, nSize); | |
3663 else | |
3664 return GetComputerNameA ((LPSTR) lpBuffer, nSize); | |
3665 } | |
3666 | |
3667 BOOL | |
3668 qxeSetComputerName (const Extbyte * lpComputerName) | |
3669 { | |
3670 if (XEUNICODE_P) | |
3671 return SetComputerNameW ((LPCWSTR) lpComputerName); | |
3672 else | |
3673 return SetComputerNameA ((LPCSTR) lpComputerName); | |
3674 } | |
3675 | |
3676 BOOL | |
3677 qxeGetUserName (Extbyte * lpBuffer, LPDWORD nSize) | |
3678 { | |
3679 if (XEUNICODE_P) | |
3680 return GetUserNameW ((LPWSTR) lpBuffer, nSize); | |
3681 else | |
3682 return GetUserNameA ((LPSTR) lpBuffer, nSize); | |
3683 } | |
3684 | |
3685 BOOL | |
3686 qxeLogonUser (Extbyte * lpszUsername, Extbyte * lpszDomain, Extbyte * lpszPassword, DWORD dwLogonType, DWORD dwLogonProvider, PHANDLE phToken) | |
3687 { | |
3688 if (XEUNICODE_P) | |
3689 return LogonUserW ((LPWSTR) lpszUsername, (LPWSTR) lpszDomain, (LPWSTR) lpszPassword, dwLogonType, dwLogonProvider, phToken); | |
3690 else | |
3691 return LogonUserA ((LPSTR) lpszUsername, (LPSTR) lpszDomain, (LPSTR) lpszPassword, dwLogonType, dwLogonProvider, phToken); | |
3692 } | |
3693 | |
3694 BOOL | |
3695 qxeCreateProcessAsUser (HANDLE hToken, const Extbyte * lpApplicationName, Extbyte * lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes, LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment, const Extbyte * lpCurrentDirectory, LPSTARTUPINFOW lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation) | |
3696 { | |
3697 if (XEUNICODE_P) | |
3698 return CreateProcessAsUserW (hToken, (LPCWSTR) lpApplicationName, (LPWSTR) lpCommandLine, lpProcessAttributes, lpThreadAttributes, bInheritHandles, dwCreationFlags, lpEnvironment, (LPCWSTR) lpCurrentDirectory, lpStartupInfo, lpProcessInformation); | |
3699 else | |
3700 return CreateProcessAsUserA (hToken, (LPCSTR) lpApplicationName, (LPSTR) lpCommandLine, lpProcessAttributes, lpThreadAttributes, bInheritHandles, dwCreationFlags, lpEnvironment, (LPCSTR) lpCurrentDirectory, (LPSTARTUPINFOA) lpStartupInfo, lpProcessInformation); | |
3701 } | |
3702 | |
3703 /* Error if GetCurrentHwProfile used: split-sized LPHW_PROFILE_INFO; NT 4.0+ only */ | |
3704 | |
3705 /* Error if GetVersionEx used: split-sized LPOSVERSIONINFO */ | |
3706 | |
3707 /* Error if CreateJobObject used: NT 5.0+ only */ | |
3708 | |
3709 /* Error if OpenJobObject used: NT 5.0+ only */ | |
3710 | |
3711 | |
3712 /*----------------------------------------------------------------------*/ | |
3713 /* Processing file COMMDLG.H */ | |
3714 /*----------------------------------------------------------------------*/ | |
3715 | |
3716 BOOL | |
3717 qxeGetOpenFileName (LPOPENFILENAMEW arg1) | |
3718 { | |
3719 if (XEUNICODE_P) | |
3720 return GetOpenFileNameW (arg1); | |
3721 else | |
3722 return GetOpenFileNameA ((LPOPENFILENAMEA) arg1); | |
3723 } | |
3724 | |
3725 BOOL | |
3726 qxeGetSaveFileName (LPOPENFILENAMEW arg1) | |
3727 { | |
3728 if (XEUNICODE_P) | |
3729 return GetSaveFileNameW (arg1); | |
3730 else | |
3731 return GetSaveFileNameA ((LPOPENFILENAMEA) arg1); | |
3732 } | |
3733 | |
3734 short | |
3735 qxeGetFileTitle (const Extbyte * arg1, Extbyte * arg2, WORD arg3) | |
3736 { | |
3737 if (XEUNICODE_P) | |
3738 return GetFileTitleW ((LPCWSTR) arg1, (LPWSTR) arg2, arg3); | |
3739 else | |
3740 return GetFileTitleA ((LPCSTR) arg1, (LPSTR) arg2, arg3); | |
3741 } | |
3742 | |
3743 BOOL | |
3744 qxeChooseColor (LPCHOOSECOLORW arg1) | |
3745 { | |
3746 if (XEUNICODE_P) | |
3747 return ChooseColorW (arg1); | |
3748 else | |
3749 return ChooseColorA ((LPCHOOSECOLORA) arg1); | |
3750 } | |
3751 | |
3752 HWND | |
3753 qxeFindText (LPFINDREPLACEW arg1) | |
3754 { | |
3755 if (XEUNICODE_P) | |
3756 return FindTextW (arg1); | |
3757 else | |
3758 return FindTextA ((LPFINDREPLACEA) arg1); | |
3759 } | |
3760 | |
3761 HWND | |
3762 qxeReplaceText (LPFINDREPLACEW arg1) | |
3763 { | |
3764 if (XEUNICODE_P) | |
3765 return ReplaceTextW (arg1); | |
3766 else | |
3767 return ReplaceTextA ((LPFINDREPLACEA) arg1); | |
3768 } | |
3769 | |
3770 /* Error if AfxReplaceText used: mac only */ | |
3771 | |
3772 /* Error if ChooseFont used: split-sized LPLOGFONT in LPCHOOSEFONT */ | |
3773 | |
3774 /* Skipping PrintDlg because LPPRINTDLG with split-sized DEVMODE handle */ | |
3775 | |
3776 /* Skipping PageSetupDlg because LPPAGESETUPDLG with split-sized DEVMODE handle */ | |
3777 | |
3778 | |
3779 /*----------------------------------------------------------------------*/ | |
3780 /* Processing file SHLOBJ.H */ | |
3781 /*----------------------------------------------------------------------*/ | |
3782 | |
3783 BOOL | |
3784 qxeSHGetPathFromIDList (LPCITEMIDLIST pidl, Extbyte * pszPath) | |
3785 { | |
3786 if (XEUNICODE_P) | |
3787 return SHGetPathFromIDListW (pidl, (LPWSTR) pszPath); | |
3788 else | |
3789 return SHGetPathFromIDListA (pidl, (LPSTR) pszPath); | |
3790 } | |
3791 | |
3792 /* Skipping SHGetSpecialFolderPath because error in Cygwin prototype */ | |
3793 | |
3794 /* Skipping SHBrowseForFolder because need to intercept callback for SendMessage */ | |
3795 | |
3796 /* Skipping SHGetDataFromIDList because split-sized WIN32_FIND_DATA or split-simple NETRESOURCE */ | |
3797 | |
3798 | |
3799 /*----------------------------------------------------------------------*/ | |
3800 /* Processing file IME.H */ | |
3801 /*----------------------------------------------------------------------*/ | |
3802 | |
3803 /* Error if SendIMEMessageEx used: obsolete, no docs available */ | |
3804 | |
3805 | |
3806 /*----------------------------------------------------------------------*/ | |
3807 /* Processing file WINGDI.H */ | |
3808 /*----------------------------------------------------------------------*/ | |
3809 | |
3810 int | |
3811 qxeAddFontResource (const Extbyte * arg1) | |
3812 { | |
3813 if (XEUNICODE_P) | |
3814 return AddFontResourceW ((LPCWSTR) arg1); | |
3815 else | |
3816 return AddFontResourceA ((LPCSTR) arg1); | |
3817 } | |
3818 | |
3819 HMETAFILE | |
3820 qxeCopyMetaFile (HMETAFILE arg1, const Extbyte * arg2) | |
3821 { | |
3822 if (XEUNICODE_P) | |
3823 return CopyMetaFileW (arg1, (LPCWSTR) arg2); | |
3824 else | |
3825 return CopyMetaFileA (arg1, (LPCSTR) arg2); | |
3826 } | |
3827 | |
3828 /* Skipping CreateDC because split-sized DEVMODE */ | |
3829 | |
3830 /* Skipping CreateFontIndirect because split-sized LOGFONT */ | |
3831 | |
3832 HFONT | |
3833 qxeCreateFont (int arg1, int arg2, int arg3, int arg4, int arg5, DWORD arg6, DWORD arg7, DWORD arg8, DWORD arg9, DWORD arg10, DWORD arg11, DWORD arg12, DWORD arg13, const Extbyte * arg14) | |
3834 { | |
3835 if (XEUNICODE_P) | |
3836 return CreateFontW (arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, (LPCWSTR) arg14); | |
3837 else | |
3838 return CreateFontA (arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, (LPCSTR) arg14); | |
3839 } | |
3840 | |
3841 /* Skipping CreateIC because split-sized DEVMODE */ | |
3842 | |
3843 HDC | |
3844 qxeCreateMetaFile (const Extbyte * arg1) | |
3845 { | |
3846 if (XEUNICODE_P) | |
3847 return CreateMetaFileW ((LPCWSTR) arg1); | |
3848 else | |
3849 return CreateMetaFileA ((LPCSTR) arg1); | |
3850 } | |
3851 | |
3852 BOOL | |
3853 qxeCreateScalableFontResource (DWORD arg1, const Extbyte * arg2, const Extbyte * arg3, const Extbyte * arg4) | |
3854 { | |
3855 if (XEUNICODE_P) | |
3856 return CreateScalableFontResourceW (arg1, (LPCWSTR) arg2, (LPCWSTR) arg3, (LPCWSTR) arg4); | |
3857 else | |
3858 return CreateScalableFontResourceA (arg1, (LPCSTR) arg2, (LPCSTR) arg3, (LPCSTR) arg4); | |
3859 } | |
3860 | |
3861 /* Skipping DeviceCapabilities because split-sized DEVMODE */ | |
3862 | |
3863 /* Skipping EnumFontFamiliesEx because split-complex FONTENUMPROC; NT 4.0+ only */ | |
3864 | |
3865 /* Error if EnumFontFamilies used: split-complex FONTENUMPROC */ | |
3866 | |
3867 /* Error if EnumFonts used: split-complex FONTENUMPROC */ | |
3868 | |
3869 BOOL | |
3870 qxeGetCharWidth (HDC arg1, UINT arg2, UINT arg3, LPINT arg4) | |
3871 { | |
3872 if (XEUNICODE_P) | |
3873 return GetCharWidthW (arg1, arg2, arg3, arg4); | |
3874 else | |
3875 return GetCharWidthA (arg1, arg2, arg3, arg4); | |
3876 } | |
3877 | |
3878 BOOL | |
3879 qxeGetCharWidth32 (HDC arg1, UINT arg2, UINT arg3, LPINT arg4) | |
3880 { | |
3881 if (XEUNICODE_P) | |
3882 return GetCharWidth32W (arg1, arg2, arg3, arg4); | |
3883 else | |
3884 return GetCharWidth32A (arg1, arg2, arg3, arg4); | |
3885 } | |
3886 | |
3887 BOOL | |
3888 qxeGetCharWidthFloat (HDC arg1, UINT arg2, UINT arg3, PFLOAT arg4) | |
3889 { | |
3890 if (XEUNICODE_P) | |
3891 return GetCharWidthFloatW (arg1, arg2, arg3, arg4); | |
3892 else | |
3893 return GetCharWidthFloatA (arg1, arg2, arg3, arg4); | |
3894 } | |
3895 | |
3896 BOOL | |
3897 qxeGetCharABCWidths (HDC arg1, UINT arg2, UINT arg3, LPABC arg4) | |
3898 { | |
3899 if (XEUNICODE_P) | |
3900 return GetCharABCWidthsW (arg1, arg2, arg3, arg4); | |
3901 else | |
3902 return GetCharABCWidthsA (arg1, arg2, arg3, arg4); | |
3903 } | |
3904 | |
3905 BOOL | |
3906 qxeGetCharABCWidthsFloat (HDC arg1, UINT arg2, UINT arg3, LPABCFLOAT arg4) | |
3907 { | |
3908 if (XEUNICODE_P) | |
3909 return GetCharABCWidthsFloatW (arg1, arg2, arg3, arg4); | |
3910 else | |
3911 return GetCharABCWidthsFloatA (arg1, arg2, arg3, arg4); | |
3912 } | |
3913 | |
3914 DWORD | |
3915 qxeGetGlyphOutline (HDC arg1, UINT arg2, UINT arg3, LPGLYPHMETRICS arg4, DWORD arg5, LPVOID arg6, CONST MAT2 * arg7) | |
3916 { | |
3917 if (XEUNICODE_P) | |
3918 return GetGlyphOutlineW (arg1, arg2, arg3, arg4, arg5, arg6, arg7); | |
3919 else | |
3920 return GetGlyphOutlineA (arg1, arg2, arg3, arg4, arg5, arg6, arg7); | |
3921 } | |
3922 | |
3923 HMETAFILE | |
3924 qxeGetMetaFile (const Extbyte * arg1) | |
3925 { | |
3926 if (XEUNICODE_P) | |
3927 return GetMetaFileW ((LPCWSTR) arg1); | |
3928 else | |
3929 return GetMetaFileA ((LPCSTR) arg1); | |
3930 } | |
3931 | |
3932 /* Error if GetOutlineTextMetrics used: split-sized LPOUTLINETEXTMETRIC */ | |
3933 | |
3934 BOOL | |
3935 qxeGetTextExtentPoint (HDC arg1, const Extbyte * arg2, int arg3, LPSIZE arg4) | |
3936 { | |
3937 if (XEUNICODE_P) | |
3938 return GetTextExtentPointW (arg1, (LPCWSTR) arg2, arg3, arg4); | |
3939 else | |
3940 return GetTextExtentPointA (arg1, (LPCSTR) arg2, arg3, arg4); | |
3941 } | |
3942 | |
3943 BOOL | |
3944 qxeGetTextExtentPoint32 (HDC arg1, const Extbyte * arg2, int arg3, LPSIZE arg4) | |
3945 { | |
3946 if (XEUNICODE_P) | |
3947 return GetTextExtentPoint32W (arg1, (LPCWSTR) arg2, arg3, arg4); | |
3948 else | |
3949 return GetTextExtentPoint32A (arg1, (LPCSTR) arg2, arg3, arg4); | |
3950 } | |
3951 | |
3952 BOOL | |
3953 qxeGetTextExtentExPoint (HDC arg1, const Extbyte * arg2, int arg3, int arg4, LPINT arg5, LPINT arg6, LPSIZE arg7) | |
3954 { | |
3955 if (XEUNICODE_P) | |
3956 return GetTextExtentExPointW (arg1, (LPCWSTR) arg2, arg3, arg4, arg5, arg6, arg7); | |
3957 else | |
3958 return GetTextExtentExPointA (arg1, (LPCSTR) arg2, arg3, arg4, arg5, arg6, arg7); | |
3959 } | |
3960 | |
3961 /* NOTE: NT 4.0+ only */ | |
3962 DWORD | |
3963 qxeGetCharacterPlacement (HDC arg1, const Extbyte * arg2, int arg3, int arg4, LPGCP_RESULTSW arg5, DWORD arg6) | |
3964 { | |
3965 if (XEUNICODE_P) | |
3966 return GetCharacterPlacementW (arg1, (LPCWSTR) arg2, arg3, arg4, arg5, arg6); | |
3967 else | |
3968 return GetCharacterPlacementA (arg1, (LPCSTR) arg2, arg3, arg4, (LPGCP_RESULTSA) arg5, arg6); | |
3969 } | |
3970 | |
3971 /* Error if GetGlyphIndices used: NT 5.0+ only */ | |
3972 | |
3973 /* Error if AddFontResourceEx used: NT 5.0+ only */ | |
3974 | |
3975 /* Error if RemoveFontResourceEx used: NT 5.0+ only */ | |
3976 | |
3977 /* Error if CreateFontIndirectEx used: split-sized ENUMLOGFONTEXDV; NT 5.0+ only */ | |
3978 | |
3979 /* Skipping ResetDC because split-sized DEVMODE */ | |
3980 | |
3981 BOOL | |
3982 qxeRemoveFontResource (const Extbyte * arg1) | |
3983 { | |
3984 if (XEUNICODE_P) | |
3985 return RemoveFontResourceW ((LPCWSTR) arg1); | |
3986 else | |
3987 return RemoveFontResourceA ((LPCSTR) arg1); | |
3988 } | |
3989 | |
3990 HENHMETAFILE | |
3991 qxeCopyEnhMetaFile (HENHMETAFILE arg1, const Extbyte * arg2) | |
3992 { | |
3993 if (XEUNICODE_P) | |
3994 return CopyEnhMetaFileW (arg1, (LPCWSTR) arg2); | |
3995 else | |
3996 return CopyEnhMetaFileA (arg1, (LPCSTR) arg2); | |
3997 } | |
3998 | |
3999 HDC | |
4000 qxeCreateEnhMetaFile (HDC arg1, const Extbyte * arg2, CONST RECT * arg3, const Extbyte * arg4) | |
4001 { | |
4002 if (XEUNICODE_P) | |
4003 return CreateEnhMetaFileW (arg1, (LPCWSTR) arg2, arg3, (LPCWSTR) arg4); | |
4004 else | |
4005 return CreateEnhMetaFileA (arg1, (LPCSTR) arg2, arg3, (LPCSTR) arg4); | |
4006 } | |
4007 | |
4008 HENHMETAFILE | |
4009 qxeGetEnhMetaFile (const Extbyte * arg1) | |
4010 { | |
4011 if (XEUNICODE_P) | |
4012 return GetEnhMetaFileW ((LPCWSTR) arg1); | |
4013 else | |
4014 return GetEnhMetaFileA ((LPCSTR) arg1); | |
4015 } | |
4016 | |
4017 UINT | |
4018 qxeGetEnhMetaFileDescription (HENHMETAFILE arg1, UINT arg2, Extbyte * arg3) | |
4019 { | |
4020 if (XEUNICODE_P) | |
4021 return GetEnhMetaFileDescriptionW (arg1, arg2, (LPWSTR) arg3); | |
4022 else | |
4023 return GetEnhMetaFileDescriptionA (arg1, arg2, (LPSTR) arg3); | |
4024 } | |
4025 | |
4026 /* Skipping GetTextMetrics because split-sized LPTEXTMETRIC */ | |
4027 | |
4028 int | |
4029 qxeStartDoc (HDC arg1, CONST DOCINFOW * arg2) | |
4030 { | |
4031 if (XEUNICODE_P) | |
4032 return StartDocW (arg1, arg2); | |
4033 else | |
4034 return StartDocA (arg1, (CONST DOCINFOA *) arg2); | |
4035 } | |
4036 | |
4037 /* Skipping GetObject because split-sized LOGFONT */ | |
4038 | |
4039 BOOL | |
4040 qxeTextOut (HDC arg1, int arg2, int arg3, const Extbyte * arg4, int arg5) | |
4041 { | |
4042 if (XEUNICODE_P) | |
4043 return TextOutW (arg1, arg2, arg3, (LPCWSTR) arg4, arg5); | |
4044 else | |
4045 return TextOutA (arg1, arg2, arg3, (LPCSTR) arg4, arg5); | |
4046 } | |
4047 | |
4048 BOOL | |
4049 qxeExtTextOut (HDC arg1, int arg2, int arg3, UINT arg4, CONST RECT * arg5, const Extbyte * arg6, UINT arg7, CONST INT * arg8) | |
4050 { | |
4051 if (XEUNICODE_P) | |
4052 return ExtTextOutW (arg1, arg2, arg3, arg4, arg5, (LPCWSTR) arg6, arg7, arg8); | |
4053 else | |
4054 return ExtTextOutA (arg1, arg2, arg3, arg4, arg5, (LPCSTR) arg6, arg7, arg8); | |
4055 } | |
4056 | |
4057 BOOL | |
4058 qxePolyTextOut (HDC arg1, CONST POLYTEXTW * arg2, int arg3) | |
4059 { | |
4060 if (XEUNICODE_P) | |
4061 return PolyTextOutW (arg1, arg2, arg3); | |
4062 else | |
4063 return PolyTextOutA (arg1, (CONST POLYTEXTA *) arg2, arg3); | |
4064 } | |
4065 | |
4066 int | |
4067 qxeGetTextFace (HDC arg1, int arg2, Extbyte * arg3) | |
4068 { | |
4069 if (XEUNICODE_P) | |
4070 return GetTextFaceW (arg1, arg2, (LPWSTR) arg3); | |
4071 else | |
4072 return GetTextFaceA (arg1, arg2, (LPSTR) arg3); | |
4073 } | |
4074 | |
4075 DWORD | |
4076 qxeGetKerningPairs (HDC arg1, DWORD arg2, LPKERNINGPAIR arg3) | |
4077 { | |
4078 if (XEUNICODE_P) | |
4079 return GetKerningPairsW (arg1, arg2, arg3); | |
4080 else | |
4081 return GetKerningPairsA (arg1, arg2, arg3); | |
4082 } | |
4083 | |
4084 /* Error if GetLogColorSpace used: split-sized LPLOGCOLORSPACE; NT 4.0+ only */ | |
4085 | |
4086 /* Error if CreateColorSpace used: split-sized LPLOGCOLORSPACE; NT 4.0+ only */ | |
4087 | |
4088 /* Skipping GetICMProfile because NT 4.0+ only, error in Cygwin prototype */ | |
4089 | |
4090 /* NOTE: NT 4.0+ only */ | |
4091 BOOL | |
4092 qxeSetICMProfile (HDC arg1, Extbyte * arg2) | |
4093 { | |
4094 if (XEUNICODE_P) | |
4095 return SetICMProfileW (arg1, (LPWSTR) arg2); | |
4096 else | |
4097 return SetICMProfileA (arg1, (LPSTR) arg2); | |
4098 } | |
4099 | |
4100 /* NOTE: NT 4.0+ only */ | |
4101 int | |
4102 qxeEnumICMProfiles (HDC arg1, ICMENUMPROCW arg2, LPARAM arg3) | |
4103 { | |
4104 if (XEUNICODE_P) | |
4105 return EnumICMProfilesW (arg1, arg2, arg3); | |
4106 else | |
4107 return EnumICMProfilesA (arg1, (ICMENUMPROCA) arg2, arg3); | |
4108 } | |
4109 | |
4110 /* Skipping UpdateICMRegKey because NT 4.0+ only, error in Cygwin prototype */ | |
4111 | |
4112 /* Error if wglUseFontBitmaps used: causes link error */ | |
4113 | |
4114 /* Error if wglUseFontOutlines used: causes link error */ | |
4115 |