?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
We should always allocate in NdrConformantStringUnmarshal if the
[wine.git] / dlls / user / dialog.c
blob6aa95a1e42b77aaad702da2e31e6e6fb08fe484e
1 /*
2 * Dialog functions
3 *
4 * Copyright 1993, 1994, 1996 Alexandre Julliard
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 */
20
21 #include "config.h"
22 #include "wine/port.h"
23
24 #include <ctype.h>
25 #include <errno.h>
26 #include <limits.h>
27 #include <stdlib.h>
28 #include <stdarg.h>
29 #include <stdio.h>
30 #include <string.h>
31
32 #include "windef.h"
33 #include "winbase.h"
34 #include "wingdi.h"
35 #include "winuser.h"
36 #include "winnls.h"
37 #include "wine/winuser16.h"
38 #include "wine/unicode.h"
39 #include "controls.h"
40 #include "win.h"
41 #include "winpos.h"
42 #include "user_private.h"
43 #include "wine/debug.h"
44
45 WINE_DEFAULT_DEBUG_CHANNEL(dialog);
46
47
48 /* Dialog control information */
49 typedef struct
50 {
51 DWORD style;
52 DWORD exStyle;
53 DWORD helpId;
54 INT16 x;
55 INT16 y;
56 INT16 cx;
57 INT16 cy;
58 UINT_PTR id;
59 LPCWSTR className;
60 LPCWSTR windowName;
61 LPCVOID data;
62 } DLG_CONTROL_INFO;
63
64 /* Dialog template */
65 typedef struct
66 {
67 DWORD style;
68 DWORD exStyle;
69 DWORD helpId;
70 UINT16 nbItems;
71 INT16 x;
72 INT16 y;
73 INT16 cx;
74 INT16 cy;
75 LPCWSTR menuName;
76 LPCWSTR className;
77 LPCWSTR caption;
78 INT16 pointSize;
79 WORD weight;
80 BOOL italic;
81 LPCWSTR faceName;
82 BOOL dialogEx;
83 } DLG_TEMPLATE;
84
85 /* Radio button group */
86 typedef struct
87 {
88 UINT firstID;
89 UINT lastID;
90 UINT checkID;
91 } RADIOGROUP;
92
93
94 /*********************************************************************
95 * dialog class descriptor
96 */
97 const struct builtin_class_descr DIALOG_builtin_class =
98 {
99 DIALOG_CLASS_ATOMA, /* name */
100 CS_SAVEBITS | CS_DBLCLKS, /* style */
101 DefDlgProcA, /* procA */
102 DefDlgProcW, /* procW */
103 DLGWINDOWEXTRA, /* extra */
104 IDC_ARROW, /* cursor */
105 0 /* brush */
106 };
107
108
109 /***********************************************************************
110 * DIALOG_EnableOwner
111 *
112 * Helper function for modal dialogs to enable again the
113 * owner of the dialog box.
114 */
115 void DIALOG_EnableOwner( HWND hOwner )
116 {
117 /* Owner must be a top-level window */
118 if (hOwner)
119 hOwner = GetAncestor( hOwner, GA_ROOT );
120 if (!hOwner) return;
121 EnableWindow( hOwner, TRUE );
122 }
123
124
125 /***********************************************************************
126 * DIALOG_DisableOwner
127 *
128 * Helper function for modal dialogs to disable the
129 * owner of the dialog box. Returns TRUE if owner was enabled.
130 */
131 BOOL DIALOG_DisableOwner( HWND hOwner )
132 {
133 /* Owner must be a top-level window */
134 if (hOwner)
135 hOwner = GetAncestor( hOwner, GA_ROOT );
136 if (!hOwner) return FALSE;
137 if (IsWindowEnabled( hOwner ))
138 {
139 EnableWindow( hOwner, FALSE );
140 return TRUE;
141 }
142 else
143 return FALSE;
144 }
145
146 /***********************************************************************
147 * DIALOG_GetControl32
148 *
149 * Return the class and text of the control pointed to by ptr,
150 * fill the header structure and return a pointer to the next control.
151 */
152 static const WORD *DIALOG_GetControl32( const WORD *p, DLG_CONTROL_INFO *info,
153 BOOL dialogEx )
154 {
155 if (dialogEx)
156 {
157 info->helpId = GET_DWORD(p); p += 2;
158 info->exStyle = GET_DWORD(p); p += 2;
159 info->style = GET_DWORD(p); p += 2;
160 }
161 else
162 {
163 info->helpId = 0;
164 info->style = GET_DWORD(p); p += 2;
165 info->exStyle = GET_DWORD(p); p += 2;
166 }
167 info->x = GET_WORD(p); p++;
168 info->y = GET_WORD(p); p++;
169 info->cx = GET_WORD(p); p++;
170 info->cy = GET_WORD(p); p++;
171
172 if (dialogEx)
173 {
174 /* id is a DWORD for DIALOGEX */
175 info->id = GET_DWORD(p);
176 p += 2;
177 }
178 else
179 {
180 info->id = GET_WORD(p);
181 p++;
182 }
183
184 if (GET_WORD(p) == 0xffff)
185 {
186 static const WCHAR class_names[6][10] =
187 {
188 { 'B','u','t','t','o','n', }, /* 0x80 */
189 { 'E','d','i','t', }, /* 0x81 */
190 { 'S','t','a','t','i','c', }, /* 0x82 */
191 { 'L','i','s','t','B','o','x', }, /* 0x83 */
192 { 'S','c','r','o','l','l','B','a','r', }, /* 0x84 */
193 { 'C','o','m','b','o','B','o','x', } /* 0x85 */
194 };
195 WORD id = GET_WORD(p+1);
196 /* Windows treats dialog control class ids 0-5 same way as 0x80-0x85 */
197 if ((id >= 0x80) && (id <= 0x85)) id -= 0x80;
198 if (id <= 5)
199 info->className = class_names[id];
200 else
201 {
202 info->className = NULL;
203 ERR("Unknown built-in class id %04x\n", id );
204 }
205 p += 2;
206 }
207 else
208 {
209 info->className = (LPCWSTR)p;
210 p += strlenW( info->className ) + 1;
211 }
212
213 if (GET_WORD(p) == 0xffff) /* Is it an integer id? */
214 {
215 info->windowName = MAKEINTRESOURCEW(GET_WORD(p + 1));
216 p += 2;
217 }
218 else
219 {
220 info->windowName = (LPCWSTR)p;
221 p += strlenW( info->windowName ) + 1;
222 }
223
224 TRACE(" %s %s %d, %d, %d, %d, %d, %08lx, %08lx, %08lx\n",
225 debugstr_w( info->className ), debugstr_w( info->windowName ),
226 info->id, info->x, info->y, info->cx, info->cy,
227 info->style, info->exStyle, info->helpId );
228
229 if (GET_WORD(p))
230 {
231 if (TRACE_ON(dialog))
232 {
233 WORD i, count = GET_WORD(p) / sizeof(WORD);
234 TRACE(" BEGIN\n");
235 TRACE(" ");
236 for (i = 0; i < count; i++) TRACE( "%04x,", GET_WORD(p+i+1) );
237 TRACE("\n");
238 TRACE(" END\n" );
239 }
240 info->data = p + 1;
241 p += GET_WORD(p) / sizeof(WORD);
242 }
243 else info->data = NULL;
244 p++;
245
246 /* Next control is on dword boundary */
247 return (const WORD *)(((UINT_PTR)p + 3) & ~3);
248 }
249
250
251 /***********************************************************************
252 * DIALOG_CreateControls32
253 *
254 * Create the control windows for a dialog.
255 */
256 static BOOL DIALOG_CreateControls32( HWND hwnd, LPCSTR template, const DLG_TEMPLATE *dlgTemplate,
257 HINSTANCE hInst, BOOL unicode )
258 {
259 DIALOGINFO *dlgInfo = DIALOG_get_info( hwnd, TRUE );
260 DLG_CONTROL_INFO info;
261 HWND hwndCtrl, hwndDefButton = 0;
262 INT items = dlgTemplate->nbItems;
263
264 TRACE(" BEGIN\n" );
265 while (items--)
266 {
267 template = (LPCSTR)DIALOG_GetControl32( (const WORD *)template, &info,
268 dlgTemplate->dialogEx );
269 /* Is this it? */
270 if (info.style & WS_BORDER)
271 {
272 info.style &= ~WS_BORDER;
273 info.exStyle |= WS_EX_CLIENTEDGE;
274 }
275 if (unicode)
276 {
277 hwndCtrl = CreateWindowExW( info.exStyle | WS_EX_NOPARENTNOTIFY,
278 info.className, info.windowName,
279 info.style | WS_CHILD,
280 MulDiv(info.x, dlgInfo->xBaseUnit, 4),
281 MulDiv(info.y, dlgInfo->yBaseUnit, 8),
282 MulDiv(info.cx, dlgInfo->xBaseUnit, 4),
283 MulDiv(info.cy, dlgInfo->yBaseUnit, 8),
284 hwnd, (HMENU)info.id,
285 hInst, (LPVOID)info.data );
286 }
287 else
288 {
289 LPSTR class = (LPSTR)info.className;
290 LPSTR caption = (LPSTR)info.windowName;
291
292 if (HIWORD(class))
293 {
294 DWORD len = WideCharToMultiByte( CP_ACP, 0, info.className, -1, NULL, 0, NULL, NULL );
295 class = HeapAlloc( GetProcessHeap(), 0, len );
296 WideCharToMultiByte( CP_ACP, 0, info.className, -1, class, len, NULL, NULL );
297 }
298 if (HIWORD(caption))
299 {
300 DWORD len = WideCharToMultiByte( CP_ACP, 0, info.windowName, -1, NULL, 0, NULL, NULL );
301 caption = HeapAlloc( GetProcessHeap(), 0, len );
302 WideCharToMultiByte( CP_ACP, 0, info.windowName, -1, caption, len, NULL, NULL );
303 }
304 hwndCtrl = CreateWindowExA( info.exStyle | WS_EX_NOPARENTNOTIFY,
305 class, caption, info.style | WS_CHILD,
306 MulDiv(info.x, dlgInfo->xBaseUnit, 4),
307 MulDiv(info.y, dlgInfo->yBaseUnit, 8),
308 MulDiv(info.cx, dlgInfo->xBaseUnit, 4),
309 MulDiv(info.cy, dlgInfo->yBaseUnit, 8),
310 hwnd, (HMENU)info.id,
311 hInst, (LPVOID)info.data );
312 if (HIWORD(class)) HeapFree( GetProcessHeap(), 0, class );
313 if (HIWORD(caption)) HeapFree( GetProcessHeap(), 0, caption );
314 }
315 if (!hwndCtrl)
316 {
317 if (dlgTemplate->style & DS_NOFAILCREATE) continue;
318 return FALSE;
319 }
320
321 /* Send initialisation messages to the control */
322 if (dlgInfo->hUserFont) SendMessageW( hwndCtrl, WM_SETFONT,
323 (WPARAM)dlgInfo->hUserFont, 0 );
324 if (SendMessageW(hwndCtrl, WM_GETDLGCODE, 0, 0) & DLGC_DEFPUSHBUTTON)
325 {
326 /* If there's already a default push-button, set it back */
327 /* to normal and use this one instead. */
328 if (hwndDefButton)
329 SendMessageW( hwndDefButton, BM_SETSTYLE, BS_PUSHBUTTON, FALSE );
330 hwndDefButton = hwndCtrl;
331 dlgInfo->idResult = GetWindowLongPtrA( hwndCtrl, GWLP_ID );
332 }
333 }
334 TRACE(" END\n" );
335 return TRUE;
336 }
337
338
339 /***********************************************************************
340 * DIALOG_ParseTemplate32
341 *
342 * Fill a DLG_TEMPLATE structure from the dialog template, and return
343 * a pointer to the first control.
344 */
345 static LPCSTR DIALOG_ParseTemplate32( LPCSTR template, DLG_TEMPLATE * result )
346 {
347 const WORD *p = (const WORD *)template;
348 WORD signature;
349 WORD dlgver;
350
351 signature = GET_WORD(p); p++;
352 dlgver = GET_WORD(p); p++;
353
354 if (signature == 1 && dlgver == 0xffff) /* DIALOGEX resource */
355 {
356 result->dialogEx = TRUE;
357 result->helpId = GET_DWORD(p); p += 2;
358 result->exStyle = GET_DWORD(p); p += 2;
359 result->style = GET_DWORD(p); p += 2;
360 }
361 else
362 {
363 result->style = GET_DWORD(p - 2);
364 result->dialogEx = FALSE;
365 result->helpId = 0;
366 result->exStyle = GET_DWORD(p); p += 2;
367 }
368 result->nbItems = GET_WORD(p); p++;
369 result->x = GET_WORD(p); p++;
370 result->y = GET_WORD(p); p++;
371 result->cx = GET_WORD(p); p++;
372 result->cy = GET_WORD(p); p++;
373 TRACE("DIALOG%s %d, %d, %d, %d, %ld\n",
374 result->dialogEx ? "EX" : "", result->x, result->y,
375 result->cx, result->cy, result->helpId );
376 TRACE(" STYLE 0x%08lx\n", result->style );
377 TRACE(" EXSTYLE 0x%08lx\n", result->exStyle );
378
379 /* Get the menu name */
380
381 switch(GET_WORD(p))
382 {
383 case 0x0000:
384 result->menuName = NULL;
385 p++;
386 break;
387 case 0xffff:
388 result->menuName = MAKEINTRESOURCEW(GET_WORD( p + 1 ));
389 p += 2;
390 TRACE(" MENU %04x\n", LOWORD(result->menuName) );
391 break;
392 default:
393 result->menuName = (LPCWSTR)p;
394 TRACE(" MENU %s\n", debugstr_w(result->menuName) );
395 p += strlenW( result->menuName ) + 1;
396 break;
397 }
398
399 /* Get the class name */
400
401 switch(GET_WORD(p))
402 {
403 case 0x0000:
404 result->className = DIALOG_CLASS_ATOMW;
405 p++;
406 break;
407 case 0xffff:
408 result->className = MAKEINTRESOURCEW(GET_WORD( p + 1 ));
409 p += 2;
410 TRACE(" CLASS %04x\n", LOWORD(result->className) );
411 break;
412 default:
413 result->className = (LPCWSTR)p;
414 TRACE(" CLASS %s\n", debugstr_w( result->className ));
415 p += strlenW( result->className ) + 1;
416 break;
417 }
418
419 /* Get the window caption */
420
421 result->caption = (LPCWSTR)p;
422 p += strlenW( result->caption ) + 1;
423 TRACE(" CAPTION %s\n", debugstr_w( result->caption ) );
424
425 /* Get the font name */
426
427 result->pointSize = 0;
428 result->faceName = NULL;
429 result->weight = FW_DONTCARE;
430 result->italic = FALSE;
431
432 if (result->style & DS_SETFONT)
433 {
434 result->pointSize = GET_WORD(p);
435 p++;
436 if (result->dialogEx)
437 {
438 result->weight = GET_WORD(p); p++;
439 result->italic = LOBYTE(GET_WORD(p)); p++;
440 }
441 result->faceName = (LPCWSTR)p;
442 p += strlenW( result->faceName ) + 1;
443 TRACE(" FONT %d, %s, %d, %s\n",
444 result->pointSize, debugstr_w( result->faceName ),
445 result->weight, result->italic ? "TRUE" : "FALSE" );
446 }
447
448 /* First control is on dword boundary */
449 return (LPCSTR)(((UINT_PTR)p + 3) & ~3);
450 }
451
452
453 /***********************************************************************
454 * DIALOG_CreateIndirect
455 * Creates a dialog box window
456 *
457 * modal = TRUE if we are called from a modal dialog box.
458 * (it's more compatible to do it here, as under Windows the owner
459 * is never disabled if the dialog fails because of an invalid template)
460 */
461 static HWND DIALOG_CreateIndirect( HINSTANCE hInst, LPCVOID dlgTemplate,
462 HWND owner, DLGPROC dlgProc, LPARAM param,
463 BOOL unicode, BOOL modal )
464 {
465 HWND hwnd;
466 RECT rect;
467 DLG_TEMPLATE template;
468 DIALOGINFO * dlgInfo = NULL;
469 DWORD units = GetDialogBaseUnits();
470 BOOL ownerEnabled = TRUE;
471 HMENU hMenu = 0;
472 HFONT hUserFont = 0;
473 UINT flags = 0;
474 UINT xBaseUnit = LOWORD(units);
475 UINT yBaseUnit = HIWORD(units);
476
477 /* Parse dialog template */
478
479 if (!dlgTemplate) return 0;
480 dlgTemplate = DIALOG_ParseTemplate32( dlgTemplate, &template );
481
482 /* Load menu */
483
484 if (template.menuName) hMenu = LoadMenuW( hInst, template.menuName );
485
486 /* Create custom font if needed */
487
488 if (template.style & DS_SETFONT)
489 {
490 /* We convert the size to pixels and then make it -ve. This works
491 * for both +ve and -ve template.pointSize */
492 HDC dc;
493 int pixels;
494 dc = GetDC(0);
495 pixels = MulDiv(template.pointSize, GetDeviceCaps(dc , LOGPIXELSY), 72);
496 hUserFont = CreateFontW( -pixels, 0, 0, 0, template.weight,
497 template.italic, FALSE, FALSE, DEFAULT_CHARSET, 0, 0,
498 PROOF_QUALITY, FF_DONTCARE,
499 template.faceName );
500 if (hUserFont)
501 {
502 SIZE charSize;
503 HFONT hOldFont = SelectObject( dc, hUserFont );
504 charSize.cx = GdiGetCharDimensions( dc, NULL, &charSize.cy );
505 if (charSize.cx)
506 {
507 xBaseUnit = charSize.cx;
508 yBaseUnit = charSize.cy;
509 }
510 SelectObject( dc, hOldFont );
511 }
512 ReleaseDC(0, dc);
513 TRACE("units = %d,%d\n", xBaseUnit, yBaseUnit );
514 }
515
516 /* Create dialog main window */
517
518 rect.left = rect.top = 0;
519 rect.right = MulDiv(template.cx, xBaseUnit, 4);
520 rect.bottom = MulDiv(template.cy, yBaseUnit, 8);
521 if (template.style & WS_CHILD)
522 template.style &= ~(WS_CAPTION|WS_SYSMENU);
523 if (template.style & DS_MODALFRAME)
524 template.exStyle |= WS_EX_DLGMODALFRAME;
525 if (template.style & DS_CONTROL)
526 template.exStyle |= WS_EX_CONTROLPARENT;
527 AdjustWindowRectEx( &rect, template.style, (hMenu != 0), template.exStyle );
528 rect.right -= rect.left;
529 rect.bottom -= rect.top;
530
531 if (template.x == CW_USEDEFAULT16)
532 {
533 rect.left = rect.top = CW_USEDEFAULT;
534 }
535 else
536 {
537 if (template.style & DS_CENTER)
538 {
539 rect.left = (GetSystemMetrics(SM_CXSCREEN) - rect.right) / 2;
540 rect.top = (GetSystemMetrics(SM_CYSCREEN) - rect.bottom) / 2;
541 }
542 else
543 {
544 rect.left += MulDiv(template.x, xBaseUnit, 4);
545 rect.top += MulDiv(template.y, yBaseUnit, 8);
546 }
547 if ( !(template.style & WS_CHILD) )
548 {
549 INT dX, dY;
550
551 if( !(template.style & DS_ABSALIGN) )
552 ClientToScreen( owner, (POINT *)&rect );
553
554 /* try to fit it into the desktop */
555
556 if( (dX = rect.left + rect.right + GetSystemMetrics(SM_CXDLGFRAME)
557 - GetSystemMetrics(SM_CXSCREEN)) > 0 ) rect.left -= dX;
558 if( (dY = rect.top + rect.bottom + GetSystemMetrics(SM_CYDLGFRAME)
559 - GetSystemMetrics(SM_CYSCREEN)) > 0 ) rect.top -= dY;
560 if( rect.left < 0 ) rect.left = 0;
561 if( rect.top < 0 ) rect.top = 0;
562 }
563 }
564
565 if (modal)
566 {
567 ownerEnabled = DIALOG_DisableOwner( owner );
568 if (ownerEnabled) flags |= DF_OWNERENABLED;
569 }
570
571 if (unicode)
572 {
573 hwnd = CreateWindowExW(template.exStyle, template.className, template.caption,
574 template.style & ~WS_VISIBLE,
575 rect.left, rect.top, rect.right, rect.bottom,
576 owner, hMenu, hInst, NULL );
577 }
578 else
579 {
580 LPSTR class = (LPSTR)template.className;
581 LPSTR caption = (LPSTR)template.caption;
582
583 if (HIWORD(class))
584 {
585 DWORD len = WideCharToMultiByte( CP_ACP, 0, template.className, -1, NULL, 0, NULL, NULL );
586 class = HeapAlloc( GetProcessHeap(), 0, len );
587 WideCharToMultiByte( CP_ACP, 0, template.className, -1, class, len, NULL, NULL );
588 }
589 if (HIWORD(caption))
590 {
591 DWORD len = WideCharToMultiByte( CP_ACP, 0, template.caption, -1, NULL, 0, NULL, NULL );
592 caption = HeapAlloc( GetProcessHeap(), 0, len );
593 WideCharToMultiByte( CP_ACP, 0, template.caption, -1, caption, len, NULL, NULL );
594 }
595 hwnd = CreateWindowExA(template.exStyle, class, caption,
596 template.style & ~WS_VISIBLE,
597 rect.left, rect.top, rect.right, rect.bottom,
598 owner, hMenu, hInst, NULL );
599 if (HIWORD(class)) HeapFree( GetProcessHeap(), 0, class );
600 if (HIWORD(caption)) HeapFree( GetProcessHeap(), 0, caption );
601 }
602
603 if (!hwnd)
604 {
605 if (hUserFont) DeleteObject( hUserFont );
606 if (hMenu) DestroyMenu( hMenu );
607 if (modal && (flags & DF_OWNERENABLED)) DIALOG_EnableOwner(owner);
608 return 0;
609 }
610
611 /* moved this from the top of the method to here as DIALOGINFO structure
612 will be valid only after WM_CREATE message has been handled in DefDlgProc
613 All the members of the structure get filled here using temp variables */
614 dlgInfo = DIALOG_get_info( hwnd, TRUE );
615 dlgInfo->hwndFocus = 0;
616 dlgInfo->hUserFont = hUserFont;
617 dlgInfo->hMenu = hMenu;
618 dlgInfo->xBaseUnit = xBaseUnit;
619 dlgInfo->yBaseUnit = yBaseUnit;
620 dlgInfo->idResult = 0;
621 dlgInfo->flags = flags;
622 dlgInfo->hDialogHeap = 0;
623
624 if (template.helpId) SetWindowContextHelpId( hwnd, template.helpId );
625
626 if (unicode) SetWindowLongPtrW( hwnd, DWLP_DLGPROC, (ULONG_PTR)dlgProc );
627 else SetWindowLongPtrA( hwnd, DWLP_DLGPROC, (ULONG_PTR)dlgProc );
628
629 if (dlgInfo->hUserFont)
630 SendMessageW( hwnd, WM_SETFONT, (WPARAM)dlgInfo->hUserFont, 0 );
631
632 /* Create controls */
633
634 if (DIALOG_CreateControls32( hwnd, dlgTemplate, &template, hInst, unicode ))
635 {
636 /* Send initialisation messages and set focus */
637
638 if (SendMessageW( hwnd, WM_INITDIALOG, (WPARAM)dlgInfo->hwndFocus, param ) &&
639 ((~template.style & DS_CONTROL) || (template.style & WS_VISIBLE)))
640 {
641 /* By returning TRUE, app has requested a default focus assignment */
642 dlgInfo->hwndFocus = GetNextDlgTabItem( hwnd, 0, FALSE);
643 if( dlgInfo->hwndFocus )
644 SetFocus( dlgInfo->hwndFocus );
645 }
646
647 if (template.style & WS_VISIBLE && !(GetWindowLongW( hwnd, GWL_STYLE ) & WS_VISIBLE))
648 {
649 ShowWindow( hwnd, SW_SHOWNORMAL ); /* SW_SHOW doesn't always work */
650 }
651 return hwnd;
652 }
653 if (modal && ownerEnabled) DIALOG_EnableOwner(owner);
654 if( IsWindow(hwnd) ) DestroyWindow( hwnd );
655 return 0;
656 }
657
658
659 /***********************************************************************
660 * CreateDialogParamA (USER32.@)
661 */
662 HWND WINAPI CreateDialogParamA( HINSTANCE hInst, LPCSTR name, HWND owner,
663 DLGPROC dlgProc, LPARAM param )
664 {
665 HRSRC hrsrc;
666 LPCDLGTEMPLATEA ptr;
667
668 if (!(hrsrc = FindResourceA( hInst, name, (LPSTR)RT_DIALOG ))) return 0;
669 if (!(ptr = (LPCDLGTEMPLATEA)LoadResource(hInst, hrsrc))) return 0;
670 return CreateDialogIndirectParamA( hInst, ptr, owner, dlgProc, param );
671 }
672
673
674 /***********************************************************************
675 * CreateDialogParamW (USER32.@)
676 */
677 HWND WINAPI CreateDialogParamW( HINSTANCE hInst, LPCWSTR name, HWND owner,
678 DLGPROC dlgProc, LPARAM param )
679 {
680 HRSRC hrsrc;
681 LPCDLGTEMPLATEA ptr;
682
683 if (!(hrsrc = FindResourceW( hInst, name, (LPWSTR)RT_DIALOG ))) return 0;
684 if (!(ptr = (LPCDLGTEMPLATEW)LoadResource(hInst, hrsrc))) return 0;
685 return CreateDialogIndirectParamW( hInst, ptr, owner, dlgProc, param );
686 }
687
688
689 /***********************************************************************
690 * CreateDialogIndirectParamAorW (USER32.@)
691 */
692 HWND WINAPI CreateDialogIndirectParamAorW( HINSTANCE hInst, LPCVOID dlgTemplate,
693 HWND owner, DLGPROC dlgProc, LPARAM param,
694 DWORD flags )
695 {
696 return DIALOG_CreateIndirect( hInst, dlgTemplate, owner, dlgProc, param, !flags, FALSE );
697 }
698
699 /***********************************************************************
700 * CreateDialogIndirectParamA (USER32.@)
701 */
702 HWND WINAPI CreateDialogIndirectParamA( HINSTANCE hInst, LPCDLGTEMPLATEA dlgTemplate,
703 HWND owner, DLGPROC dlgProc, LPARAM param )
704 {
705 return CreateDialogIndirectParamAorW( hInst, dlgTemplate, owner, dlgProc, param, 2 );
706 }
707
708 /***********************************************************************
709 * CreateDialogIndirectParamW (USER32.@)
710 */
711 HWND WINAPI CreateDialogIndirectParamW( HINSTANCE hInst, LPCDLGTEMPLATEW dlgTemplate,
712 HWND owner, DLGPROC dlgProc, LPARAM param )
713 {
714 return CreateDialogIndirectParamAorW( hInst, dlgTemplate, owner, dlgProc, param, 0 );
715 }
716
717
718 /***********************************************************************
719 * DIALOG_DoDialogBox
720 */
721 INT DIALOG_DoDialogBox( HWND hwnd, HWND owner )
722 {
723 DIALOGINFO * dlgInfo;
724 MSG msg;
725 INT retval;
726 HWND ownerMsg = GetAncestor( owner, GA_ROOT );
727 BOOL bFirstEmpty;
728
729 if (!(dlgInfo = DIALOG_get_info( hwnd, FALSE ))) return -1;
730
731 bFirstEmpty = TRUE;
732 if (!(dlgInfo->flags & DF_END)) /* was EndDialog called in WM_INITDIALOG ? */
733 {
734 for (;;)
735 {
736 if (!PeekMessageW( &msg, 0, 0, 0, PM_REMOVE ))
737 {
738 if (bFirstEmpty)
739 {
740 /* ShowWindow the first time the queue goes empty */
741 ShowWindow( hwnd, SW_SHOWNORMAL );
742 bFirstEmpty = FALSE;
743 }
744 if (!(GetWindowLongW( hwnd, GWL_STYLE ) & DS_NOIDLEMSG))
745 {
746 /* No message present -> send ENTERIDLE and wait */
747 SendMessageW( ownerMsg, WM_ENTERIDLE, MSGF_DIALOGBOX, (LPARAM)hwnd );
748 }
749 if (!GetMessageW( &msg, 0, 0, 0 )) break;
750 }
751
752 if (!IsWindow( hwnd )) return -1;
753 if (!(dlgInfo->flags & DF_END) && !IsDialogMessageW( hwnd, &msg))
754 {
755 TranslateMessage( &msg );
756 DispatchMessageW( &msg );
757 }
758 if (dlgInfo->flags & DF_END) break;
759 }
760 }
761 if (dlgInfo->flags & DF_OWNERENABLED) DIALOG_EnableOwner( owner );
762 retval = dlgInfo->idResult;
763 DestroyWindow( hwnd );
764 return retval;
765 }
766
767
768 /***********************************************************************
769 * DialogBoxParamA (USER32.@)
770 */
771 INT_PTR WINAPI DialogBoxParamA( HINSTANCE hInst, LPCSTR name,
772 HWND owner, DLGPROC dlgProc, LPARAM param )
773 {
774 HWND hwnd;
775 HRSRC hrsrc;
776 LPCDLGTEMPLATEA ptr;
777
778 if (!(hrsrc = FindResourceA( hInst, name, (LPSTR)RT_DIALOG ))) return 0;
779 if (!(ptr = (LPCDLGTEMPLATEA)LoadResource(hInst, hrsrc))) return 0;
780 hwnd = DIALOG_CreateIndirect( hInst, ptr, owner, dlgProc, param, FALSE, TRUE );
781 if (hwnd) return DIALOG_DoDialogBox( hwnd, owner );
782 return -1;
783 }
784
785
786 /***********************************************************************
787 * DialogBoxParamW (USER32.@)
788 */
789 INT_PTR WINAPI DialogBoxParamW( HINSTANCE hInst, LPCWSTR name,
790 HWND owner, DLGPROC dlgProc, LPARAM param )
791 {
792 HWND hwnd;
793 HRSRC hrsrc;
794 LPCDLGTEMPLATEW ptr;
795
796 if (!(hrsrc = FindResourceW( hInst, name, (LPWSTR)RT_DIALOG ))) return 0;
797 if (!(ptr = (LPCDLGTEMPLATEW)LoadResource(hInst, hrsrc))) return 0;
798 hwnd = DIALOG_CreateIndirect( hInst, ptr, owner, dlgProc, param, TRUE, TRUE );
799 if (hwnd) return DIALOG_DoDialogBox( hwnd, owner );
800 return -1;
801 }
802
803
804 /***********************************************************************
805 * DialogBoxIndirectParamAorW (USER32.@)
806 */
807 INT_PTR WINAPI DialogBoxIndirectParamAorW( HINSTANCE hInstance, LPCVOID template,
808 HWND owner, DLGPROC dlgProc,
809 LPARAM param, DWORD flags )
810 {
811 HWND hwnd = DIALOG_CreateIndirect( hInstance, template, owner, dlgProc, param, !flags, TRUE );
812 if (hwnd) return DIALOG_DoDialogBox( hwnd, owner );
813 return -1;
814 }
815
816 /***********************************************************************
817 * DialogBoxIndirectParamA (USER32.@)
818 */
819 INT_PTR WINAPI DialogBoxIndirectParamA(HINSTANCE hInstance, LPCDLGTEMPLATEA template,
820 HWND owner, DLGPROC dlgProc, LPARAM param )
821 {
822 return DialogBoxIndirectParamAorW( hInstance, template, owner, dlgProc, param, 2 );
823 }
824
825
826 /***********************************************************************
827 * DialogBoxIndirectParamW (USER32.@)
828 */
829 INT_PTR WINAPI DialogBoxIndirectParamW(HINSTANCE hInstance, LPCDLGTEMPLATEW template,
830 HWND owner, DLGPROC dlgProc, LPARAM param )
831 {
832 return DialogBoxIndirectParamAorW( hInstance, template, owner, dlgProc, param, 0 );
833 }
834
835 /***********************************************************************
836 * EndDialog (USER32.@)
837 */
838 BOOL WINAPI EndDialog( HWND hwnd, INT_PTR retval )
839 {
840 BOOL wasEnabled = TRUE;
841 DIALOGINFO * dlgInfo;
842 HWND owner;
843
844 TRACE("%p %d\n", hwnd, retval );
845
846 if (!(dlgInfo = DIALOG_get_info( hwnd, FALSE )))
847 {
848 ERR("got invalid window handle (%p); buggy app !?\n", hwnd);
849 return FALSE;
850 }
851 dlgInfo->idResult = retval;
852 dlgInfo->flags |= DF_END;
853 wasEnabled = (dlgInfo->flags & DF_OWNERENABLED);
854
855 if (wasEnabled && (owner = GetWindow( hwnd, GW_OWNER )))
856 DIALOG_EnableOwner( owner );
857
858 /* Windows sets the focus to the dialog itself in EndDialog */
859
860 if (IsChild(hwnd, GetFocus()))
861 SetFocus( hwnd );
862
863 /* Don't have to send a ShowWindow(SW_HIDE), just do
864 SetWindowPos with SWP_HIDEWINDOW as done in Windows */
865
866 SetWindowPos(hwnd, NULL, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE
867 | SWP_NOZORDER | SWP_NOACTIVATE | SWP_HIDEWINDOW);
868
869 if (hwnd == GetActiveWindow()) WINPOS_ActivateOtherWindow( hwnd );
870
871 /* unblock dialog loop */
872 PostMessageA(hwnd, WM_NULL, 0, 0);
873 return TRUE;
874 }
875
876
877 /***********************************************************************
878 * DIALOG_IsAccelerator
879 */
880 static BOOL DIALOG_IsAccelerator( HWND hwnd, HWND hwndDlg, WPARAM wParam )
881 {
882 HWND hwndControl = hwnd;
883 HWND hwndNext;
884 INT dlgCode;
885 WCHAR buffer[128];
886
887 do
888 {
889 DWORD style = GetWindowLongW( hwndControl, GWL_STYLE );
890 if ((style & (WS_VISIBLE | WS_DISABLED)) == WS_VISIBLE)
891 {
892 dlgCode = SendMessageW( hwndControl, WM_GETDLGCODE, 0, 0 );
893 if ( (dlgCode & (DLGC_BUTTON | DLGC_STATIC)) &&
894 GetWindowTextW( hwndControl, buffer, sizeof(buffer)/sizeof(WCHAR) ))
895 {
896 /* find the accelerator key */
897 LPWSTR p = buffer - 2;
898
899 do
900 {
901 p = strchrW( p + 2, '&' );
902 }
903 while (p != NULL && p[1] == '&');
904
905 /* and check if it's the one we're looking for */
906 if (p != NULL && toupperW( p[1] ) == toupperW( wParam ) )
907 {
908 if ((dlgCode & DLGC_STATIC) || (style & 0x0f) == BS_GROUPBOX )
909 {
910 /* set focus to the control */
911 SendMessageW( hwndDlg, WM_NEXTDLGCTL, (WPARAM)hwndControl, 1);
912 /* and bump it on to next */
913 SendMessageW( hwndDlg, WM_NEXTDLGCTL, 0, 0);
914 }
915 else if (dlgCode & DLGC_BUTTON)
916 {
917 /* send BM_CLICK message to the control */
918 SendMessageW( hwndControl, BM_CLICK, 0, 0 );
919 }
920 return TRUE;
921 }
922 }
923 hwndNext = GetWindow( hwndControl, GW_CHILD );
924 }
925 else hwndNext = 0;
926
927 if (!hwndNext) hwndNext = GetWindow( hwndControl, GW_HWNDNEXT );
928
929 while (!hwndNext && hwndControl)
930 {
931 hwndControl = GetParent( hwndControl );
932 if (hwndControl == hwndDlg)
933 {
934 if(hwnd==hwndDlg) /* prevent endless loop */
935 {
936 hwndNext=hwnd;
937 break;
938 }
939 hwndNext = GetWindow( hwndDlg, GW_CHILD );
940 }
941 else
942 hwndNext = GetWindow( hwndControl, GW_HWNDNEXT );
943 }
944 hwndControl = hwndNext;
945 }
946 while (hwndControl && (hwndControl != hwnd));
947
948 return FALSE;
949 }
950
951 /***********************************************************************
952 * DIALOG_FindMsgDestination
953 *
954 * The messages that IsDialogMessage sends may not go to the dialog
955 * calling IsDialogMessage if that dialog is a child, and it has the
956 * DS_CONTROL style set.
957 * We propagate up until we hit one that does not have DS_CONTROL, or
958 * whose parent is not a dialog.
959 *
960 * This is undocumented behaviour.
961 */
962 static HWND DIALOG_FindMsgDestination( HWND hwndDlg )
963 {
964 while (GetWindowLongA(hwndDlg, GWL_STYLE) & DS_CONTROL)
965 {
966 WND *pParent;
967 HWND hParent = GetParent(hwndDlg);
968 if (!hParent) break;
969
970 pParent = WIN_GetPtr(hParent);
971 if (!pParent || pParent == WND_OTHER_PROCESS || pParent == WND_DESKTOP) break;
972
973 if (!(pParent->flags & WIN_ISDIALOG))
974 {
975 WIN_ReleasePtr(pParent);
976 break;
977 }
978 WIN_ReleasePtr(pParent);
979
980 hwndDlg = hParent;
981 }
982
983 return hwndDlg;
984 }
985
986 /***********************************************************************
987 * DIALOG_FixOneChildOnChangeFocus
988 *
989 * Callback helper for DIALOG_FixChildrenOnChangeFocus
990 */
991
992 static BOOL CALLBACK DIALOG_FixOneChildOnChangeFocus (HWND hwndChild,
993 LPARAM lParam)
994 {
995 /* If a default pushbutton then no longer default */
996 if (DLGC_DEFPUSHBUTTON & SendMessageW (hwndChild, WM_GETDLGCODE, 0, 0))
997 SendMessageW (hwndChild, BM_SETSTYLE, BS_PUSHBUTTON, TRUE);
998 return TRUE;
999 }
1000
1001 /***********************************************************************
1002 * DIALOG_FixChildrenOnChangeFocus
1003 *
1004 * Following the change of focus that occurs for example after handling
1005 * a WM_KEYDOWN VK_TAB in IsDialogMessage, some tidying of the dialog's
1006 * children may be required.
1007 */
1008 static void DIALOG_FixChildrenOnChangeFocus (HWND hwndDlg, HWND hwndNext)
1009 {
1010 INT dlgcode_next = SendMessageW (hwndNext, WM_GETDLGCODE, 0, 0);
1011 /* INT dlgcode_dlg = SendMessageW (hwndDlg, WM_GETDLGCODE, 0, 0); */
1012 /* Windows does ask for this. I don't know why yet */
1013
1014 EnumChildWindows (hwndDlg, DIALOG_FixOneChildOnChangeFocus, 0);
1015
1016 /* If the button that is getting the focus WAS flagged as the default
1017 * pushbutton then ask the dialog what it thinks the default is and
1018 * set that in the default style.
1019 */
1020 if (dlgcode_next & DLGC_DEFPUSHBUTTON)
1021 {
1022 DWORD def_id = SendMessageW (hwndDlg, DM_GETDEFID, 0, 0);
1023 if (HIWORD(def_id) == DC_HASDEFID)
1024 {
1025 HWND hwndDef;
1026 def_id = LOWORD(def_id);
1027 hwndDef = GetDlgItem (hwndDlg, def_id);
1028 if (hwndDef)
1029 {
1030 INT dlgcode_def = SendMessageW (hwndDef, WM_GETDLGCODE, 0, 0);
1031 /* I know that if it is a button then it should already be a
1032 * UNDEFPUSHBUTTON, since we have just told the buttons to
1033 * change style. But maybe they ignored our request
1034 */
1035 if ((dlgcode_def & DLGC_BUTTON) &&
1036 (dlgcode_def & DLGC_UNDEFPUSHBUTTON))
1037 {
1038 SendMessageW (hwndDef, BM_SETSTYLE, BS_DEFPUSHBUTTON, TRUE);
1039 }
1040 }
1041 }
1042 }
1043 else if ((dlgcode_next & DLGC_BUTTON) && (dlgcode_next & DLGC_UNDEFPUSHBUTTON))
1044 {
1045 SendMessageW (hwndNext, BM_SETSTYLE, BS_DEFPUSHBUTTON, TRUE);
1046 /* I wonder why it doesn't send a DM_SETDEFID */
1047 }
1048 }
1049
1050 /***********************************************************************
1051 * IsDialogMessageW (USER32.@)
1052 */
1053 BOOL WINAPI IsDialogMessageW( HWND hwndDlg, LPMSG msg )
1054 {
1055 INT dlgCode = 0;
1056
1057 if (CallMsgFilterW( msg, MSGF_DIALOGBOX )) return TRUE;
1058
1059 hwndDlg = WIN_GetFullHandle( hwndDlg );
1060 if (hwndDlg == GetDesktopWindow()) return FALSE;
1061 if ((hwndDlg != msg->hwnd) && !IsChild( hwndDlg, msg->hwnd )) return FALSE;
1062
1063 hwndDlg = DIALOG_FindMsgDestination(hwndDlg);
1064
1065 switch(msg->message)
1066 {
1067 case WM_KEYDOWN:
1068 dlgCode = SendMessageW( msg->hwnd, WM_GETDLGCODE, msg->wParam, (LPARAM)msg );
1069 if (dlgCode & DLGC_WANTMESSAGE) break;
1070
1071 switch(msg->wParam)
1072 {
1073 case VK_TAB:
1074 if (!(dlgCode & DLGC_WANTTAB))
1075 {
1076 BOOL fIsDialog = TRUE;
1077 WND *pWnd = WIN_GetPtr( hwndDlg );
1078
1079 if (pWnd && pWnd != WND_OTHER_PROCESS)
1080 {
1081 fIsDialog = (pWnd->flags & WIN_ISDIALOG) != 0;
1082 WIN_ReleasePtr(pWnd);
1083 }
1084
1085 /* I am not sure under which circumstances the TAB is handled
1086 * each way. All I do know is that it does not always simply
1087 * send WM_NEXTDLGCTL. (Personally I have never yet seen it
1088 * do so but I presume someone has)
1089 */
1090 if (fIsDialog)
1091 SendMessageW( hwndDlg, WM_NEXTDLGCTL, (GetKeyState(VK_SHIFT) & 0x8000), 0 );
1092 else
1093 {
1094 /* It would appear that GetNextDlgTabItem can handle being
1095 * passed hwndDlg rather than NULL but that is undocumented
1096 * so let's do it properly
1097 */
1098 HWND hwndFocus = GetFocus();
1099 HWND hwndNext = GetNextDlgTabItem (hwndDlg,
1100 hwndFocus == hwndDlg ? NULL : hwndFocus,
1101 GetKeyState (VK_SHIFT) & 0x8000);
1102 if (hwndNext)
1103 {
1104 dlgCode = SendMessageW (hwndNext, WM_GETDLGCODE,
1105 msg->wParam, (LPARAM)msg);
1106 if (dlgCode & DLGC_HASSETSEL)
1107 {
1108 INT maxlen = 1 + SendMessageW (hwndNext, WM_GETTEXTLENGTH, 0, 0);
1109 WCHAR *buffer = HeapAlloc (GetProcessHeap(), 0, maxlen * sizeof(WCHAR));
1110 if (buffer)
1111 {
1112 INT length;
1113 SendMessageW (hwndNext, WM_GETTEXT, maxlen, (LPARAM) buffer);
1114 length = strlenW (buffer);
1115 HeapFree (GetProcessHeap(), 0, buffer);
1116 SendMessageW (hwndNext, EM_SETSEL, 0, length);
1117 }
1118 }
1119 SetFocus (hwndNext);
1120 DIALOG_FixChildrenOnChangeFocus (hwndDlg, hwndNext);
1121 }
1122 else
1123 return FALSE;
1124 }
1125 return TRUE;
1126 }
1127 break;
1128
1129 case VK_RIGHT:
1130 case VK_DOWN:
1131 case VK_LEFT:
1132 case VK_UP:
1133 if (!(dlgCode & DLGC_WANTARROWS))
1134 {
1135 BOOL fPrevious = (msg->wParam == VK_LEFT || msg->wParam == VK_UP);
1136 HWND hwndNext = GetNextDlgGroupItem (hwndDlg, GetFocus(), fPrevious );
1137 SendMessageW( hwndDlg, WM_NEXTDLGCTL, (WPARAM)hwndNext, 1 );
1138 return TRUE;
1139 }
1140 break;
1141
1142 case VK_CANCEL:
1143 case VK_ESCAPE:
1144 SendMessageW( hwndDlg, WM_COMMAND, IDCANCEL, (LPARAM)GetDlgItem( hwndDlg, IDCANCEL ) );
1145 return TRUE;
1146
1147 case VK_EXECUTE:
1148 case VK_RETURN:
1149 {
1150 DWORD dw;
1151 if ((GetFocus() == msg->hwnd) &&
1152 (SendMessageW (msg->hwnd, WM_GETDLGCODE, 0, 0) & DLGC_DEFPUSHBUTTON))
1153 {
1154 SendMessageW (hwndDlg, WM_COMMAND, MAKEWPARAM (GetDlgCtrlID(msg->hwnd),BN_CLICKED), (LPARAM)msg->hwnd);
1155 }
1156 else if (DC_HASDEFID == HIWORD(dw = SendMessageW (hwndDlg, DM_GETDEFID, 0, 0)))
1157 {
1158 SendMessageW( hwndDlg, WM_COMMAND, MAKEWPARAM( LOWORD(dw), BN_CLICKED ),
1159 (LPARAM)GetDlgItem(hwndDlg, LOWORD(dw)));
1160 }
1161 else
1162 {
1163 SendMessageW( hwndDlg, WM_COMMAND, IDOK, (LPARAM)GetDlgItem( hwndDlg, IDOK ) );
1164
1165 }
1166 }
1167 return TRUE;
1168 }
1169 break;
1170
1171 case WM_CHAR:
1172 /* FIXME Under what circumstances does WM_GETDLGCODE get sent?
1173 * It does NOT get sent in the test program I have
1174 */
1175 dlgCode = SendMessageW( msg->hwnd, WM_GETDLGCODE, msg->wParam, (LPARAM)msg );
1176 if (dlgCode & (DLGC_WANTCHARS|DLGC_WANTMESSAGE)) break;
1177 if (msg->wParam == '\t' && (dlgCode & DLGC_WANTTAB)) break;
1178 /* drop through */
1179
1180 case WM_SYSCHAR:
1181 if (DIALOG_IsAccelerator( WIN_GetFullHandle(msg->hwnd), hwndDlg, msg->wParam ))
1182 {
1183 /* don't translate or dispatch */
1184 return TRUE;
1185 }
1186 break;
1187 }
1188
1189 TranslateMessage( msg );
1190 DispatchMessageW( msg );
1191 return TRUE;
1192 }
1193
1194
1195 /***********************************************************************
1196 * GetDlgCtrlID (USER32.@)
1197 */
1198 INT WINAPI GetDlgCtrlID( HWND hwnd )
1199 {
1200 return GetWindowLongPtrW( hwnd, GWLP_ID );
1201 }
1202
1203
1204 /***********************************************************************
1205 * GetDlgItem (USER32.@)
1206 */
1207 HWND WINAPI GetDlgItem( HWND hwndDlg, INT id )
1208 {
1209 int i;
1210 HWND *list = WIN_ListChildren( hwndDlg );
1211 HWND ret = 0;
1212
1213 if (!list) return 0;
1214
1215 for (i = 0; list[i]; i++) if (GetWindowLongPtrW( list[i], GWLP_ID ) == id) break;
1216 ret = list[i];
1217 HeapFree( GetProcessHeap(), 0, list );
1218 return ret;
1219 }
1220
1221
1222 /*******************************************************************
1223 * SendDlgItemMessageA (USER32.@)
1224 */
1225 LRESULT WINAPI SendDlgItemMessageA( HWND hwnd, INT id, UINT msg,
1226 WPARAM wParam, LPARAM lParam )
1227 {
1228 HWND hwndCtrl = GetDlgItem( hwnd, id );
1229 if (hwndCtrl) return SendMessageA( hwndCtrl, msg, wParam, lParam );
1230 else return 0;
1231 }
1232
1233
1234 /*******************************************************************
1235 * SendDlgItemMessageW (USER32.@)
1236 */
1237 LRESULT WINAPI SendDlgItemMessageW( HWND hwnd, INT id, UINT msg,
1238 WPARAM wParam, LPARAM lParam )
1239 {
1240 HWND hwndCtrl = GetDlgItem( hwnd, id );
1241 if (hwndCtrl) return SendMessageW( hwndCtrl, msg, wParam, lParam );
1242 else return 0;
1243 }
1244
1245
1246 /*******************************************************************
1247 * SetDlgItemTextA (USER32.@)
1248 */
1249 BOOL WINAPI SetDlgItemTextA( HWND hwnd, INT id, LPCSTR lpString )
1250 {
1251 return SendDlgItemMessageA( hwnd, id, WM_SETTEXT, 0, (LPARAM)lpString );
1252 }
1253
1254
1255 /*******************************************************************
1256 * SetDlgItemTextW (USER32.@)
1257 */
1258 BOOL WINAPI SetDlgItemTextW( HWND hwnd, INT id, LPCWSTR lpString )
1259 {
1260 return SendDlgItemMessageW( hwnd, id, WM_SETTEXT, 0, (LPARAM)lpString );
1261 }
1262
1263
1264 /***********************************************************************
1265 * GetDlgItemTextA (USER32.@)
1266 */
1267 INT WINAPI GetDlgItemTextA( HWND hwnd, INT id, LPSTR str, UINT len )
1268 {
1269 if (str && (len > 0)) str[0] = '\0';
1270 return (INT)SendDlgItemMessageA( hwnd, id, WM_GETTEXT,
1271 len, (LPARAM)str );
1272 }
1273
1274
1275 /***********************************************************************
1276 * GetDlgItemTextW (USER32.@)
1277 */
1278 INT WINAPI GetDlgItemTextW( HWND hwnd, INT id, LPWSTR str, UINT len )
1279 {
1280 if (str && (len > 0)) str[0] = '\0';
1281 return (INT)SendDlgItemMessageW( hwnd, id, WM_GETTEXT,
1282 len, (LPARAM)str );
1283 }
1284
1285
1286 /*******************************************************************
1287 * SetDlgItemInt (USER32.@)
1288 */
1289 BOOL WINAPI SetDlgItemInt( HWND hwnd, INT id, UINT value,
1290 BOOL fSigned )
1291 {
1292 char str[20];
1293
1294 if (fSigned) sprintf( str, "%d", (INT)value );
1295 else sprintf( str, "%u", value );
1296 SendDlgItemMessageA( hwnd, id, WM_SETTEXT, 0, (LPARAM)str );
1297 return TRUE;
1298 }
1299
1300
1301 /***********************************************************************
1302 * GetDlgItemInt (USER32.@)
1303 */
1304 UINT WINAPI GetDlgItemInt( HWND hwnd, INT id, BOOL *translated,
1305 BOOL fSigned )
1306 {
1307 char str[30];
1308 char * endptr;
1309 long result = 0;
1310
1311 if (translated) *translated = FALSE;
1312 if (!SendDlgItemMessageA(hwnd, id, WM_GETTEXT, sizeof(str), (LPARAM)str))
1313 return 0;
1314 if (fSigned)
1315 {
1316 result = strtol( str, &endptr, 10 );
1317 if (!endptr || (endptr == str)) /* Conversion was unsuccessful */
1318 return 0;
1319 if (((result == LONG_MIN) || (result == LONG_MAX)) && (errno==ERANGE))
1320 return 0;
1321 }
1322 else
1323 {
1324 result = strtoul( str, &endptr, 10 );
1325 if (!endptr || (endptr == str)) /* Conversion was unsuccessful */
1326 return 0;
1327 if ((result == ULONG_MAX) && (errno == ERANGE)) return 0;
1328 }
1329 if (translated) *translated = TRUE;
1330 return (UINT)result;
1331 }
1332
1333
1334 /***********************************************************************
1335 * CheckDlgButton (USER32.@)
1336 */
1337 BOOL WINAPI CheckDlgButton( HWND hwnd, INT id, UINT check )
1338 {
1339 SendDlgItemMessageW( hwnd, id, BM_SETCHECK, check, 0 );
1340 return TRUE;
1341 }
1342
1343
1344 /***********************************************************************
1345 * IsDlgButtonChecked (USER32.@)
1346 */
1347 UINT WINAPI IsDlgButtonChecked( HWND hwnd, UINT id )
1348 {
1349 return (UINT)SendDlgItemMessageW( hwnd, id, BM_GETCHECK, 0, 0 );
1350 }
1351
1352
1353 /***********************************************************************
1354 * CheckRB
1355 *
1356 * Callback function used to check/uncheck radio buttons that fall
1357 * within a specific range of IDs.
1358 */
1359 static BOOL CALLBACK CheckRB(HWND hwndChild, LPARAM lParam)
1360 {
1361 LONG lChildID = GetWindowLongPtrW(hwndChild, GWLP_ID);
1362 RADIOGROUP *lpRadioGroup = (RADIOGROUP *) lParam;
1363
1364 if ((lChildID >= lpRadioGroup->firstID) &&
1365 (lChildID <= lpRadioGroup->lastID))
1366 {
1367 if (lChildID == lpRadioGroup->checkID)
1368 {
1369 SendMessageW(hwndChild, BM_SETCHECK, BST_CHECKED, 0);
1370 }
1371 else
1372 {
1373 SendMessageW(hwndChild, BM_SETCHECK, BST_UNCHECKED, 0);
1374 }
1375 }
1376
1377 return TRUE;
1378 }
1379
1380
1381 /***********************************************************************
1382 * CheckRadioButton (USER32.@)
1383 */
1384 BOOL WINAPI CheckRadioButton( HWND hwndDlg, UINT firstID,
1385 UINT lastID, UINT checkID )
1386 {
1387 RADIOGROUP radioGroup;
1388
1389 radioGroup.firstID = firstID;
1390 radioGroup.lastID = lastID;
1391 radioGroup.checkID = checkID;
1392
1393 return EnumChildWindows(hwndDlg, (WNDENUMPROC)CheckRB,
1394 (LPARAM)&radioGroup);
1395 }
1396
1397
1398 /***********************************************************************
1399 * GetDialogBaseUnits (USER.243)
1400 * GetDialogBaseUnits (USER32.@)
1401 */
1402 DWORD WINAPI GetDialogBaseUnits(void)
1403 {
1404 static DWORD units;
1405
1406 if (!units)
1407 {
1408 HDC hdc;
1409 SIZE size;
1410
1411 if ((hdc = GetDC(0)))
1412 {
1413 size.cx = GdiGetCharDimensions( hdc, NULL, &size.cy );
1414 if (size.cx) units = MAKELONG( size.cx, size.cy );
1415 ReleaseDC( 0, hdc );
1416 }
1417 TRACE("base units = %d,%d\n", LOWORD(units), HIWORD(units) );
1418 }
1419 return units;
1420 }
1421
1422
1423 /***********************************************************************
1424 * MapDialogRect (USER32.@)
1425 */
1426 BOOL WINAPI MapDialogRect( HWND hwnd, LPRECT rect )
1427 {
1428 DIALOGINFO * dlgInfo;
1429 if (!(dlgInfo = DIALOG_get_info( hwnd, FALSE ))) return FALSE;
1430 rect->left = MulDiv(rect->left, dlgInfo->xBaseUnit, 4);
1431 rect->right = MulDiv(rect->right, dlgInfo->xBaseUnit, 4);
1432 rect->top = MulDiv(rect->top, dlgInfo->yBaseUnit, 8);
1433 rect->bottom = MulDiv(rect->bottom, dlgInfo->yBaseUnit, 8);
1434 return TRUE;
1435 }
1436
1437
1438 /***********************************************************************
1439 * GetNextDlgGroupItem (USER32.@)
1440 *
1441 * Corrections to MSDN documentation
1442 *
1443 * (Under Windows 2000 at least, where hwndDlg is not actually a dialog)
1444 * 1. hwndCtrl can be hwndDlg in which case it behaves as for NULL
1445 * 2. Prev of NULL or hwndDlg fails
1446 */
1447 HWND WINAPI GetNextDlgGroupItem( HWND hwndDlg, HWND hwndCtrl, BOOL fPrevious )
1448 {
1449 HWND hwnd, hwndNext, retvalue, hwndLastGroup = 0;
1450 BOOL fLooped=FALSE;
1451 BOOL fSkipping=FALSE;
1452
1453 hwndDlg = WIN_GetFullHandle( hwndDlg );
1454 hwndCtrl = WIN_GetFullHandle( hwndCtrl );
1455
1456 if (hwndDlg == hwndCtrl) hwndCtrl = NULL;
1457 if (!hwndCtrl && fPrevious) return 0;
1458
1459 if (hwndCtrl)
1460 {
1461 if (!IsChild (hwndDlg, hwndCtrl)) return 0;
1462 }
1463 else
1464 {
1465 /* No ctrl specified -> start from the beginning */
1466 if (!(hwndCtrl = GetWindow( hwndDlg, GW_CHILD ))) return 0;
1467 /* MSDN is wrong. fPrevious does not result in the last child */
1468
1469 /* Maybe that first one is valid. If so then we don't want to skip it*/
1470 if ((GetWindowLongW( hwndCtrl, GWL_STYLE ) & (WS_VISIBLE|WS_DISABLED)) == WS_VISIBLE)
1471 {
1472 return hwndCtrl;
1473 }
1474 }
1475
1476 /* Always go forward around the group and list of controls; for the
1477 * previous control keep track; for the next break when you find one
1478 */
1479 retvalue = hwndCtrl;
1480 hwnd = hwndCtrl;
1481 while (hwndNext = GetWindow (hwnd, GW_HWNDNEXT),
1482 1)
1483 {
1484 while (!hwndNext)
1485 {
1486 /* Climb out until there is a next sibling of the ancestor or we
1487 * reach the top (in which case we loop back to the start)
1488 */
1489 if (hwndDlg == GetParent (hwnd))
1490 {
1491 /* Wrap around to the beginning of the list, within the same
1492 * group. (Once only)
1493 */
1494 if (fLooped) goto end;
1495 fLooped = TRUE;
1496 hwndNext = GetWindow (hwndDlg, GW_CHILD);
1497 }
1498 else
1499 {
1500 hwnd = GetParent (hwnd);
1501 hwndNext = GetWindow (hwnd, GW_HWNDNEXT);
1502 }
1503 }
1504 hwnd = hwndNext;
1505
1506 /* Wander down the leading edge of controlparents */
1507 while ( (GetWindowLongW (hwnd, GWL_EXSTYLE) & WS_EX_CONTROLPARENT) &&
1508 ((GetWindowLongW (hwnd, GWL_STYLE) & (WS_VISIBLE | WS_DISABLED)) == WS_VISIBLE) &&
1509 (hwndNext = GetWindow (hwnd, GW_CHILD)))
1510 hwnd = hwndNext;
1511 /* Question. If the control is a control parent but either has no
1512 * children or is not visible/enabled then if it has a WS_GROUP does
1513 * it count? For that matter does it count anyway?
1514 * I believe it doesn't count.
1515 */
1516
1517 if ((GetWindowLongW (hwnd, GWL_STYLE) & WS_GROUP))
1518 {
1519 hwndLastGroup = hwnd;
1520 if (!fSkipping)
1521 {
1522 /* Look for the beginning of the group */
1523 fSkipping = TRUE;
1524 }
1525 }
1526
1527 if (hwnd == hwndCtrl)
1528 {
1529 if (!fSkipping) break;
1530 if (hwndLastGroup == hwnd) break;
1531 hwnd = hwndLastGroup;
1532 fSkipping = FALSE;
1533 fLooped = FALSE;
1534 }
1535
1536 if (!fSkipping &&
1537 (GetWindowLongW (hwnd, GWL_STYLE) & (WS_VISIBLE|WS_DISABLED)) ==
1538 WS_VISIBLE)
1539 {
1540 retvalue = hwnd;
1541 if (!fPrevious) break;
1542 }
1543 }
1544 end:
1545 return retvalue;
1546 }
1547
1548
1549 /***********************************************************************
1550 * DIALOG_GetNextTabItem
1551 *
1552 * Recursive helper for GetNextDlgTabItem
1553 */
1554 static HWND DIALOG_GetNextTabItem( HWND hwndMain, HWND hwndDlg, HWND hwndCtrl, BOOL fPrevious )
1555 {
1556 LONG dsStyle;
1557 LONG exStyle;
1558 UINT wndSearch = fPrevious ? GW_HWNDPREV : GW_HWNDNEXT;
1559 HWND retWnd = 0;
1560 HWND hChildFirst = 0;
1561
1562 if(!hwndCtrl)
1563 {
1564 hChildFirst = GetWindow(hwndDlg,GW_CHILD);
1565 if(fPrevious) hChildFirst = GetWindow(hChildFirst,GW_HWNDLAST);
1566 }
1567 else if (IsChild( hwndMain, hwndCtrl ))
1568 {
1569 hChildFirst = GetWindow(hwndCtrl,wndSearch);
1570 if(!hChildFirst)
1571 {
1572 if(GetParent(hwndCtrl) != hwndMain)
1573 /* i.e. if we are not at the top level of the recursion */
1574 hChildFirst = GetWindow(GetParent(hwndCtrl),wndSearch);
1575 else
1576 hChildFirst = GetWindow(hwndCtrl, fPrevious ? GW_HWNDLAST : GW_HWNDFIRST);
1577 }
1578 }
1579
1580 while(hChildFirst)
1581 {
1582 dsStyle = GetWindowLongA(hChildFirst,GWL_STYLE);
1583 exStyle = GetWindowLongA(hChildFirst,GWL_EXSTYLE);
1584 if( (exStyle & WS_EX_CONTROLPARENT) && (dsStyle & WS_VISIBLE) && !(dsStyle & WS_DISABLED))
1585 {
1586 HWND retWnd;
1587 retWnd = DIALOG_GetNextTabItem(hwndMain,hChildFirst,NULL,fPrevious );
1588 if (retWnd) return (retWnd);
1589 }
1590 else if( (dsStyle & WS_TABSTOP) && (dsStyle & WS_VISIBLE) && !(dsStyle & WS_DISABLED))
1591 {
1592 return (hChildFirst);
1593 }
1594 hChildFirst = GetWindow(hChildFirst,wndSearch);
1595 }
1596 if(hwndCtrl)
1597 {
1598 HWND hParent = GetParent(hwndCtrl);
1599 while(hParent)
1600 {
1601 if(hParent == hwndMain) break;
1602 retWnd = DIALOG_GetNextTabItem(hwndMain,GetParent(hParent),hParent,fPrevious );
1603 if(retWnd) break;
1604 hParent = GetParent(hParent);
1605 }
1606 if(!retWnd)
1607 retWnd = DIALOG_GetNextTabItem(hwndMain,hwndMain,NULL,fPrevious );
1608 }
1609 return retWnd ? retWnd : hwndCtrl;
1610 }
1611
1612 /***********************************************************************
1613 * GetNextDlgTabItem (USER32.@)
1614 */
1615 HWND WINAPI GetNextDlgTabItem( HWND hwndDlg, HWND hwndCtrl,
1616 BOOL fPrevious )
1617 {
1618 hwndDlg = WIN_GetFullHandle( hwndDlg );
1619 hwndCtrl = WIN_GetFullHandle( hwndCtrl );
1620
1621 /* Undocumented but tested under Win2000 and WinME */
1622 if (hwndDlg == hwndCtrl) hwndCtrl = NULL;
1623
1624 /* Contrary to MSDN documentation, tested under Win2000 and WinME
1625 * NB GetLastError returns whatever was set before the function was
1626 * called.
1627 */
1628 if (!hwndCtrl && fPrevious) return 0;
1629
1630 return DIALOG_GetNextTabItem(hwndDlg,hwndDlg,hwndCtrl,fPrevious);
1631 }
1632
1633 /**********************************************************************
1634 * DIALOG_DlgDirSelect
1635 *
1636 * Helper function for DlgDirSelect*
1637 */
1638 static BOOL DIALOG_DlgDirSelect( HWND hwnd, LPWSTR str, INT len,
1639 INT id, BOOL unicode, BOOL combo )
1640 {
1641 WCHAR *buffer, *ptr;
1642 INT item, size;
1643 BOOL ret;
1644 HWND listbox = GetDlgItem( hwnd, id );
1645
1646 TRACE("%p '%s' %d\n", hwnd, unicode ? debugstr_w(str) : debugstr_a((LPSTR)str), id );
1647 if (!listbox) return FALSE;
1648
1649 item = SendMessageW(listbox, combo ? CB_GETCURSEL : LB_GETCURSEL, 0, 0 );
1650 if (item == LB_ERR) return FALSE;
1651
1652 size = SendMessageW(listbox, combo ? CB_GETLBTEXTLEN : LB_GETTEXTLEN, 0, 0 );
1653 if (size == LB_ERR) return FALSE;
1654
1655 if (!(buffer = HeapAlloc( GetProcessHeap(), 0, size+1 ))) return FALSE;
1656
1657 SendMessageW( listbox, combo ? CB_GETLBTEXT : LB_GETTEXT, item, (LPARAM)buffer );
1658
1659 if ((ret = (buffer[0] == '['))) /* drive or directory */
1660 {
1661 if (buffer[1] == '-') /* drive */
1662 {
1663 buffer[3] = ':';
1664 buffer[4] = 0;
1665 ptr = buffer + 2;
1666 }
1667 else
1668 {
1669 buffer[strlenW(buffer)-1] = '\\';
1670 ptr = buffer + 1;
1671 }
1672 }
1673 else ptr = buffer;
1674
1675 if (!unicode)
1676 {
1677 if (len > 0 && !WideCharToMultiByte( CP_ACP, 0, ptr, -1, (LPSTR)str, len, 0, 0 ))
1678 ((LPSTR)str)[len-1] = 0;
1679 }
1680 else lstrcpynW( str, ptr, len );
1681 HeapFree( GetProcessHeap(), 0, buffer );
1682 TRACE("Returning %d '%s'\n", ret, unicode ? debugstr_w(str) : debugstr_a((LPSTR)str) );
1683 return ret;
1684 }
1685
1686
1687 /**********************************************************************
1688 * DIALOG_DlgDirListW
1689 *
1690 * Helper function for DlgDirList*W
1691 */
1692 static INT DIALOG_DlgDirListW( HWND hDlg, LPWSTR spec, INT idLBox,
1693 INT idStatic, UINT attrib, BOOL combo )
1694 {
1695 HWND hwnd;
1696 LPWSTR orig_spec = spec;
1697 WCHAR any[] = {'*','.','*',0};
1698
1699 #define SENDMSG(msg,wparam,lparam) \
1700 ((attrib & DDL_POSTMSGS) ? PostMessageW( hwnd, msg, wparam, lparam ) \
1701 : SendMessageW( hwnd, msg, wparam, lparam ))
1702
1703 TRACE("%p %s %d %d %04x\n", hDlg, debugstr_w(spec), idLBox, idStatic, attrib );
1704
1705 /* If the path exists and is a directory, chdir to it */
1706 if (!spec || !spec[0] || SetCurrentDirectoryW( spec )) spec = any;
1707 else
1708 {
1709 WCHAR *p, *p2;
1710 p = spec;
1711 if ((p2 = strrchrW( p, '\\' ))) p = p2;
1712 if ((p2 = strrchrW( p, '/' ))) p = p2;
1713 if (p != spec)
1714 {
1715 WCHAR sep = *p;
1716 *p = 0;
1717 if (!SetCurrentDirectoryW( spec ))
1718 {
1719 *p = sep; /* Restore the original spec */
1720 return FALSE;
1721 }
1722 spec = p + 1;
1723 }
1724 }
1725
1726 TRACE( "mask=%s\n", debugstr_w(spec) );
1727
1728 if (idLBox && ((hwnd = GetDlgItem( hDlg, idLBox )) != 0))
1729 {
1730 SENDMSG( combo ? CB_RESETCONTENT : LB_RESETCONTENT, 0, 0 );
1731 if (attrib & DDL_DIRECTORY)
1732 {
1733 if (!(attrib & DDL_EXCLUSIVE))
1734 {
1735 if (SENDMSG( combo ? CB_DIR : LB_DIR,
1736 attrib & ~(DDL_DIRECTORY | DDL_DRIVES),
1737 (LPARAM)spec ) == LB_ERR)
1738 return FALSE;
1739 }
1740 if (SENDMSG( combo ? CB_DIR : LB_DIR,
1741 (attrib & (DDL_DIRECTORY | DDL_DRIVES)) | DDL_EXCLUSIVE,
1742 (LPARAM)any ) == LB_ERR)
1743 return FALSE;
1744 }
1745 else
1746 {
1747 if (SENDMSG( combo ? CB_DIR : LB_DIR, attrib,
1748 (LPARAM)spec ) == LB_ERR)
1749 return FALSE;
1750 }
1751 }
1752
1753 if (idStatic && ((hwnd = GetDlgItem( hDlg, idStatic )) != 0))
1754 {
1755 WCHAR temp[MAX_PATH];
1756 GetCurrentDirectoryW( sizeof(temp)/sizeof(WCHAR), temp );
1757 CharLowerW( temp );
1758 /* Can't use PostMessage() here, because the string is on the stack */
1759 SetDlgItemTextW( hDlg, idStatic, temp );
1760 }
1761
1762 if (orig_spec && (spec != orig_spec))
1763 {
1764 /* Update the original file spec */
1765 WCHAR *p = spec;
1766 while ((*orig_spec++ = *p++));
1767 }
1768
1769 return TRUE;
1770 #undef SENDMSG
1771 }
1772
1773
1774 /**********************************************************************
1775 * DIALOG_DlgDirListA
1776 *
1777 * Helper function for DlgDirList*A
1778 */
1779 static INT DIALOG_DlgDirListA( HWND hDlg, LPSTR spec, INT idLBox,
1780 INT idStatic, UINT attrib, BOOL combo )
1781 {
1782 if (spec)
1783 {
1784 INT ret, len = MultiByteToWideChar( CP_ACP, 0, spec, -1, NULL, 0 );
1785 LPWSTR specW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
1786 MultiByteToWideChar( CP_ACP, 0, spec, -1, specW, len );
1787 ret = DIALOG_DlgDirListW( hDlg, specW, idLBox, idStatic, attrib, combo );
1788 WideCharToMultiByte( CP_ACP, 0, specW, -1, spec, 0x7fffffff, NULL, NULL );
1789 HeapFree( GetProcessHeap(), 0, specW );
1790 return ret;
1791 }
1792 return DIALOG_DlgDirListW( hDlg, NULL, idLBox, idStatic, attrib, combo );
1793 }
1794
1795
1796 /**********************************************************************
1797 * DlgDirSelectExA (USER32.@)
1798 */
1799 BOOL WINAPI DlgDirSelectExA( HWND hwnd, LPSTR str, INT len, INT id )
1800 {
1801 return DIALOG_DlgDirSelect( hwnd, (LPWSTR)str, len, id, FALSE, FALSE );
1802 }
1803
1804
1805 /**********************************************************************
1806 * DlgDirSelectExW (USER32.@)
1807 */
1808 BOOL WINAPI DlgDirSelectExW( HWND hwnd, LPWSTR str, INT len, INT id )
1809 {
1810 return DIALOG_DlgDirSelect( hwnd, str, len, id, TRUE, FALSE );
1811 }
1812
1813
1814 /**********************************************************************
1815 * DlgDirSelectComboBoxExA (USER32.@)
1816 */
1817 BOOL WINAPI DlgDirSelectComboBoxExA( HWND hwnd, LPSTR str, INT len,
1818 INT id )
1819 {
1820 return DIALOG_DlgDirSelect( hwnd, (LPWSTR)str, len, id, FALSE, TRUE );
1821 }
1822
1823
1824 /**********************************************************************
1825 * DlgDirSelectComboBoxExW (USER32.@)
1826 */
1827 BOOL WINAPI DlgDirSelectComboBoxExW( HWND hwnd, LPWSTR str, INT len,
1828 INT id)
1829 {
1830 return DIALOG_DlgDirSelect( hwnd, str, len, id, TRUE, TRUE );
1831 }
1832
1833
1834 /**********************************************************************
1835 * DlgDirListA (USER32.@)
1836 */
1837 INT WINAPI DlgDirListA( HWND hDlg, LPSTR spec, INT idLBox,
1838 INT idStatic, UINT attrib )
1839 {
1840 return DIALOG_DlgDirListA( hDlg, spec, idLBox, idStatic, attrib, FALSE );
1841 }
1842
1843
1844 /**********************************************************************
1845 * DlgDirListW (USER32.@)
1846 */
1847 INT WINAPI DlgDirListW( HWND hDlg, LPWSTR spec, INT idLBox,
1848 INT idStatic, UINT attrib )
1849 {
1850 return DIALOG_DlgDirListW( hDlg, spec, idLBox, idStatic, attrib, FALSE );
1851 }
1852
1853
1854 /**********************************************************************
1855 * DlgDirListComboBoxA (USER32.@)
1856 */
1857 INT WINAPI DlgDirListComboBoxA( HWND hDlg, LPSTR spec, INT idCBox,
1858 INT idStatic, UINT attrib )
1859 {
1860 return DIALOG_DlgDirListA( hDlg, spec, idCBox, idStatic, attrib, TRUE );
1861 }
1862
1863
1864 /**********************************************************************
1865 * DlgDirListComboBoxW (USER32.@)
1866 */
1867 INT WINAPI DlgDirListComboBoxW( HWND hDlg, LPWSTR spec, INT idCBox,
1868 INT idStatic, UINT attrib )
1869 {
1870 return DIALOG_DlgDirListW( hDlg, spec, idCBox, idStatic, attrib, TRUE );
1871 }
Windows API implementation