reactos/dll/win32/user32/windows/dialog.c

   1 /*
   2  *  ReactOS kernel
   3  *  Copyright (C) 1998, 1999, 2000, 2001 ReactOS Team
   4  *
   5  *  This program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with this program; if not, write to the Free Software
  17  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18  */
  19 /* $Id$
  20  *
  21  * PROJECT:         ReactOS user32.dll
  22  * FILE:            lib/user32/windows/dialog.c
  23  * PURPOSE:         Input
  24  * PROGRAMMER:      Casper S. Hornstrup (chorns@users.sourceforge.net)
  25  *                  Thomas Weidenmueller (w3seek@users.sourceforge.net)
  26  *                  Steven Edwards (Steven_Ed4153@yahoo.com)
  27  * UPDATE HISTORY:
  28  *      07-26-2003  Code ported from wine
  29  *      09-05-2001  CSH  Created
  30  */
  31
  32 /* INCLUDES ******************************************************************/
  33
  34 #include <user32.h>
  35
  36 #include <wine/debug.h>
  37 WINE_DEFAULT_DEBUG_CHANNEL(user32);
  38
  39 /* MACROS/DEFINITIONS ********************************************************/
  40
  41 #define DF_END  0x0001
  42 #define DF_OWNERENABLED 0x0002
  43 #define CW_USEDEFAULT16 ((short)0x8000)
  44 #define DWLP_ROS_DIALOGINFO (DWLP_USER+sizeof(ULONG_PTR))
  45 #define GETDLGINFO(hwnd) DIALOG_get_info(hwnd, FALSE)
  46 #define SETDLGINFO(hwnd, info) SetWindowLongPtrW((hwnd), DWLP_ROS_DIALOGINFO, (LONG_PTR)(info))
  47 #define GET_WORD(ptr)  (*(WORD *)(ptr))
  48 #define GET_DWORD(ptr) (*(DWORD *)(ptr))
  49 #define MAKEINTATOMA(atom)  ((LPCSTR)((ULONG_PTR)((WORD)(atom))))
  50 #define MAKEINTATOMW(atom)  ((LPCWSTR)((ULONG_PTR)((WORD)(atom))))
  51 #define DIALOG_CLASS_ATOMA   MAKEINTATOMA(32770)  /* Dialog */
  52 #define DIALOG_CLASS_ATOMW   MAKEINTATOMW(32770)  /* Dialog */
  53
  54 void WINAPI WinPosActivateOtherWindow(HWND hwnd);
  55
  56 /* INTERNAL STRUCTS **********************************************************/
  57
  58 /* Dialog info structure */
  59 typedef struct
  60 {
  61     HWND      hwndFocus;   /* Current control with focus */
  62     HFONT     hUserFont;   /* Dialog font */
  63     HMENU     hMenu;       /* Dialog menu */
  64     UINT      xBaseUnit;   /* Dialog units (depends on the font) */
  65     UINT      yBaseUnit;
  66     INT       idResult;    /* EndDialog() result / default pushbutton ID */
  67     UINT      flags;       /* EndDialog() called for this dialog */
  68 } DIALOGINFO;
  69
  70 /* Dialog control information */
  71 typedef struct
  72 {
  73     DWORD      style;
  74     DWORD      exStyle;
  75     DWORD      helpId;
  76     short      x;
  77     short      y;
  78     short      cx;
  79     short      cy;
  80     UINT       id;
  81     LPCWSTR    className;
  82     LPCWSTR    windowName;
  83     BOOL       windowNameFree;
  84     LPCVOID    data;
  85 } DLG_CONTROL_INFO;
  86
  87 /* Dialog template */
  88 typedef struct
  89 {
  90     DWORD      style;
  91     DWORD      exStyle;
  92     DWORD      helpId;
  93     WORD       nbItems;
  94     short      x;
  95     short      y;
  96     short      cx;
  97     short      cy;
  98     LPCWSTR    menuName;
  99     LPCWSTR    className;
 100     LPCWSTR    caption;
 101     WORD       pointSize;
 102     WORD       weight;
 103     BOOL       italic;
 104     LPCWSTR    faceName;
 105     BOOL       dialogEx;
 106 } DLG_TEMPLATE;
 107
 108 /* GetDlgItem structure */
 109 typedef struct
 110 {
 111     INT        nIDDlgItem;
 112     HWND       control;
 113 } GETDLGITEMINFO;
 114
 115 /* CheckRadioButton structure */
 116 typedef struct
 117 {
 118   UINT firstID;
 119   UINT lastID;
 120   UINT checkID;
 121 } RADIOGROUP;
 122
 123
 124 /*********************************************************************
 125  * dialog class descriptor
 126  */
 127 const struct builtin_class_descr DIALOG_builtin_class =
 128 {
 129     DIALOG_CLASS_ATOMW,       /* name */
 130     CS_SAVEBITS | CS_DBLCLKS, /* style  */
 131     (WNDPROC) DefDlgProcA,    /* procA */
 132     (WNDPROC) DefDlgProcW,    /* procW */
 133     DLGWINDOWEXTRA,           /* extra */
 134     (LPCWSTR) IDC_ARROW,      /* cursor */
 135     0                         /* brush */
 136 };
 137
 138
 139 /* INTERNAL FUNCTIONS ********************************************************/
 140
 141 /***********************************************************************
 142 *               DIALOG_get_info
 143 *
 144 * Get the DIALOGINFO structure of a window, allocating it if needed
 145 * and 'create' is TRUE.
 146 */
 147 DIALOGINFO * DIALOG_get_info( HWND hWnd, BOOL create )
 148 {
 149     PWINDOW pWindow;
 150     DIALOGINFO* dlgInfo = (DIALOGINFO *)GetWindowLongPtrW( hWnd, DWLP_ROS_DIALOGINFO );
 151
 152     if(!dlgInfo && create)
 153     {
 154         pWindow = ValidateHwnd( hWnd );
 155
 156         if (pWindow && pWindow->ExtraDataSize >= DLGWINDOWEXTRA && hWnd != GetDesktopWindow())
 157         {
 158             if (!(dlgInfo = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*dlgInfo) )))
 159                 return NULL;
 160
 161             SETDLGINFO( hWnd, dlgInfo );
 162
 163             NtUserSetWindowFNID( hWnd, FNID_DIALOG );
 164         }
 165         else
 166         {
 167             return NULL;
 168         }
 169     }
 170     return dlgInfo;
 171 }
 172
 173 /***********************************************************************
 174  *           DIALOG_EnableOwner
 175  *
 176  * Helper function for modal dialogs to enable again the
 177  * owner of the dialog box.
 178  */
 179 void DIALOG_EnableOwner( HWND hOwner )
 180 {
 181     /* Owner must be a top-level window */
 182     if (hOwner)
 183         hOwner = GetAncestor( hOwner, GA_ROOT );
 184     if (!hOwner) return;
 185         EnableWindow( hOwner, TRUE );
 186 }
 187
 188  /***********************************************************************
 189  *           DIALOG_DisableOwner
 190  *
 191  * Helper function for modal dialogs to disable the
 192  * owner of the dialog box. Returns TRUE if owner was enabled.
 193  */
 194 BOOL DIALOG_DisableOwner( HWND hOwner )
 195 {
 196     /* Owner must be a top-level window */
 197     if (hOwner)
 198         hOwner = GetAncestor( hOwner, GA_ROOT );
 199     if (!hOwner) return FALSE;
 200     if (IsWindowEnabled( hOwner ))
 201     {
 202         EnableWindow( hOwner, FALSE );
 203         return TRUE;
 204     }
 205     else
 206         return FALSE;
 207 }
 208
 209  /***********************************************************************
 210  *           DIALOG_GetControl32
 211  *
 212  * Return the class and text of the control pointed to by ptr,
 213  * fill the header structure and return a pointer to the next control.
 214  */
 215 static const WORD *DIALOG_GetControl32( const WORD *p, DLG_CONTROL_INFO *info,
 216                                         BOOL dialogEx )
 217 {
 218     if (dialogEx)
 219     {
 220         info->helpId  = GET_DWORD(p); p += 2;
 221         info->exStyle = GET_DWORD(p); p += 2;
 222         info->style   = GET_DWORD(p); p += 2;
 223     }
 224     else
 225     {
 226         info->helpId  = 0;
 227         info->style   = GET_DWORD(p); p += 2;
 228         info->exStyle = GET_DWORD(p); p += 2;
 229     }
 230     info->x       = GET_WORD(p); p++;
 231     info->y       = GET_WORD(p); p++;
 232     info->cx      = GET_WORD(p); p++;
 233     info->cy      = GET_WORD(p); p++;
 234
 235     if (dialogEx)
 236     {
 237         /* id is a DWORD for DIALOGEX */
 238         info->id = GET_DWORD(p);
 239         p += 2;
 240     }
 241     else
 242     {
 243         info->id = GET_WORD(p);
 244         p++;
 245     }
 246
 247     if (GET_WORD(p) == 0xffff)
 248     {
 249         static const WCHAR class_names[6][10] =
 250         {
 251             { 'B','u','t','t','o','n', },             /* 0x80 */
 252             { 'E','d','i','t', },                     /* 0x81 */
 253             { 'S','t','a','t','i','c', },             /* 0x82 */
 254             { 'L','i','s','t','B','o','x', },         /* 0x83 */
 255             { 'S','c','r','o','l','l','B','a','r', }, /* 0x84 */
 256             { 'C','o','m','b','o','B','o','x', }      /* 0x85 */
 257         };
 258         WORD id = GET_WORD(p+1);
 259         /* Windows treats dialog control class ids 0-5 same way as 0x80-0x85 */
 260         if ((id >= 0x80) && (id <= 0x85)) id -= 0x80;
 261         if (id <= 5)
 262             info->className = class_names[id];
 263         else
 264         {
 265             info->className = NULL;
 266             /* FIXME: load other classes here? */
 267         }
 268         p += 2;
 269     }
 270     else
 271     {
 272         info->className = (LPCWSTR)p;
 273         p += wcslen( info->className ) + 1;
 274     }
 275
 276     if (GET_WORD(p) == 0xffff)  /* Is it an integer id? */
 277     {
 278         info->windowName = HeapAlloc( GetProcessHeap(), 0, sizeof(L"#65535") );
 279         if (info->windowName != NULL)
 280         {
 281             swprintf((LPWSTR)info->windowName, L"#%d", GET_WORD(p + 1));
 282             info->windowNameFree = TRUE;
 283         }
 284         else
 285         {
 286             info->windowNameFree = FALSE;
 287         }
 288         p += 2;
 289     }
 290     else
 291     {
 292         info->windowName = (LPCWSTR)p;
 293         info->windowNameFree = FALSE;
 294         p += wcslen( info->windowName ) + 1;
 295     }
 296
 297     if (GET_WORD(p))
 298     {
 299         info->data = p + 1;
 300         p += GET_WORD(p) / sizeof(WORD);
 301     }
 302     else info->data = NULL;
 303     p++;
 304
 305     /* Next control is on dword boundary */
 306     return (const WORD *)((((int)p) + 3) & ~3);
 307 }
 308
 309  /***********************************************************************
 310  *           DIALOG_CreateControls32
 311  *
 312  * Create the control windows for a dialog.
 313  */
 314 static BOOL DIALOG_CreateControls32( HWND hwnd, LPCSTR template, const DLG_TEMPLATE *dlgTemplate,
 315                                      HINSTANCE hInst, BOOL unicode )
 316 {
 317     DIALOGINFO * dlgInfo;
 318     DLG_CONTROL_INFO info;
 319     HWND hwndCtrl, hwndDefButton = 0;
 320     INT items = dlgTemplate->nbItems;
 321
 322     if (!(dlgInfo = GETDLGINFO(hwnd))) return FALSE;
 323
 324     while (items--)
 325     {
 326         template = (LPCSTR)DIALOG_GetControl32( (WORD *)template, &info,
 327                                                 dlgTemplate->dialogEx );
 328         /* Is this it? */
 329         if (info.style & WS_BORDER)
 330         {
 331             info.style &= ~WS_BORDER;
 332             info.exStyle |= WS_EX_CLIENTEDGE;
 333         }
 334         if (unicode)
 335         {
 336             hwndCtrl = CreateWindowExW( info.exStyle | WS_EX_NOPARENTNOTIFY,
 337                                         info.className, info.windowName,
 338                                         info.style | WS_CHILD,
 339                                         MulDiv(info.x, dlgInfo->xBaseUnit, 4),
 340                                         MulDiv(info.y, dlgInfo->yBaseUnit, 8),
 341                                         MulDiv(info.cx, dlgInfo->xBaseUnit, 4),
 342                                         MulDiv(info.cy, dlgInfo->yBaseUnit, 8),
 343                                         hwnd, (HMENU)info.id,
 344                                         hInst, (LPVOID)info.data );
 345         }
 346         else
 347         {
 348             LPSTR class = (LPSTR)info.className;
 349             LPSTR caption = (LPSTR)info.windowName;
 350
 351             if (HIWORD(class))
 352             {
 353                 DWORD len = WideCharToMultiByte( CP_ACP, 0, info.className, -1, NULL, 0, NULL, NULL );
 354                 class = HeapAlloc( GetProcessHeap(), 0, len );
 355                 if (class != NULL)
 356                     WideCharToMultiByte( CP_ACP, 0, info.className, -1, class, len, NULL, NULL );
 357             }
 358             if (HIWORD(caption))
 359             {
 360                 DWORD len = WideCharToMultiByte( CP_ACP, 0, info.windowName, -1, NULL, 0, NULL, NULL );
 361                 caption = HeapAlloc( GetProcessHeap(), 0, len );
 362                 if (caption != NULL)
 363                     WideCharToMultiByte( CP_ACP, 0, info.windowName, -1, caption, len, NULL, NULL );
 364             }
 365
 366             if (class != NULL && caption != NULL)
 367             {
 368                 hwndCtrl = CreateWindowExA( info.exStyle | WS_EX_NOPARENTNOTIFY,
 369                                             class, caption, info.style | WS_CHILD,
 370                                             MulDiv(info.x, dlgInfo->xBaseUnit, 4),
 371                                             MulDiv(info.y, dlgInfo->yBaseUnit, 8),
 372                                             MulDiv(info.cx, dlgInfo->xBaseUnit, 4),
 373                                             MulDiv(info.cy, dlgInfo->yBaseUnit, 8),
 374                                             hwnd, (HMENU)info.id,
 375                                             hInst, (LPVOID)info.data );
 376             }
 377             else
 378                 hwndCtrl = NULL;
 379             if (HIWORD(class)) HeapFree( GetProcessHeap(), 0, class );
 380             if (HIWORD(caption)) HeapFree( GetProcessHeap(), 0, caption );
 381         }
 382
 383         if (info.windowNameFree)
 384         {
 385             HeapFree( GetProcessHeap(), 0, (LPVOID)info.windowName );
 386         }
 387
 388         if (!hwndCtrl)
 389         {
 390             if (dlgTemplate->style & DS_NOFAILCREATE) continue;
 391             return FALSE;
 392         }
 393
 394         /* Send initialisation messages to the control */
 395         if (dlgInfo->hUserFont) SendMessageW( hwndCtrl, WM_SETFONT,
 396                                              (WPARAM)dlgInfo->hUserFont, 0 );
 397         if (SendMessageW(hwndCtrl, WM_GETDLGCODE, 0, 0) & DLGC_DEFPUSHBUTTON)
 398         {
 399             /* If there's already a default push-button, set it back */
 400             /* to normal and use this one instead. */
 401             if (hwndDefButton)
 402                 SendMessageW( hwndDefButton, BM_SETSTYLE, BS_PUSHBUTTON, FALSE );
 403             hwndDefButton = hwndCtrl;
 404             dlgInfo->idResult = GetWindowLongPtrA( hwndCtrl, GWLP_ID );
 405         }
 406     }
 407     return TRUE;
 408 }
 409
 410  /***********************************************************************
 411   *           DIALOG_FindMsgDestination
 412   *
 413   * The messages that IsDialogMessage sends may not go to the dialog
 414   * calling IsDialogMessage if that dialog is a child, and it has the
 415   * DS_CONTROL style set.
 416   * We propagate up until we hit one that does not have DS_CONTROL, or
 417   * whose parent is not a dialog.
 418   *
 419   * This is undocumented behaviour.
 420   */
 421 static HWND DIALOG_FindMsgDestination( HWND hwndDlg )
 422 {
 423     while (GetWindowLongA(hwndDlg, GWL_STYLE) & DS_CONTROL)
 424     {
 425         HWND hParent = GetParent(hwndDlg);
 426         if (!hParent) break;
 427
 428         if (!IsWindow(hParent)) break;
 429
 430         if (!GETDLGINFO(hParent)) /* TODO: Correct? */
 431         {
 432             break;
 433         }
 434
 435         hwndDlg = hParent;
 436     }
 437
 438     return hwndDlg;
 439 }
 440
 441  /***********************************************************************
 442   *           DIALOG_IsAccelerator
 443   */
 444 static BOOL DIALOG_IsAccelerator( HWND hwnd, HWND hwndDlg, WPARAM wParam )
 445 {
 446     HWND hwndControl = hwnd;
 447     HWND hwndNext;
 448     INT dlgCode;
 449     WCHAR buffer[128];
 450
 451     do
 452     {
 453         DWORD style = GetWindowLongW( hwndControl, GWL_STYLE );
 454         if ((style & (WS_VISIBLE | WS_DISABLED)) == WS_VISIBLE)
 455         {
 456             dlgCode = SendMessageA( hwndControl, WM_GETDLGCODE, 0, 0 );
 457             if ( (dlgCode & (DLGC_BUTTON | DLGC_STATIC)) &&
 458                  GetWindowTextW( hwndControl, buffer, sizeof(buffer)/sizeof(WCHAR) ))
 459             {
 460                 /* find the accelerator key */
 461                 LPWSTR p = buffer - 2;
 462
 463                 do
 464                 {
 465                     p = wcschr( p + 2, '&' );
 466                 }
 467                 while (p != NULL && p[1] == '&');
 468
 469                 /* and check if it's the one we're looking for */
 470                                 /* FIXME: usage of towupper correct? */
 471                 if (p != NULL && towupper( p[1] ) == towupper( wParam ) )
 472                 {
 473                     if ((dlgCode & DLGC_STATIC) || (style & 0x0f) == BS_GROUPBOX )
 474                     {
 475                         /* set focus to the control */
 476                         SendMessageW( hwndDlg, WM_NEXTDLGCTL, (WPARAM)hwndControl, 1);
 477                         /* and bump it on to next */
 478                         SendMessageW( hwndDlg, WM_NEXTDLGCTL, 0, 0);
 479                     }
 480                     else if (dlgCode & DLGC_BUTTON)
 481                     {
 482                         /* send BM_CLICK message to the control */
 483                         SendMessageW( hwndControl, BM_CLICK, 0, 0 );
 484                     }
 485                     return TRUE;
 486                 }
 487             }
 488             hwndNext = GetWindow( hwndControl, GW_CHILD );
 489         }
 490         else hwndNext = 0;
 491
 492         if (!hwndNext) hwndNext = GetWindow( hwndControl, GW_HWNDNEXT );
 493
 494         while (!hwndNext && hwndControl)
 495         {
 496             hwndControl = GetParent( hwndControl );
 497             if (hwndControl == hwndDlg)
 498             {
 499                 if(hwnd==hwndDlg)   /* prevent endless loop */
 500                 {
 501                     hwndNext=hwnd;
 502                     break;
 503                 }
 504                 hwndNext = GetWindow( hwndDlg, GW_CHILD );
 505             }
 506             else
 507                 hwndNext = GetWindow( hwndControl, GW_HWNDNEXT );
 508         }
 509         hwndControl = hwndNext;
 510     }
 511     while (hwndControl && (hwndControl != hwnd));
 512
 513     return FALSE;
 514 }
 515
 516  /***********************************************************************
 517  *           DIALOG_DoDialogBox
 518  */
 519 INT DIALOG_DoDialogBox( HWND hwnd, HWND owner )
 520 {
 521     DIALOGINFO * dlgInfo;
 522     MSG msg;
 523     INT retval;
 524     HWND ownerMsg = GetAncestor( owner, GA_ROOT );
 525     BOOL bFirstEmpty;
 526
 527     if (!(dlgInfo = GETDLGINFO(hwnd))) return -1;
 528
 529     bFirstEmpty = TRUE;
 530     if (!(dlgInfo->flags & DF_END)) /* was EndDialog called in WM_INITDIALOG ? */
 531     {
 532         for (;;)
 533         {
 534             if (!PeekMessageW( &msg, 0, 0, 0, PM_REMOVE ))
 535             {
 536                 if (bFirstEmpty)
 537                 {
 538                     /* ShowWindow the first time the queue goes empty */
 539                     ShowWindow( hwnd, SW_SHOWNORMAL );
 540                     bFirstEmpty = FALSE;
 541                 }
 542                 if (!(GetWindowLongW( hwnd, GWL_STYLE ) & DS_NOIDLEMSG))
 543                {
 544                     /* No message present -> send ENTERIDLE and wait */
 545                     SendMessageW( ownerMsg, WM_ENTERIDLE, MSGF_DIALOGBOX, (LPARAM)hwnd );
 546                 }
 547                 if (!GetMessageW( &msg, 0, 0, 0 )) break;
 548             }
 549
 550             if (!IsWindow( hwnd )) return -1;
 551             if (!(dlgInfo->flags & DF_END) && !IsDialogMessageW( hwnd, &msg))
 552             {
 553                 TranslateMessage( &msg );
 554                 DispatchMessageW( &msg );
 555             }
 556             if (dlgInfo->flags & DF_END) break;
 557         }
 558     }
 559     if (dlgInfo->flags & DF_OWNERENABLED) DIALOG_EnableOwner( owner );
 560     retval = dlgInfo->idResult;
 561     DestroyWindow( hwnd );
 562     return retval;
 563 }
 564
 565  /***********************************************************************
 566  *           DIALOG_ParseTemplate32
 567  *
 568  * Fill a DLG_TEMPLATE structure from the dialog template, and return
 569  * a pointer to the first control.
 570  */
 571 static LPCSTR DIALOG_ParseTemplate32( LPCSTR template, DLG_TEMPLATE * result )
 572 {
 573     const WORD *p = (const WORD *)template;
 574     WORD signature;
 575     WORD dlgver;
 576
 577     signature = GET_WORD(p); p++;
 578     dlgver = GET_WORD(p); p++;
 579
 580     if (signature == 1 && dlgver == 0xffff)  /* DIALOGEX resource */
 581     {
 582         result->dialogEx = TRUE;
 583         result->helpId   = GET_DWORD(p); p += 2;
 584         result->exStyle  = GET_DWORD(p); p += 2;
 585         result->style    = GET_DWORD(p); p += 2;
 586     }
 587     else
 588     {
 589         result->style = GET_DWORD(p - 2);
 590         result->dialogEx = FALSE;
 591         result->helpId   = 0;
 592         result->exStyle  = GET_DWORD(p); p += 2;
 593     }
 594     result->nbItems = GET_WORD(p); p++;
 595     result->x       = GET_WORD(p); p++;
 596     result->y       = GET_WORD(p); p++;
 597     result->cx      = GET_WORD(p); p++;
 598     result->cy      = GET_WORD(p); p++;
 599
 600     /* Get the menu name */
 601
 602     switch(GET_WORD(p))
 603     {
 604         case 0x0000:
 605             result->menuName = NULL;
 606             p++;
 607             break;
 608         case 0xffff:
 609             result->menuName = (LPCWSTR)(UINT)GET_WORD( p + 1 );
 610             p += 2;
 611             break;
 612         default:
 613             result->menuName = (LPCWSTR)p;
 614             p += wcslen( result->menuName ) + 1;
 615             break;
 616     }
 617
 618     /* Get the class name */
 619
 620     switch(GET_WORD(p))
 621     {
 622         case 0x0000:
 623             result->className = DIALOG_CLASS_ATOMW;
 624             p++;
 625             break;
 626         case 0xffff:
 627             result->className = (LPCWSTR)(UINT)GET_WORD( p + 1 );
 628             p += 2;
 629             break;
 630         default:
 631             result->className = (LPCWSTR)p;
 632             p += wcslen( result->className ) + 1;
 633             break;
 634     }
 635
 636     /* Get the window caption */
 637
 638     result->caption = (LPCWSTR)p;
 639     p += wcslen( result->caption ) + 1;
 640
 641     /* Get the font name */
 642
 643     result->pointSize = 0;
 644     result->weight = FW_DONTCARE;
 645     result->italic = FALSE;
 646     result->faceName = NULL;
 647
 648     if (result->style & DS_SETFONT)
 649     {
 650         result->pointSize = GET_WORD(p);
 651         p++;
 652         if (result->dialogEx)
 653         {
 654             result->weight = GET_WORD(p); p++;
 655             result->italic = LOBYTE(GET_WORD(p)); p++;
 656         }
 657         result->faceName = (LPCWSTR)p;
 658         p += wcslen( result->faceName ) + 1;
 659     }
 660
 661     /* First control is on dword boundary */
 662     return (LPCSTR)((((UINT_PTR)p) + 3) & ~3);
 663 }
 664
 665  /***********************************************************************
 666  *           DIALOG_CreateIndirect
 667  *       Creates a dialog box window
 668  *
 669  *       modal = TRUE if we are called from a modal dialog box.
 670  *       (it's more compatible to do it here, as under Windows the owner
 671  *       is never disabled if the dialog fails because of an invalid template)
 672  */
 673 static HWND DIALOG_CreateIndirect( HINSTANCE hInst, LPCVOID dlgTemplate,
 674                                    HWND owner, DLGPROC dlgProc, LPARAM param,
 675                                    BOOL unicode, BOOL modal )
 676 {
 677     HWND hwnd;
 678     RECT rect;
 679     DLG_TEMPLATE template;
 680     DIALOGINFO * dlgInfo = NULL;
 681     DWORD units = GetDialogBaseUnits();
 682     BOOL ownerEnabled = TRUE;
 683     HMENU hMenu = 0;
 684     HFONT hUserFont = 0;
 685     UINT flags = 0;
 686     UINT xBaseUnit = LOWORD(units);
 687     UINT yBaseUnit = HIWORD(units);
 688
 689       /* Parse dialog template */
 690
 691     if (!dlgTemplate) return 0;
 692     dlgTemplate = DIALOG_ParseTemplate32( dlgTemplate, &template );
 693
 694       /* Load menu */
 695
 696     if (template.menuName) hMenu = LoadMenuW( hInst, template.menuName );
 697
 698       /* Create custom font if needed */
 699
 700     if (template.style & DS_SETFONT)
 701     {
 702           /* We convert the size to pixels and then make it -ve.  This works
 703            * for both +ve and -ve template.pointSize */
 704         HDC dc;
 705         int pixels;
 706         dc = GetDC(0);
 707         pixels = MulDiv(template.pointSize, GetDeviceCaps(dc , LOGPIXELSY), 72);
 708         hUserFont = CreateFontW( -pixels, 0, 0, 0, template.weight,
 709                                           template.italic, FALSE, FALSE, DEFAULT_CHARSET, 0, 0,
 710                                           PROOF_QUALITY, FF_DONTCARE,
 711                                           template.faceName );
 712         if (hUserFont)
 713         {
 714             SIZE charSize;
 715             HFONT hOldFont = SelectObject( dc, hUserFont );
 716             charSize.cx = GdiGetCharDimensions( dc, NULL, &charSize.cy );
 717             if (charSize.cx)
 718             {
 719                 xBaseUnit = charSize.cx;
 720                 yBaseUnit = charSize.cy;
 721             }
 722             SelectObject( dc, hOldFont );
 723         }
 724         ReleaseDC(0, dc);
 725         TRACE("units = %d,%d\n", xBaseUnit, yBaseUnit );
 726     }
 727
 728     /* Create dialog main window */
 729
 730     rect.left = rect.top = 0;
 731     rect.right = MulDiv(template.cx, xBaseUnit, 4);
 732     rect.bottom =  MulDiv(template.cy, yBaseUnit, 8);
 733     if (template.style & WS_CHILD)
 734         template.style &= ~(WS_CAPTION|WS_SYSMENU);
 735     if (template.style & DS_MODALFRAME)
 736         template.exStyle |= WS_EX_DLGMODALFRAME;
 737     if (template.style & DS_CONTROL)
 738         template.exStyle |= WS_EX_CONTROLPARENT;
 739     AdjustWindowRectEx( &rect, template.style, (hMenu != 0), template.exStyle );
 740     rect.right -= rect.left;
 741     rect.bottom -= rect.top;
 742
 743     if (template.x == CW_USEDEFAULT16)
 744     {
 745         rect.left = rect.top = CW_USEDEFAULT;
 746     }
 747     else
 748     {
 749         if (template.style & DS_CENTER)
 750         {
 751             rect.left = (GetSystemMetrics(SM_CXSCREEN) - rect.right) / 2;
 752             rect.top = (GetSystemMetrics(SM_CYSCREEN) - rect.bottom) / 2;
 753         }
 754         else
 755         {
 756             rect.left += MulDiv(template.x, xBaseUnit, 4);
 757             rect.top += MulDiv(template.y, yBaseUnit, 8);
 758             if( !(template.style & (WS_CHILD|DS_ABSALIGN)) )
 759                 ClientToScreen( owner, (POINT *)&rect );
 760         }
 761         if ( !(template.style & WS_CHILD) )
 762         {
 763             INT dX, dY;
 764
 765             /* try to fit it into the desktop */
 766
 767             if( (dX = rect.left + rect.right + GetSystemMetrics(SM_CXDLGFRAME)
 768                  - GetSystemMetrics(SM_CXSCREEN)) > 0 ) rect.left -= dX;
 769             if( (dY = rect.top + rect.bottom + GetSystemMetrics(SM_CYDLGFRAME)
 770                  - GetSystemMetrics(SM_CYSCREEN)) > 0 ) rect.top -= dY;
 771             if( rect.left < 0 ) rect.left = 0;
 772             if( rect.top < 0 ) rect.top = 0;
 773         }
 774     }
 775
 776     if (modal)
 777     {
 778         ownerEnabled = DIALOG_DisableOwner( owner );
 779         if (ownerEnabled) flags |= DF_OWNERENABLED;
 780     }
 781
 782     if (unicode)
 783     {
 784         hwnd = User32CreateWindowEx(template.exStyle, (LPCSTR)template.className, (LPCSTR)template.caption,
 785                                     template.style & ~WS_VISIBLE,
 786                                     rect.left, rect.top, rect.right, rect.bottom,
 787                                     owner, hMenu, hInst, NULL,
 788                                     TRUE);
 789     }
 790     else
 791     {
 792         LPSTR class = (LPSTR)template.className;
 793         LPSTR caption = (LPSTR)template.caption;
 794
 795         if (HIWORD(class))
 796         {
 797             DWORD len = WideCharToMultiByte( CP_ACP, 0, template.className, -1, NULL, 0, NULL, NULL );
 798             class = HeapAlloc( GetProcessHeap(), 0, len );
 799             if (class != NULL)
 800                 WideCharToMultiByte( CP_ACP, 0, template.className, -1, class, len, NULL, NULL );
 801         }
 802         if (HIWORD(caption))
 803         {
 804             DWORD len = WideCharToMultiByte( CP_ACP, 0, template.caption, -1, NULL, 0, NULL, NULL );
 805             caption = HeapAlloc( GetProcessHeap(), 0, len );
 806             if (caption != NULL)
 807                 WideCharToMultiByte( CP_ACP, 0, template.caption, -1, caption, len, NULL, NULL );
 808         }
 809
 810         if (class != NULL && caption != NULL)
 811         {
 812             hwnd = User32CreateWindowEx(template.exStyle, class, caption,
 813                                         template.style & ~WS_VISIBLE,
 814                                         rect.left, rect.top, rect.right, rect.bottom,
 815                                         owner, hMenu, hInst, NULL,
 816                                         FALSE);
 817         }
 818         else
 819             hwnd = NULL;
 820         if (HIWORD(class)) HeapFree( GetProcessHeap(), 0, class );
 821         if (HIWORD(caption)) HeapFree( GetProcessHeap(), 0, caption );
 822     }
 823
 824     if (!hwnd)
 825     {
 826         if (hUserFont) DeleteObject( hUserFont );
 827         if (hMenu) DestroyMenu( hMenu );
 828         if (modal && (flags & DF_OWNERENABLED)) DIALOG_EnableOwner(owner);
 829         return 0;
 830     }
 831
 832     /* moved this from the top of the method to here as DIALOGINFO structure
 833     will be valid only after WM_CREATE message has been handled in DefDlgProc
 834     All the members of the structure get filled here using temp variables */
 835
 836     dlgInfo = DIALOG_get_info( hwnd, TRUE );
 837     if (dlgInfo == NULL)
 838     {
 839         if (hUserFont) DeleteObject( hUserFont );
 840         if (hMenu) DestroyMenu( hMenu );
 841         if (modal && (flags & DF_OWNERENABLED)) DIALOG_EnableOwner(owner);
 842         return 0;
 843     }
 844
 845 //    dlgInfo->hwndFocus   = 0;
 846     dlgInfo->hUserFont   = hUserFont;
 847     dlgInfo->hMenu       = hMenu;
 848     dlgInfo->xBaseUnit   = xBaseUnit;
 849     dlgInfo->yBaseUnit   = yBaseUnit;
 850 //    dlgInfo->idResult    = 0;
 851     dlgInfo->flags       = flags;
 852 //    dlgInfo->hDialogHeap = 0;
 853
 854     if (template.helpId) SetWindowContextHelpId( hwnd, template.helpId );
 855
 856     if (unicode) SetWindowLongPtrW( hwnd, DWLP_DLGPROC, (ULONG_PTR)dlgProc );
 857     else SetWindowLongPtrA( hwnd, DWLP_DLGPROC, (ULONG_PTR)dlgProc );
 858
 859     if (dlgProc && dlgInfo->hUserFont)
 860         SendMessageW( hwnd, WM_SETFONT, (WPARAM)dlgInfo->hUserFont, 0 );
 861
 862     /* Create controls */
 863
 864     if (DIALOG_CreateControls32( hwnd, dlgTemplate, &template, hInst, unicode ))
 865     {
 866         /* Send initialisation messages and set focus */
 867         if (dlgProc)
 868         {
 869             if (SendMessageW( hwnd, WM_INITDIALOG, (WPARAM)dlgInfo->hwndFocus, param ) &&
 870                 ((~template.style & DS_CONTROL) || (template.style & WS_VISIBLE)))
 871             {
 872                 /* By returning TRUE, app has requested a default focus assignment */
 873                 dlgInfo->hwndFocus = GetNextDlgTabItem( hwnd, 0, FALSE);
 874                 if( dlgInfo->hwndFocus )
 875                     SetFocus( dlgInfo->hwndFocus );
 876             }
 877         }
 878         if (!(GetWindowLongW( hwnd, GWL_STYLE ) & WS_CHILD))
 879             SendMessageW( hwnd, WM_CHANGEUISTATE, MAKEWPARAM(UIS_INITIALIZE, 0), 0);
 880
 881         if (template.style & WS_VISIBLE && !(GetWindowLongW( hwnd, GWL_STYLE ) & WS_VISIBLE))
 882         {
 883            ShowWindow( hwnd, SW_SHOWNORMAL );   /* SW_SHOW doesn't always work */
 884         }
 885         return hwnd;
 886     }
 887     if (modal && ownerEnabled) DIALOG_EnableOwner(owner);
 888     if( IsWindow(hwnd) ) DestroyWindow( hwnd );
 889     return 0;
 890 }
 891
 892 /***********************************************************************
 893  *           DEFDLG_SetFocus
 894  *
 895  * Set the focus to a control of the dialog, selecting the text if
 896  * the control is an edit dialog.
 897  */
 898 static void DEFDLG_SetFocus( HWND hwndDlg, HWND hwndCtrl )
 899 {
 900     HWND hwndPrev = GetFocus();
 901
 902     if (IsChild( hwndDlg, hwndPrev ))
 903     {
 904         if (SendMessageW( hwndPrev, WM_GETDLGCODE, 0, 0 ) & DLGC_HASSETSEL)
 905             SendMessageW( hwndPrev, EM_SETSEL, -1, 0 );
 906     }
 907     if (SendMessageW( hwndCtrl, WM_GETDLGCODE, 0, 0 ) & DLGC_HASSETSEL)
 908         SendMessageW( hwndCtrl, EM_SETSEL, 0, -1 );
 909     SetFocus( hwndCtrl );
 910 }
 911
 912 /***********************************************************************
 913  *           DEFDLG_SaveFocus
 914  */
 915 static void DEFDLG_SaveFocus( HWND hwnd )
 916 {
 917     DIALOGINFO *infoPtr;
 918     HWND hwndFocus = GetFocus();
 919
 920     if (!hwndFocus || !IsChild( hwnd, hwndFocus )) return;
 921     if (!(infoPtr = GETDLGINFO(hwnd))) return;
 922     infoPtr->hwndFocus = hwndFocus;
 923     /* Remove default button */
 924 }
 925
 926 /***********************************************************************
 927  *           DEFDLG_RestoreFocus
 928  */
 929 static void DEFDLG_RestoreFocus( HWND hwnd )
 930 {
 931     DIALOGINFO *infoPtr;
 932
 933     if (IsIconic( hwnd )) return;
 934     if (!(infoPtr = GETDLGINFO(hwnd))) return;
 935     /* Don't set the focus back to controls if EndDialog is already called.*/
 936     if (infoPtr->flags & DF_END) return;
 937     if (!IsWindow(infoPtr->hwndFocus) || infoPtr->hwndFocus == hwnd) {
 938         /* If no saved focus control exists, set focus to the first visible,
 939            non-disabled, WS_TABSTOP control in the dialog */
 940         infoPtr->hwndFocus = GetNextDlgTabItem( hwnd, 0, FALSE );
 941        if (!IsWindow( infoPtr->hwndFocus )) return;
 942     }
 943     SetFocus( infoPtr->hwndFocus );
 944
 945     /* This used to set infoPtr->hwndFocus to NULL for no apparent reason,
 946        sometimes losing focus when receiving WM_SETFOCUS messages. */
 947 }
 948
 949 /***********************************************************************
 950  *           DEFDLG_FindDefButton
 951  *
 952  * Find the current default push-button.
 953  */
 954 static HWND DEFDLG_FindDefButton( HWND hwndDlg )
 955 {
 956     HWND hwndChild, hwndTmp;
 957
 958     hwndChild = GetWindow( hwndDlg, GW_CHILD );
 959     while (hwndChild)
 960     {
 961         if (SendMessageW( hwndChild, WM_GETDLGCODE, 0, 0 ) & DLGC_DEFPUSHBUTTON)
 962             break;
 963
 964         /* Recurse into WS_EX_CONTROLPARENT controls */
 965         if (GetWindowLongW( hwndChild, GWL_EXSTYLE ) & WS_EX_CONTROLPARENT)
 966         {
 967             LONG dsStyle = GetWindowLongW( hwndChild, GWL_STYLE );
 968             if ((dsStyle & WS_VISIBLE) && !(dsStyle & WS_DISABLED) &&
 969                 (hwndTmp = DEFDLG_FindDefButton(hwndChild)) != NULL)
 970            return hwndTmp;
 971         }
 972         hwndChild = GetWindow( hwndChild, GW_HWNDNEXT );
 973     }
 974     return hwndChild;
 975 }
 976
 977 /***********************************************************************
 978  *           DEFDLG_SetDefId
 979  *
 980  * Set the default button id.
 981  */
 982 static BOOL DEFDLG_SetDefId( HWND hwndDlg, DIALOGINFO *dlgInfo, WPARAM wParam)
 983 {
 984     DWORD dlgcode=0; /* initialize just to avoid a warning */
 985     HWND hwndOld, hwndNew = GetDlgItem(hwndDlg, wParam);
 986     INT old_id = dlgInfo->idResult;
 987
 988     dlgInfo->idResult = wParam;
 989     if (hwndNew &&
 990         !((dlgcode=SendMessageW(hwndNew, WM_GETDLGCODE, 0, 0 ))
 991             & (DLGC_UNDEFPUSHBUTTON | DLGC_BUTTON)))
 992         return FALSE;  /* Destination is not a push button */
 993
 994     /* Make sure the old default control is a valid push button ID */
 995     hwndOld = GetDlgItem( hwndDlg, old_id );
 996     if (!hwndOld || !(SendMessageW( hwndOld, WM_GETDLGCODE, 0, 0) & DLGC_DEFPUSHBUTTON))
 997         hwndOld = DEFDLG_FindDefButton( hwndDlg );
 998     if (hwndOld && hwndOld != hwndNew)
 999         SendMessageW( hwndOld, BM_SETSTYLE, BS_PUSHBUTTON, TRUE );
1000
1001     if (hwndNew)
1002     {
1003         if(dlgcode & DLGC_UNDEFPUSHBUTTON)
1004             SendMessageW( hwndNew, BM_SETSTYLE, BS_DEFPUSHBUTTON, TRUE );
1005     }
1006     return TRUE;
1007 }
1008
1009 /***********************************************************************
1010  *           DEFDLG_SetDefButton
1011  *
1012  * Set the new default button to be hwndNew.
1013  */
1014 static BOOL DEFDLG_SetDefButton( HWND hwndDlg, DIALOGINFO *dlgInfo, HWND hwndNew )
1015 {
1016     DWORD dlgcode=0; /* initialize just to avoid a warning */
1017     HWND hwndOld = GetDlgItem( hwndDlg, dlgInfo->idResult );
1018
1019     if (hwndNew &&
1020         !((dlgcode=SendMessageW(hwndNew, WM_GETDLGCODE, 0, 0 ))
1021             & (DLGC_UNDEFPUSHBUTTON | DLGC_DEFPUSHBUTTON)))
1022     {
1023         /**
1024          * Need to draw only default push button rectangle.
1025          * Since the next control is not a push button, need to draw the push
1026          * button rectangle for the default control.
1027          */
1028         hwndNew = hwndOld;
1029         dlgcode = SendMessageW(hwndNew, WM_GETDLGCODE, 0, 0 );
1030     }
1031
1032     /* Make sure the old default control is a valid push button ID */
1033     if (!hwndOld || !(SendMessageW( hwndOld, WM_GETDLGCODE, 0, 0) & DLGC_DEFPUSHBUTTON))
1034         hwndOld = DEFDLG_FindDefButton( hwndDlg );
1035     if (hwndOld && hwndOld != hwndNew)
1036         SendMessageW( hwndOld, BM_SETSTYLE, BS_PUSHBUTTON, TRUE );
1037
1038     if (hwndNew)
1039     {
1040         if(dlgcode & DLGC_UNDEFPUSHBUTTON)
1041             SendMessageW( hwndNew, BM_SETSTYLE, BS_DEFPUSHBUTTON, TRUE );
1042     }
1043     return TRUE;
1044 }
1045
1046 /***********************************************************************
1047  *           DEFDLG_Proc
1048  *
1049  * Implementation of DefDlgProc(). Only handle messages that need special
1050  * handling for dialogs.
1051  */
1052 static LRESULT DEFDLG_Proc( HWND hwnd, UINT msg, WPARAM wParam,
1053                             LPARAM lParam, DIALOGINFO *dlgInfo )
1054 {
1055     switch(msg)
1056     {
1057         case WM_ERASEBKGND:
1058         {
1059             HBRUSH brush = (HBRUSH)SendMessageW( hwnd, WM_CTLCOLORDLG, wParam, (LPARAM)hwnd );
1060             if (!brush) brush = (HBRUSH)DefWindowProcW( hwnd, WM_CTLCOLORDLG, wParam, (LPARAM)hwnd );
1061             if (brush)
1062             {
1063                 RECT rect;
1064                 HDC hdc = (HDC)wParam;
1065                 GetClientRect( hwnd, &rect );
1066                 DPtoLP( hdc, (LPPOINT)&rect, 2 );
1067                 FillRect( hdc, &rect, brush );
1068             }
1069             return 1;
1070         }
1071         case WM_NCDESTROY:
1072             if ((dlgInfo = (DIALOGINFO *)SetWindowLongPtrW( hwnd, DWLP_ROS_DIALOGINFO, 0 )))
1073             {
1074                 /* Free dialog heap (if created) */
1075                 /*if (dlgInfo->hDialogHeap)
1076                 {
1077                     GlobalUnlock16(dlgInfo->hDialogHeap);
1078                     GlobalFree16(dlgInfo->hDialogHeap);
1079                 }*/
1080                 if (dlgInfo->hUserFont) DeleteObject( dlgInfo->hUserFont );
1081                 if (dlgInfo->hMenu) DestroyMenu( dlgInfo->hMenu );
1082                 HeapFree( GetProcessHeap(), 0, dlgInfo );
1083             }
1084              /* Window clean-up */
1085             return DefWindowProcA( hwnd, msg, wParam, lParam );
1086
1087         case WM_SHOWWINDOW:
1088             if (!wParam) DEFDLG_SaveFocus( hwnd );
1089             return DefWindowProcA( hwnd, msg, wParam, lParam );
1090
1091         case WM_ACTIVATE:
1092             if (wParam) DEFDLG_RestoreFocus( hwnd );
1093             else DEFDLG_SaveFocus( hwnd );
1094             return 0;
1095
1096         case WM_SETFOCUS:
1097             DEFDLG_RestoreFocus( hwnd );
1098             return 0;
1099
1100         case DM_SETDEFID:
1101             if (dlgInfo && !(dlgInfo->flags & DF_END))
1102                 DEFDLG_SetDefId( hwnd, dlgInfo, wParam );
1103             return 1;
1104
1105         case DM_GETDEFID:
1106             if (dlgInfo && !(dlgInfo->flags & DF_END))
1107             {
1108                 HWND hwndDefId;
1109                 if (dlgInfo->idResult)
1110                     return MAKELONG( dlgInfo->idResult, DC_HASDEFID );
1111                 if ((hwndDefId = DEFDLG_FindDefButton( hwnd )))
1112                     return MAKELONG( GetDlgCtrlID( hwndDefId ), DC_HASDEFID);
1113             }
1114             return 0;
1115
1116         case WM_NEXTDLGCTL:
1117             if (dlgInfo)
1118             {
1119                 HWND hwndDest = (HWND)wParam;
1120                 if (!lParam)
1121                     hwndDest = GetNextDlgTabItem(hwnd, GetFocus(), wParam);
1122                 if (hwndDest) DEFDLG_SetFocus( hwnd, hwndDest );
1123                 DEFDLG_SetDefButton( hwnd, dlgInfo, hwndDest );
1124             }
1125             return 0;
1126
1127         case WM_ENTERMENULOOP:
1128         case WM_LBUTTONDOWN:
1129         case WM_NCLBUTTONDOWN:
1130             {
1131                 HWND hwndFocus = GetFocus();
1132                 if (hwndFocus)
1133                 {
1134                     /* always make combo box hide its listbox control */
1135                     if (!SendMessageW( hwndFocus, CB_SHOWDROPDOWN, FALSE, 0 ))
1136                         SendMessageW( GetParent(hwndFocus), CB_SHOWDROPDOWN, FALSE, 0 );
1137                 }
1138             }
1139             return DefWindowProcA( hwnd, msg, wParam, lParam );
1140
1141         case WM_GETFONT:
1142             return dlgInfo ? (LRESULT)dlgInfo->hUserFont : 0;
1143
1144         case WM_CLOSE:
1145             PostMessageA( hwnd, WM_COMMAND, MAKEWPARAM(IDCANCEL, BN_CLICKED),
1146                             (LPARAM)GetDlgItem( hwnd, IDCANCEL ) );
1147             return 0;
1148     }
1149     return 0;
1150 }
1151
1152 /***********************************************************************
1153  *           DEFDLG_Epilog
1154  */
1155 static LRESULT DEFDLG_Epilog(HWND hwnd, UINT msg, BOOL fResult)
1156 {
1157
1158     // TODO: where's wine's WM_CTLCOLOR from?
1159     if ((msg >= WM_CTLCOLORMSGBOX && msg <= WM_CTLCOLORSTATIC) ||
1160          msg == WM_CTLCOLOR ||  msg == WM_COMPAREITEM ||
1161          msg == WM_VKEYTOITEM || msg == WM_CHARTOITEM ||
1162          msg == WM_QUERYDRAGICON || msg == WM_INITDIALOG)
1163         return fResult;
1164
1165     return GetWindowLongPtrW( hwnd, DWLP_MSGRESULT );
1166 }
1167
1168 /***********************************************************************
1169  *           DIALOG_GetNextTabItem
1170  *
1171  * Helper for GetNextDlgTabItem
1172  */
1173 static HWND DIALOG_GetNextTabItem( HWND hwndMain, HWND hwndDlg, HWND hwndCtrl, BOOL fPrevious )
1174 {
1175     LONG dsStyle;
1176     LONG exStyle;
1177     UINT wndSearch = fPrevious ? GW_HWNDPREV : GW_HWNDNEXT;
1178     HWND retWnd = 0;
1179     HWND hChildFirst = 0;
1180
1181     if(!hwndCtrl)
1182     {
1183         hChildFirst = GetWindow(hwndDlg,GW_CHILD);
1184         if(fPrevious) hChildFirst = GetWindow(hChildFirst,GW_HWNDLAST);
1185     }
1186     else if (IsChild( hwndMain, hwndCtrl ))
1187     {
1188         hChildFirst = GetWindow(hwndCtrl,wndSearch);
1189         if(!hChildFirst)
1190         {
1191             if(GetParent(hwndCtrl) != hwndMain)
1192                 /* i.e. if we are not at the top level of the recursion */
1193                 hChildFirst = GetWindow(GetParent(hwndCtrl),wndSearch);
1194             else
1195                 hChildFirst = GetWindow(hwndCtrl, fPrevious ? GW_HWNDLAST : GW_HWNDFIRST);
1196         }
1197     }
1198
1199     while(hChildFirst)
1200     {
1201         dsStyle = GetWindowLongA(hChildFirst,GWL_STYLE);
1202         exStyle = GetWindowLongA(hChildFirst,GWL_EXSTYLE);
1203         if( (exStyle & WS_EX_CONTROLPARENT) && (dsStyle & WS_VISIBLE) && !(dsStyle & WS_DISABLED))
1204         {
1205             HWND retWnd;
1206             retWnd = DIALOG_GetNextTabItem(hwndMain,hChildFirst,NULL,fPrevious );
1207             if (retWnd) return (retWnd);
1208         }
1209         else if( (dsStyle & WS_TABSTOP) && (dsStyle & WS_VISIBLE) && !(dsStyle & WS_DISABLED))
1210         {
1211             return (hChildFirst);
1212         }
1213         hChildFirst = GetWindow(hChildFirst,wndSearch);
1214     }
1215     if(hwndCtrl)
1216     {
1217         HWND hParent = GetParent(hwndCtrl);
1218         while(hParent)
1219         {
1220             if(hParent == hwndMain) break;
1221             retWnd = DIALOG_GetNextTabItem(hwndMain,GetParent(hParent),hParent,fPrevious );
1222             if(retWnd) break;
1223             hParent = GetParent(hParent);
1224         }
1225         if(!retWnd)
1226             retWnd = DIALOG_GetNextTabItem(hwndMain,hwndMain,NULL,fPrevious );
1227     }
1228     return retWnd ? retWnd : hwndCtrl;
1229
1230 }
1231
1232 /**********************************************************************
1233  *          DIALOG_DlgDirListW
1234  *
1235  * Helper function for DlgDirList*W
1236  */
1237 static INT DIALOG_DlgDirListW( HWND hDlg, LPWSTR spec, INT idLBox,
1238                                 INT idStatic, UINT attrib, BOOL combo )
1239 {
1240     HWND hwnd;
1241     LPWSTR orig_spec = spec;
1242     WCHAR any[] = {'*','.','*',0};
1243
1244 #define SENDMSG(msg,wparam,lparam) \
1245     ((attrib & DDL_POSTMSGS) ? PostMessageW( hwnd, msg, wparam, lparam ) \
1246                              : SendMessageW( hwnd, msg, wparam, lparam ))
1247
1248 //    TRACE("%p '%s' %d %d %04x\n",
1249 //          hDlg, spec ? spec : "NULL", idLBox, idStatic, attrib );
1250
1251     /* If the path exists and is a directory, chdir to it */
1252     if (!spec || !spec[0] || SetCurrentDirectoryW( spec )) spec = any;
1253     else
1254     {
1255         WCHAR *p, *p2;
1256         p = spec;
1257         if ((p2 = strchrW( p, ':' ))) p = p2 + 1;
1258         if ((p2 = strrchrW( p, '\\' ))) p = p2;
1259         if ((p2 = strrchrW( p, '/' ))) p = p2;
1260         if (p != spec)
1261         {
1262             WCHAR sep = *p;
1263             *p = 0;
1264             if (!SetCurrentDirectoryW( spec ))
1265             {
1266                 *p = sep;  /* Restore the original spec */
1267                 return FALSE;
1268             }
1269             spec = p + 1;
1270         }
1271     }
1272
1273     TRACE( "mask=%s\n", spec );
1274
1275     if (idLBox && ((hwnd = GetDlgItem( hDlg, idLBox )) != 0))
1276     {
1277         if (attrib == DDL_DRIVES) attrib |= DDL_EXCLUSIVE;
1278
1279         SENDMSG( combo ? CB_RESETCONTENT : LB_RESETCONTENT, 0, 0 );
1280         if (attrib & DDL_DIRECTORY)
1281         {
1282             if (!(attrib & DDL_EXCLUSIVE))
1283             {
1284                 SENDMSG( combo ? CB_DIR : LB_DIR,
1285                          attrib & ~(DDL_DIRECTORY | DDL_DRIVES),
1286                          (LPARAM)spec );
1287             }
1288             SENDMSG( combo ? CB_DIR : LB_DIR,
1289                    (attrib & (DDL_DIRECTORY | DDL_DRIVES)) | DDL_EXCLUSIVE,
1290                    (LPARAM)any );
1291         }
1292         else
1293         {
1294             SENDMSG( combo ? CB_DIR : LB_DIR, attrib, (LPARAM)spec );
1295         }
1296     }
1297
1298     /* Convert path specification to uppercase */
1299     if (spec) CharUpperW(spec);
1300
1301     if (idStatic && ((hwnd = GetDlgItem( hDlg, idStatic )) != 0))
1302     {
1303         WCHAR temp[MAX_PATH];
1304         GetCurrentDirectoryW( sizeof(temp)/sizeof(WCHAR), temp );
1305         CharLowerW( temp );
1306         /* Can't use PostMessage() here, because the string is on the stack */
1307         SetDlgItemTextW( hDlg, idStatic, temp );
1308     }
1309
1310     if (orig_spec && (spec != orig_spec))
1311     {
1312         /* Update the original file spec */
1313         WCHAR *p = spec;
1314         while ((*orig_spec++ = *p++));
1315     }
1316
1317     return TRUE;
1318 #undef SENDMSG
1319 }
1320
1321 /**********************************************************************
1322  *          DIALOG_DlgDirListA
1323  *
1324  * Helper function for DlgDirList*A
1325  */
1326 static INT DIALOG_DlgDirListA( HWND hDlg, LPSTR spec, INT idLBox,
1327                                INT idStatic, UINT attrib, BOOL combo )
1328 {
1329     if (spec)
1330     {
1331         INT ret, len = MultiByteToWideChar( CP_ACP, 0, spec, -1, NULL, 0 );
1332         LPWSTR specW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
1333         if (specW == NULL)
1334             return FALSE;
1335         MultiByteToWideChar( CP_ACP, 0, spec, -1, specW, len );
1336         ret = DIALOG_DlgDirListW( hDlg, specW, idLBox, idStatic, attrib, combo );
1337         WideCharToMultiByte( CP_ACP, 0, specW, -1, spec, 0x7fffffff, NULL, NULL );
1338         HeapFree( GetProcessHeap(), 0, specW );
1339         return ret;
1340     }
1341     return DIALOG_DlgDirListW( hDlg, NULL, idLBox, idStatic, attrib, combo );
1342 }
1343
1344 /**********************************************************************
1345  *           DIALOG_DlgDirSelect
1346  *
1347  * Helper function for DlgDirSelect*
1348  */
1349 static BOOL DIALOG_DlgDirSelect( HWND hwnd, LPWSTR str, INT len,
1350                                  INT id, BOOL unicode, BOOL combo )
1351 {
1352     WCHAR *buffer, *ptr;
1353     INT item, size;
1354     BOOL ret;
1355     HWND listbox = GetDlgItem( hwnd, id );
1356
1357     TRACE("%p %s %d\n", hwnd, unicode ? debugstr_w(str) : debugstr_a((LPSTR)str), id );
1358     if (!listbox) return FALSE;
1359
1360     item = SendMessageW(listbox, combo ? CB_GETCURSEL : LB_GETCURSEL, 0, 0 );
1361     if (item == LB_ERR) return FALSE;
1362
1363     size = SendMessageW(listbox, combo ? CB_GETLBTEXTLEN : LB_GETTEXTLEN, item, 0 );
1364     if (size == LB_ERR) return FALSE;
1365
1366     if (!(buffer = HeapAlloc( GetProcessHeap(), 0, (size+2) * sizeof(WCHAR) ))) return FALSE;
1367
1368     SendMessageW( listbox, combo ? CB_GETLBTEXT : LB_GETTEXT, item, (LPARAM)buffer );
1369
1370     if ((ret = (buffer[0] == '[')))  /* drive or directory */
1371     {
1372         if (buffer[1] == '-')  /* drive */
1373         {
1374             buffer[3] = ':';
1375             buffer[4] = 0;
1376             ptr = buffer + 2;
1377         }
1378         else
1379         {
1380             buffer[strlenW(buffer)-1] = '\\';
1381             ptr = buffer + 1;
1382         }
1383     }
1384     else
1385     {
1386         /* Filenames without a dot extension must have one tacked at the end */
1387         if (strchrW(buffer, '.') == NULL)
1388         {
1389             buffer[strlenW(buffer)+1] = '\0';
1390             buffer[strlenW(buffer)] = '.';
1391         }
1392         ptr = buffer;
1393     }
1394
1395     if (!unicode)
1396     {
1397         if (len > 0 && !WideCharToMultiByte( CP_ACP, 0, ptr, -1, (LPSTR)str, len, 0, 0 ))
1398             ((LPSTR)str)[len-1] = 0;
1399     }
1400     else lstrcpynW( str, ptr, len );
1401     HeapFree( GetProcessHeap(), 0, buffer );
1402     TRACE("Returning %d %s\n", ret, unicode ? debugstr_w(str) : debugstr_a((LPSTR)str) );
1403     return ret;
1404 }
1405
1406 /***********************************************************************
1407  *           GetDlgItemEnumProc
1408  *
1409  * Callback for GetDlgItem
1410  */
1411 BOOL CALLBACK GetDlgItemEnumProc (HWND hwnd, LPARAM lParam )
1412 {
1413     GETDLGITEMINFO * info = (GETDLGITEMINFO *)lParam;
1414     if(info->nIDDlgItem == GetWindowLongW( hwnd, GWL_ID ))
1415     {
1416         info->control = hwnd;
1417         return FALSE;
1418     }
1419     return TRUE;
1420 }
1421
1422
1423 /* FUNCTIONS *****************************************************************/
1424
1425 /*
1426  * @implemented
1427  */
1428 HWND
1429 WINAPI
1430 CreateDialogIndirectParamAorW(
1431   HINSTANCE hInstance,
1432   LPCDLGTEMPLATE lpTemplate,
1433   HWND hWndParent,
1434   DLGPROC lpDialogFunc,
1435   LPARAM lParamInit,
1436   DWORD Flags)
1437 {
1438 /* FIXME:
1439  *   This function might be obsolete since I don't think it is exported by NT
1440  *   Also wine has one more parameter identifying weather it should call
1441  *   the function with unicode or not
1442  */
1443   return DIALOG_CreateIndirect( hInstance, lpTemplate, hWndParent, lpDialogFunc, lParamInit , !Flags, FALSE );
1444 }
1445
1446
1447 /*
1448  * @implemented
1449  */
1450 HWND
1451 WINAPI
1452 CreateDialogIndirectParamA(
1453   HINSTANCE hInstance,
1454   LPCDLGTEMPLATE lpTemplate,
1455   HWND hWndParent,
1456   DLGPROC lpDialogFunc,
1457   LPARAM lParamInit)
1458 {
1459   return CreateDialogIndirectParamAorW( hInstance, lpTemplate, hWndParent, lpDialogFunc, lParamInit, 2 );
1460 }
1461
1462
1463 /*
1464  * @implemented
1465  */
1466 HWND
1467 WINAPI
1468 CreateDialogIndirectParamW(
1469   HINSTANCE hInstance,
1470   LPCDLGTEMPLATE lpTemplate,
1471   HWND hWndParent,
1472   DLGPROC lpDialogFunc,
1473   LPARAM lParamInit)
1474 {
1475   return CreateDialogIndirectParamAorW( hInstance, lpTemplate, hWndParent, lpDialogFunc, lParamInit, 0);
1476 }
1477
1478
1479 /*
1480  * @implemented
1481  */
1482 HWND
1483 WINAPI
1484 CreateDialogParamA(
1485   HINSTANCE hInstance,
1486   LPCSTR lpTemplateName,
1487   HWND hWndParent,
1488   DLGPROC lpDialogFunc,
1489   LPARAM dwInitParam)
1490 {
1491         HRSRC hrsrc;
1492         LPCDLGTEMPLATE ptr;
1493
1494     if (!(hrsrc = FindResourceA( hInstance, lpTemplateName, (LPCSTR)RT_DIALOG ))) return 0;
1495     if (!(ptr = (LPCDLGTEMPLATE)LoadResource(hInstance, hrsrc))) return 0;
1496         return CreateDialogIndirectParamA( hInstance, ptr, hWndParent, lpDialogFunc, dwInitParam );
1497 }
1498
1499
1500 /*
1501  * @implemented
1502  */
1503 HWND
1504 WINAPI
1505 CreateDialogParamW(
1506   HINSTANCE hInstance,
1507   LPCWSTR lpTemplateName,
1508   HWND hWndParent,
1509   DLGPROC lpDialogFunc,
1510   LPARAM dwInitParam)
1511 {
1512         HRSRC hrsrc;
1513         LPCDLGTEMPLATE ptr;
1514
1515         if (!(hrsrc = FindResourceW( hInstance, lpTemplateName, (LPCWSTR)RT_DIALOG ))) return 0;
1516         if (!(ptr = (LPCDLGTEMPLATE)LoadResource(hInstance, hrsrc))) return 0;
1517         return CreateDialogIndirectParamW( hInstance, ptr, hWndParent, lpDialogFunc, dwInitParam );
1518 }
1519
1520
1521 /*
1522  * @implemented
1523  */
1524 LRESULT
1525 WINAPI
1526 DefDlgProcA(
1527   HWND hDlg,
1528   UINT Msg,
1529   WPARAM wParam,
1530   LPARAM lParam)
1531 {
1532     WNDPROC dlgproc;
1533     BOOL result = FALSE;
1534     DIALOGINFO * dlgInfo;
1535
1536         /* if there's no dialog info property then call default windows proc?? */
1537     if (!(dlgInfo = DIALOG_get_info(hDlg, TRUE)))
1538             return DefWindowProcA( hDlg, Msg, wParam, lParam );
1539
1540     SetWindowLongPtrW( hDlg, DWLP_MSGRESULT, 0 );
1541
1542     if ((dlgproc = (WNDPROC)GetWindowLongPtrW( hDlg, DWLP_DLGPROC )))
1543     {
1544         /* Call dialog procedure */
1545         result = CallWindowProcA( dlgproc, hDlg, Msg, wParam, lParam );
1546     }
1547
1548     if (!result && IsWindow(hDlg))
1549     {
1550         /* callback didn't process this message */
1551
1552         switch(Msg)
1553         {
1554             case WM_ERASEBKGND:
1555             case WM_SHOWWINDOW:
1556             case WM_ACTIVATE:
1557             case WM_SETFOCUS:
1558             case DM_SETDEFID:
1559             case DM_GETDEFID:
1560             case WM_NEXTDLGCTL:
1561             case WM_GETFONT:
1562             case WM_CLOSE:
1563             case WM_NCDESTROY:
1564             case WM_ENTERMENULOOP:
1565             case WM_LBUTTONDOWN:
1566             case WM_NCLBUTTONDOWN:
1567                  return DEFDLG_Proc( hDlg, Msg, wParam, lParam, dlgInfo );
1568             case WM_INITDIALOG:
1569             case WM_VKEYTOITEM:
1570             case WM_COMPAREITEM:
1571             case WM_CHARTOITEM:
1572                  break;
1573
1574             default:
1575                  return DefWindowProcA( hDlg, Msg, wParam, lParam );
1576         }
1577     }
1578     return DEFDLG_Epilog(hDlg, Msg, result);
1579 }
1580
1581
1582 /*
1583  * @implemented
1584  */
1585 LRESULT
1586 WINAPI
1587 DefDlgProcW(
1588   HWND hDlg,
1589   UINT Msg,
1590   WPARAM wParam,
1591   LPARAM lParam)
1592 {
1593     WNDPROC dlgproc;
1594     BOOL result = FALSE;
1595     DIALOGINFO * dlgInfo;
1596
1597         /* if there's no dialog info property then call default windows proc?? */
1598     if (!(dlgInfo = DIALOG_get_info(hDlg, TRUE)))
1599             return DefWindowProcW( hDlg, Msg, wParam, lParam );
1600
1601     SetWindowLongPtrW( hDlg, DWLP_MSGRESULT, 0 );
1602
1603     if ((dlgproc = (WNDPROC)GetWindowLongPtrW( hDlg, DWLP_DLGPROC )))
1604     {
1605         /* Call dialog procedure */
1606         result = CallWindowProcW( dlgproc, hDlg, Msg, wParam, lParam );
1607     }
1608
1609     if (!result && IsWindow(hDlg))
1610     {
1611         /* callback didn't process this message */
1612
1613         switch(Msg)
1614         {
1615             case WM_ERASEBKGND:
1616             case WM_SHOWWINDOW:
1617             case WM_ACTIVATE:
1618             case WM_SETFOCUS:
1619             case DM_SETDEFID:
1620             case DM_GETDEFID:
1621             case WM_NEXTDLGCTL:
1622             case WM_GETFONT:
1623             case WM_CLOSE:
1624             case WM_NCDESTROY:
1625             case WM_ENTERMENULOOP:
1626             case WM_LBUTTONDOWN:
1627             case WM_NCLBUTTONDOWN:
1628                  return DEFDLG_Proc( hDlg, Msg, wParam, lParam, dlgInfo );
1629             case WM_INITDIALOG:
1630             case WM_VKEYTOITEM:
1631             case WM_COMPAREITEM:
1632             case WM_CHARTOITEM:
1633                  break;
1634
1635             default:
1636                  return DefWindowProcW( hDlg, Msg, wParam, lParam );
1637         }
1638     }
1639     return DEFDLG_Epilog(hDlg, Msg, result);
1640 }
1641
1642
1643 /*
1644  * @implemented
1645  */
1646 INT_PTR
1647 WINAPI
1648 DialogBoxIndirectParamAorW(
1649   HINSTANCE hInstance,
1650   LPCDLGTEMPLATE hDialogTemplate,
1651   HWND hWndParent,
1652   DLGPROC lpDialogFunc,
1653   LPARAM dwInitParam,
1654   DWORD Flags)
1655 {
1656 /* FIXME:
1657  *  This function might be obsolete since I don't think it is exported by NT
1658  *  Also wine has one more parameter identifying weather it should call
1659  *  the function with unicode or not
1660  */
1661   HWND hWnd = DIALOG_CreateIndirect( hInstance, hDialogTemplate, hWndParent, lpDialogFunc, dwInitParam, !Flags, TRUE );
1662   if (hWnd) return DIALOG_DoDialogBox( hWnd, hWndParent );
1663   return -1;
1664 }
1665
1666
1667 /*
1668  * @implemented
1669  */
1670 INT_PTR
1671 WINAPI
1672 DialogBoxIndirectParamA(
1673   HINSTANCE hInstance,
1674   LPCDLGTEMPLATE hDialogTemplate,
1675   HWND hWndParent,
1676   DLGPROC lpDialogFunc,
1677   LPARAM dwInitParam)
1678 {
1679   return DialogBoxIndirectParamAorW( hInstance, hDialogTemplate, hWndParent, lpDialogFunc, dwInitParam, 2);
1680 }
1681
1682
1683 /*
1684  * @implemented
1685  */
1686 INT_PTR
1687 WINAPI
1688 DialogBoxIndirectParamW(
1689   HINSTANCE hInstance,
1690   LPCDLGTEMPLATE hDialogTemplate,
1691   HWND hWndParent,
1692   DLGPROC lpDialogFunc,
1693   LPARAM dwInitParam)
1694 {
1695   return DialogBoxIndirectParamAorW( hInstance, hDialogTemplate, hWndParent, lpDialogFunc, dwInitParam, 0);
1696 }
1697
1698
1699 /*
1700  * @implemented
1701  */
1702 INT_PTR
1703 WINAPI
1704 DialogBoxParamA(
1705   HINSTANCE hInstance,
1706   LPCSTR lpTemplateName,
1707   HWND hWndParent,
1708   DLGPROC lpDialogFunc,
1709   LPARAM dwInitParam)
1710 {
1711     HWND hwnd;
1712     HRSRC hrsrc;
1713     LPCDLGTEMPLATE ptr;
1714
1715     if (!(hrsrc = FindResourceA( hInstance, lpTemplateName, (LPCSTR)RT_DIALOG )) ||
1716         !(ptr = (LPCDLGTEMPLATE)LoadResource(hInstance, hrsrc)))
1717     {
1718         SetLastError(ERROR_RESOURCE_NAME_NOT_FOUND);
1719         return -1;
1720     }
1721     if (hWndParent != NULL && !IsWindow(hWndParent))
1722     {
1723         SetLastError(ERROR_INVALID_WINDOW_HANDLE);
1724         return 0;
1725     }
1726     hwnd = DIALOG_CreateIndirect(hInstance, ptr, hWndParent, lpDialogFunc, dwInitParam, FALSE, TRUE);
1727     if (hwnd) return DIALOG_DoDialogBox(hwnd, hWndParent);
1728     return -1;
1729 }
1730
1731
1732 /*
1733  * @implemented
1734  */
1735 INT_PTR
1736 WINAPI
1737 DialogBoxParamW(
1738   HINSTANCE hInstance,
1739   LPCWSTR lpTemplateName,
1740   HWND hWndParent,
1741   DLGPROC lpDialogFunc,
1742   LPARAM dwInitParam)
1743 {
1744     HWND hwnd;
1745     HRSRC hrsrc;
1746     LPCDLGTEMPLATE ptr;
1747
1748     if (!(hrsrc = FindResourceW( hInstance, lpTemplateName, (LPCWSTR)RT_DIALOG )) ||
1749         !(ptr = (LPCDLGTEMPLATE)LoadResource(hInstance, hrsrc)))
1750     {
1751         SetLastError(ERROR_RESOURCE_NAME_NOT_FOUND);
1752         return -1;
1753     }
1754     if (hWndParent != NULL && !IsWindow(hWndParent))
1755     {
1756         SetLastError(ERROR_INVALID_WINDOW_HANDLE);
1757         return 0;
1758     }
1759     hwnd = DIALOG_CreateIndirect(hInstance, ptr, hWndParent, lpDialogFunc, dwInitParam, TRUE, TRUE);
1760     if (hwnd) return DIALOG_DoDialogBox(hwnd, hWndParent);
1761     return -1;
1762 }
1763
1764
1765 /*
1766  * @implemented
1767  */
1768 int
1769 WINAPI
1770 DlgDirListA(
1771   HWND hDlg,
1772   LPSTR lpPathSpec,
1773   int nIDListBox,
1774   int nIDStaticPath,
1775   UINT uFileType)
1776 {
1777     return DIALOG_DlgDirListA( hDlg, lpPathSpec, nIDListBox, nIDStaticPath, uFileType, FALSE );
1778 }
1779
1780
1781 /*
1782  * @implemented
1783  */
1784 int
1785 WINAPI
1786 DlgDirListComboBoxA(
1787   HWND hDlg,
1788   LPSTR lpPathSpec,
1789   int nIDComboBox,
1790   int nIDStaticPath,
1791   UINT uFiletype)
1792 {
1793   return DIALOG_DlgDirListA( hDlg, lpPathSpec, nIDComboBox, nIDStaticPath, uFiletype, TRUE );
1794 }
1795
1796
1797 /*
1798  * @implemented
1799  */
1800 int
1801 WINAPI
1802 DlgDirListComboBoxW(
1803   HWND hDlg,
1804   LPWSTR lpPathSpec,
1805   int nIDComboBox,
1806   int nIDStaticPath,
1807   UINT uFiletype)
1808 {
1809   return DIALOG_DlgDirListW( hDlg, lpPathSpec, nIDComboBox, nIDStaticPath, uFiletype, TRUE );
1810 }
1811
1812
1813 /*
1814  * @implemented
1815  */
1816 int
1817 WINAPI
1818 DlgDirListW(
1819   HWND hDlg,
1820   LPWSTR lpPathSpec,
1821   int nIDListBox,
1822   int nIDStaticPath,
1823   UINT uFileType)
1824 {
1825   return DIALOG_DlgDirListW( hDlg, lpPathSpec, nIDListBox, nIDStaticPath, uFileType, FALSE );
1826 }
1827
1828
1829 /*
1830  * @implemented
1831  */
1832 BOOL
1833 WINAPI
1834 DlgDirSelectComboBoxExA(
1835   HWND hDlg,
1836   LPSTR lpString,
1837   int nCount,
1838   int nIDComboBox)
1839 {
1840   return DIALOG_DlgDirSelect( hDlg, (LPWSTR)lpString, nCount, nIDComboBox, FALSE, TRUE );
1841 }
1842
1843
1844 /*
1845  * @implemented
1846  */
1847 BOOL
1848 WINAPI
1849 DlgDirSelectComboBoxExW(
1850   HWND hDlg,
1851   LPWSTR lpString,
1852   int nCount,
1853   int nIDComboBox)
1854 {
1855   return DIALOG_DlgDirSelect( hDlg, (LPWSTR)lpString, nCount, nIDComboBox, TRUE, TRUE );
1856 }
1857
1858
1859 /*
1860  * @implemented
1861  */
1862 BOOL
1863 WINAPI
1864 DlgDirSelectExA(
1865   HWND hDlg,
1866   LPSTR lpString,
1867   int nCount,
1868   int nIDListBox)
1869 {
1870   return DIALOG_DlgDirSelect( hDlg, (LPWSTR)lpString, nCount, nIDListBox, FALSE, FALSE );
1871 }
1872
1873
1874 /*
1875  * @implemented
1876  */
1877 BOOL
1878 WINAPI
1879 DlgDirSelectExW(
1880   HWND hDlg,
1881   LPWSTR lpString,
1882   int nCount,
1883   int nIDListBox)
1884 {
1885   return DIALOG_DlgDirSelect( hDlg, lpString, nCount, nIDListBox, TRUE, FALSE );
1886 }
1887
1888
1889 /*
1890  * @implemented
1891  */
1892 BOOL
1893 WINAPI
1894 EndDialog(
1895   HWND hDlg,
1896   INT_PTR nResult)
1897 {
1898     BOOL wasEnabled = TRUE;
1899     DIALOGINFO * dlgInfo;
1900     HWND owner;
1901
1902     if (!(dlgInfo = GETDLGINFO(hDlg))) return FALSE;
1903
1904     dlgInfo->idResult = nResult;
1905     dlgInfo->flags |= DF_END;
1906     wasEnabled = (dlgInfo->flags & DF_OWNERENABLED);
1907
1908     if (wasEnabled && (owner = GetWindow( hDlg, GW_OWNER )))
1909         DIALOG_EnableOwner( owner );
1910
1911     /* Windows sets the focus to the dialog itself in EndDialog */
1912
1913     if (IsChild(hDlg, GetFocus()))
1914        SetFocus( hDlg );
1915
1916     /* Don't have to send a ShowWindow(SW_HIDE), just do
1917        SetWindowPos with SWP_HIDEWINDOW as done in Windows */
1918
1919     SetWindowPos(hDlg, NULL, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE
1920                  | SWP_NOZORDER | SWP_NOACTIVATE | SWP_HIDEWINDOW);
1921
1922     if (hDlg == GetActiveWindow()) WinPosActivateOtherWindow( hDlg );
1923
1924     /* unblock dialog loop */
1925     PostMessageA(hDlg, WM_NULL, 0, 0);
1926     return TRUE;
1927 }
1928
1929
1930 /*
1931  * @implemented
1932  */
1933 LONG
1934 WINAPI
1935 GetDialogBaseUnits(VOID)
1936 {
1937     static DWORD units;
1938
1939     if (!units)
1940     {
1941         HDC hdc;
1942         SIZE size;
1943
1944         if ((hdc = GetDC(0)))
1945         {
1946             size.cx = GdiGetCharDimensions( hdc, NULL, &size.cy );
1947             if (size.cx) units = MAKELONG( size.cx, size.cy );
1948             ReleaseDC( 0, hdc );
1949         }
1950     }
1951     return units;
1952 }
1953
1954
1955 /*
1956  * @implemented
1957  */
1958 int
1959 WINAPI
1960 GetDlgCtrlID(
1961   HWND hwndCtl)
1962 {
1963         return GetWindowLongPtrW( hwndCtl, GWLP_ID );
1964 }
1965
1966
1967 /*
1968  * @implemented
1969  */
1970 HWND
1971 WINAPI
1972 GetDlgItem(
1973   HWND hDlg,
1974   int nIDDlgItem)
1975 {
1976     GETDLGITEMINFO info;
1977     info.nIDDlgItem = nIDDlgItem;
1978     info.control = 0;
1979     if(hDlg && !EnumChildWindows(hDlg, (WNDENUMPROC)&GetDlgItemEnumProc, (LPARAM)&info))
1980         return info.control;
1981     else
1982         return 0;
1983 }
1984
1985
1986 /*
1987  * @implemented
1988  */
1989 UINT
1990 WINAPI
1991 GetDlgItemInt(
1992   HWND hDlg,
1993   int nIDDlgItem,
1994   BOOL *lpTranslated,
1995   BOOL bSigned)
1996 {
1997         char str[30];
1998     char * endptr;
1999     long result = 0;
2000
2001     if (lpTranslated) *lpTranslated = FALSE;
2002     if (!SendDlgItemMessageA(hDlg, nIDDlgItem, WM_GETTEXT, sizeof(str), (LPARAM)str))
2003         return 0;
2004     if (bSigned)
2005     {
2006         result = strtol( str, &endptr, 10 );
2007         if (!endptr || (endptr == str))  /* Conversion was unsuccessful */
2008             return 0;
2009                 /* FIXME: errno? */
2010         if (((result == 0) || (result == 0xFFFFFFFF))/* && (errno == ERANGE) */)
2011             return 0;
2012     }
2013     else
2014     {
2015         result = strtoul( str, &endptr, 10 );
2016         if (!endptr || (endptr == str))  /* Conversion was unsuccessful */
2017             return 0;
2018                 /* FIXME: errno? */
2019         if ((result == 0xFFFFFFFF)/* && (errno == ERANGE) */) return 0;
2020     }
2021     if (lpTranslated) *lpTranslated = TRUE;
2022     return (UINT)result;
2023 }
2024
2025
2026 /*
2027  * @implemented
2028  */
2029 UINT
2030 WINAPI
2031 GetDlgItemTextA(
2032   HWND hDlg,
2033   int nIDDlgItem,
2034   LPSTR lpString,
2035   int nMaxCount)
2036 {
2037   if (lpString && (nMaxCount > 0)) lpString[0] = '\0';
2038   return (UINT)SendDlgItemMessageA( hDlg, nIDDlgItem, WM_GETTEXT, nMaxCount, (LPARAM)lpString );
2039 }
2040
2041
2042 /*
2043  * @implemented
2044  */
2045 UINT
2046 WINAPI
2047 GetDlgItemTextW(
2048   HWND hDlg,
2049   int nIDDlgItem,
2050   LPWSTR lpString,
2051   int nMaxCount)
2052 {
2053   if (lpString && (nMaxCount > 0)) lpString[0] = '\0';
2054   return (UINT)SendDlgItemMessageW( hDlg, nIDDlgItem, WM_GETTEXT, nMaxCount, (LPARAM)lpString );
2055 }
2056
2057 /*
2058  * @implemented
2059  */
2060 HWND
2061 WINAPI
2062 GetNextDlgGroupItem(
2063   HWND hDlg,
2064   HWND hCtl,
2065   BOOL bPrevious)
2066 {
2067     HWND hwnd, hwndNext, retvalue, hwndLastGroup = 0;
2068     BOOL fLooped=FALSE;
2069     BOOL fSkipping=FALSE;
2070
2071     if (hDlg == hCtl) hCtl = NULL;
2072     if (!hCtl && bPrevious) return 0;
2073
2074         /* if the hwndCtrl is the child of the control in the hwndDlg,
2075          * then the hwndDlg has to be the parent of the hwndCtrl */
2076
2077     if (hCtl)
2078     {
2079         if (!IsChild (hDlg, hCtl)) return 0;
2080         /* Make sure hwndCtrl is a top-level child */
2081
2082     }
2083     else
2084     {
2085         /* No ctrl specified -> start from the beginning */
2086         if (!(hCtl = GetWindow( hDlg, GW_CHILD ))) return 0;
2087         /* MSDN is wrong. fPrevious does not result in the last child */
2088
2089         /* No ctrl specified -> start from the beginning */
2090         if (!(hCtl = GetWindow( hDlg, GW_CHILD ))) return 0;
2091
2092         /* MSDN is wrong. fPrevious does not result in the last child */
2093
2094         /* Maybe that first one is valid.  If so then we don't want to skip it*/
2095         if ((GetWindowLongW( hCtl, GWL_STYLE ) & (WS_VISIBLE|WS_DISABLED)) == WS_VISIBLE)
2096         {
2097             return hCtl;
2098         }
2099
2100     }
2101
2102     /* Always go forward around the group and list of controls; for the
2103      * previous control keep track; for the next break when you find one
2104      */
2105     retvalue = hCtl;
2106     hwnd = hCtl;
2107     while (hwndNext = GetWindow (hwnd, GW_HWNDNEXT),
2108            1)
2109     {
2110         while (!hwndNext)
2111         {
2112             /* Climb out until there is a next sibling of the ancestor or we
2113              * reach the top (in which case we loop back to the start)
2114              */
2115             if (hDlg == GetParent (hwnd))
2116             {
2117                 /* Wrap around to the beginning of the list, within the same
2118                  * group. (Once only)
2119                  */
2120                 if (fLooped) goto end;
2121                 fLooped = TRUE;
2122                 hwndNext = GetWindow (hDlg, GW_CHILD);
2123             }
2124             else
2125             {
2126                 hwnd = GetParent (hwnd);
2127                 hwndNext = GetWindow (hwnd, GW_HWNDNEXT);
2128             }
2129         }
2130         hwnd = hwndNext;
2131
2132         /* Wander down the leading edge of controlparents */
2133         while ( (GetWindowLongW (hwnd, GWL_EXSTYLE) & WS_EX_CONTROLPARENT) &&
2134                 ((GetWindowLongW (hwnd, GWL_STYLE) & (WS_VISIBLE | WS_DISABLED)) == WS_VISIBLE) &&
2135                 (hwndNext = GetWindow (hwnd, GW_CHILD)))
2136             hwnd = hwndNext;
2137         /* Question.  If the control is a control parent but either has no
2138          * children or is not visible/enabled then if it has a WS_GROUP does
2139          * it count?  For that matter does it count anyway?
2140          * I believe it doesn't count.
2141          */
2142
2143         if ((GetWindowLongW (hwnd, GWL_STYLE) & WS_GROUP))
2144         {
2145             hwndLastGroup = hwnd;
2146             if (!fSkipping)
2147             {
2148                 /* Look for the beginning of the group */
2149                 fSkipping = TRUE;
2150             }
2151         }
2152
2153         if (hwnd == hCtl)
2154         {
2155             if (!fSkipping) break;
2156             if (hwndLastGroup == hwnd) break;
2157             hwnd = hwndLastGroup;
2158             fSkipping = FALSE;
2159             fLooped = FALSE;
2160         }
2161
2162         if (!fSkipping &&
2163             (GetWindowLongW (hwnd, GWL_STYLE) & (WS_VISIBLE|WS_DISABLED)) ==
2164              WS_VISIBLE)
2165         {
2166             retvalue = hwnd;
2167             if (!bPrevious) break;
2168         }
2169     }
2170 end:
2171     return retvalue;
2172 }
2173
2174
2175 /*
2176  * @implemented
2177  */
2178 HWND
2179 WINAPI
2180 GetNextDlgTabItem(
2181   HWND hDlg,
2182   HWND hCtl,
2183   BOOL bPrevious)
2184 {
2185         /* Undocumented but tested under Win2000 and WinME */
2186         if (hDlg == hCtl) hCtl = NULL;
2187
2188         /* Contrary to MSDN documentation, tested under Win2000 and WinME
2189         * NB GetLastError returns whatever was set before the function was
2190         * called.
2191         */
2192         if (!hCtl && bPrevious) return 0;
2193
2194         return DIALOG_GetNextTabItem(hDlg, hDlg, hCtl, bPrevious);
2195 }
2196
2197
2198 #if 0
2199 BOOL
2200 WINAPI
2201 IsDialogMessage(
2202   HWND hDlg,
2203   LPMSG lpMsg)
2204 {
2205         return IsDialogMessageW(hDlg, lpMsg);
2206 }
2207 #endif
2208
2209 /***********************************************************************
2210  *              DIALOG_FixOneChildOnChangeFocus
2211  *
2212  * Callback helper for DIALOG_FixChildrenOnChangeFocus
2213  */
2214
2215 static BOOL CALLBACK DIALOG_FixOneChildOnChangeFocus (HWND hwndChild,
2216         LPARAM lParam)
2217 {
2218     /* If a default pushbutton then no longer default */
2219     if (DLGC_DEFPUSHBUTTON & SendMessageW (hwndChild, WM_GETDLGCODE, 0, 0))
2220         SendMessageW (hwndChild, BM_SETSTYLE, BS_PUSHBUTTON, TRUE);
2221     return TRUE;
2222 }
2223
2224 /***********************************************************************
2225  *              DIALOG_FixChildrenOnChangeFocus
2226  *
2227  * Following the change of focus that occurs for example after handling
2228  * a WM_KEYDOWN VK_TAB in IsDialogMessage, some tidying of the dialog's
2229  * children may be required.
2230  */
2231 static void DIALOG_FixChildrenOnChangeFocus (HWND hwndDlg, HWND hwndNext)
2232 {
2233     INT dlgcode_next = SendMessageW (hwndNext, WM_GETDLGCODE, 0, 0);
2234     /* INT dlgcode_dlg  = SendMessageW (hwndDlg, WM_GETDLGCODE, 0, 0); */
2235     /* Windows does ask for this.  I don't know why yet */
2236
2237     EnumChildWindows (hwndDlg, DIALOG_FixOneChildOnChangeFocus, 0);
2238
2239     /* If the button that is getting the focus WAS flagged as the default
2240      * pushbutton then ask the dialog what it thinks the default is and
2241      * set that in the default style.
2242      */
2243     if (dlgcode_next & DLGC_DEFPUSHBUTTON)
2244     {
2245         DWORD def_id = SendMessageW (hwndDlg, DM_GETDEFID, 0, 0);
2246         if (HIWORD(def_id) == DC_HASDEFID)
2247         {
2248             HWND hwndDef;
2249             def_id = LOWORD(def_id);
2250             hwndDef = GetDlgItem (hwndDlg, def_id);
2251             if (hwndDef)
2252             {
2253                 INT dlgcode_def = SendMessageW (hwndDef, WM_GETDLGCODE, 0, 0);
2254                 /* I know that if it is a button then it should already be a
2255                  * UNDEFPUSHBUTTON, since we have just told the buttons to
2256                  * change style.  But maybe they ignored our request
2257                  */
2258                 if ((dlgcode_def & DLGC_BUTTON) &&
2259                         (dlgcode_def &  DLGC_UNDEFPUSHBUTTON))
2260                 {
2261                     SendMessageW (hwndDef, BM_SETSTYLE, BS_DEFPUSHBUTTON, TRUE);
2262                 }
2263             }
2264         }
2265     }
2266     else if ((dlgcode_next & DLGC_BUTTON) && (dlgcode_next & DLGC_UNDEFPUSHBUTTON))
2267     {
2268         SendMessageW (hwndNext, BM_SETSTYLE, BS_DEFPUSHBUTTON, TRUE);
2269         /* I wonder why it doesn't send a DM_SETDEFID */
2270     }
2271 }
2272
2273 /*
2274  * @implemented
2275  */
2276 BOOL
2277 WINAPI
2278 IsDialogMessageW(
2279   HWND hDlg,
2280   LPMSG lpMsg)
2281 {
2282      INT dlgCode = 0;
2283
2284      // FIXME: hooks
2285      if (CallMsgFilterW( lpMsg, MSGF_DIALOGBOX )) return TRUE;
2286
2287      if ((hDlg != lpMsg->hwnd) && !IsChild( hDlg, lpMsg->hwnd )) return FALSE;
2288
2289     if (hDlg == GetDesktopWindow()) return FALSE;
2290
2291      hDlg = DIALOG_FindMsgDestination(hDlg);
2292
2293      switch(lpMsg->message)
2294      {
2295      case WM_KEYDOWN:
2296         dlgCode = SendMessageW( lpMsg->hwnd, WM_GETDLGCODE, lpMsg->wParam, (LPARAM)lpMsg );
2297          if (dlgCode & DLGC_WANTMESSAGE) break;
2298
2299          switch(lpMsg->wParam)
2300          {
2301          case VK_TAB:
2302             if (!(dlgCode & DLGC_WANTTAB))
2303             {
2304                 SendMessageW(hDlg, WM_CHANGEUISTATE, MAKEWPARAM(UIS_CLEAR, UISF_HIDEFOCUS), 0);
2305
2306                 /* I am not sure under which circumstances the TAB is handled
2307                  * each way.  All I do know is that it does not always simply
2308                  * send WM_NEXTDLGCTL.  (Personally I have never yet seen it
2309                  * do so but I presume someone has)
2310                  */
2311                 if (GETDLGINFO(hDlg))
2312                     SendMessageW( hDlg, WM_NEXTDLGCTL, (GetKeyState(VK_SHIFT) & 0x8000), 0 );
2313                 else
2314                 {
2315                     /* It would appear that GetNextDlgTabItem can handle being
2316                      * passed hwndDlg rather than NULL but that is undocumented
2317                      * so let's do it properly
2318                      */
2319                     HWND hwndFocus = GetFocus();
2320                     HWND hwndNext = GetNextDlgTabItem (hDlg,
2321                             hwndFocus == hDlg ? NULL : hwndFocus,
2322                             GetKeyState (VK_SHIFT) & 0x8000);
2323                     if (hwndNext)
2324                     {
2325                         dlgCode = SendMessageW (hwndNext, WM_GETDLGCODE,
2326                                 lpMsg->wParam, (LPARAM)lpMsg);
2327                         if (dlgCode & DLGC_HASSETSEL)
2328                         {
2329                             INT maxlen = 1 + SendMessageW (hwndNext, WM_GETTEXTLENGTH, 0, 0);
2330                             WCHAR *buffer = HeapAlloc (GetProcessHeap(), 0, maxlen * sizeof(WCHAR));
2331                             if (buffer)
2332                             {
2333                                 INT length;
2334                                 SendMessageW (hwndNext, WM_GETTEXT, maxlen, (LPARAM) buffer);
2335                                 length = wcslen (buffer);
2336                                 HeapFree (GetProcessHeap(), 0, buffer);
2337                                 SendMessageW (hwndNext, EM_SETSEL, 0, length);
2338                             }
2339                         }
2340                         SetFocus (hwndNext);
2341                         DIALOG_FixChildrenOnChangeFocus (hDlg, hwndNext);
2342                     }
2343                     else
2344                         return FALSE;
2345                 }
2346                 return TRUE;
2347             }
2348             break;
2349
2350          case VK_RIGHT:
2351          case VK_DOWN:
2352          case VK_LEFT:
2353          case VK_UP:
2354              if (!(dlgCode & DLGC_WANTARROWS))
2355              {
2356                  BOOL fPrevious = (lpMsg->wParam == VK_LEFT || lpMsg->wParam == VK_UP);
2357                  HWND hwndNext = GetNextDlgGroupItem (hDlg, GetFocus(), fPrevious );
2358                  SendMessageW( hDlg, WM_NEXTDLGCTL, (WPARAM)hwndNext, 1 );
2359                  return TRUE;
2360              }
2361              break;
2362
2363          case VK_CANCEL:
2364          case VK_ESCAPE:
2365              SendMessageW( hDlg, WM_COMMAND, IDCANCEL, (LPARAM)GetDlgItem( hDlg, IDCANCEL ) );
2366              return TRUE;
2367
2368          case VK_EXECUTE:
2369          case VK_RETURN:
2370               {
2371                  DWORD dw;
2372                  if ((GetFocus() == lpMsg->hwnd) &&
2373                      (SendMessageW (lpMsg->hwnd, WM_GETDLGCODE, 0, 0) & DLGC_DEFPUSHBUTTON))
2374                  {
2375                      SendMessageW (hDlg, WM_COMMAND, MAKEWPARAM (GetDlgCtrlID(lpMsg->hwnd),BN_CLICKED), (LPARAM)lpMsg->hwnd);
2376                  }
2377                  else if (DC_HASDEFID == HIWORD(dw = SendMessageW (hDlg, DM_GETDEFID, 0, 0)))
2378                  {
2379                      SendMessageW( hDlg, WM_COMMAND, MAKEWPARAM( LOWORD(dw), BN_CLICKED ),
2380                                      (LPARAM)GetDlgItem(hDlg, LOWORD(dw)));
2381                  }
2382                  else
2383                  {
2384                      SendMessageW( hDlg, WM_COMMAND, IDOK, (LPARAM)GetDlgItem( hDlg, IDOK ) );
2385
2386                  }
2387              }
2388              return TRUE;
2389          }
2390          break;
2391
2392      case WM_CHAR:
2393          dlgCode = SendMessageW( lpMsg->hwnd, WM_GETDLGCODE, lpMsg->wParam, (LPARAM)lpMsg );
2394          if (dlgCode & (DLGC_WANTCHARS|DLGC_WANTMESSAGE)) break;
2395          if (lpMsg->wParam == '\t' && (dlgCode & DLGC_WANTTAB)) break;
2396          /* drop through */
2397
2398      case WM_SYSCHAR:
2399          if (DIALOG_IsAccelerator( lpMsg->hwnd, hDlg, lpMsg->wParam ))
2400          {
2401              /* don't translate or dispatch */
2402              return TRUE;
2403          }
2404          break;
2405
2406      case WM_SYSKEYDOWN:
2407          /* If the ALT key is being pressed display the keyboard cues */
2408          if (lpMsg->lParam & (1 << 29))
2409              SendMessageW(hDlg, WM_CHANGEUISTATE, MAKEWPARAM(UIS_CLEAR, UISF_HIDEACCEL | UISF_HIDEFOCUS), 0);
2410          break;
2411      }
2412
2413      TranslateMessage( lpMsg );
2414      DispatchMessageW( lpMsg );
2415      return TRUE;
2416 }
2417
2418
2419 /*
2420  * @implemented
2421  */
2422 UINT
2423 WINAPI
2424 IsDlgButtonChecked(
2425   HWND hDlg,
2426   int nIDButton)
2427 {
2428   return (UINT)SendDlgItemMessageW( hDlg, nIDButton, BM_GETCHECK, 0, 0 );
2429 }
2430
2431
2432 /*
2433  * @implemented
2434  */
2435 BOOL
2436 WINAPI
2437 MapDialogRect(
2438   HWND hDlg,
2439   LPRECT lpRect)
2440 {
2441         DIALOGINFO * dlgInfo;
2442         if (!(dlgInfo = GETDLGINFO(hDlg))) return FALSE;
2443         lpRect->left   = MulDiv(lpRect->left, dlgInfo->xBaseUnit, 4);
2444         lpRect->right  = MulDiv(lpRect->right, dlgInfo->xBaseUnit, 4);
2445         lpRect->top    = MulDiv(lpRect->top, dlgInfo->yBaseUnit, 8);
2446         lpRect->bottom = MulDiv(lpRect->bottom, dlgInfo->yBaseUnit, 8);
2447         return TRUE;
2448 }
2449
2450
2451 /*
2452  * @implemented
2453  */
2454 LRESULT
2455 WINAPI
2456 SendDlgItemMessageA(
2457   HWND hDlg,
2458   int nIDDlgItem,
2459   UINT Msg,
2460   WPARAM wParam,
2461   LPARAM lParam)
2462 {
2463         HWND hwndCtrl = GetDlgItem( hDlg, nIDDlgItem );
2464         if (hwndCtrl) return SendMessageA( hwndCtrl, Msg, wParam, lParam );
2465         else return 0;
2466 }
2467
2468
2469 /*
2470  * @implemented
2471  */
2472 LRESULT
2473 WINAPI
2474 SendDlgItemMessageW(
2475   HWND hDlg,
2476   int nIDDlgItem,
2477   UINT Msg,
2478   WPARAM wParam,
2479   LPARAM lParam)
2480 {
2481         HWND hwndCtrl = GetDlgItem( hDlg, nIDDlgItem );
2482         if (hwndCtrl) return SendMessageW( hwndCtrl, Msg, wParam, lParam );
2483         else return 0;
2484 }
2485
2486
2487 /*
2488  * @implemented
2489  */
2490 BOOL
2491 WINAPI
2492 SetDlgItemInt(
2493   HWND hDlg,
2494   int nIDDlgItem,
2495   UINT uValue,
2496   BOOL bSigned)
2497 {
2498         char str[20];
2499
2500         if (bSigned) sprintf( str, "%d", (INT)uValue );
2501         else sprintf( str, "%u", uValue );
2502         SendDlgItemMessageA( hDlg, nIDDlgItem, WM_SETTEXT, 0, (LPARAM)str );
2503         return TRUE;
2504 }
2505
2506
2507 /*
2508  * @implemented
2509  */
2510 BOOL
2511 WINAPI
2512 SetDlgItemTextA(
2513   HWND hDlg,
2514   int nIDDlgItem,
2515   LPCSTR lpString)
2516 {
2517   return SendDlgItemMessageA( hDlg, nIDDlgItem, WM_SETTEXT, 0, (LPARAM)lpString );
2518 }
2519
2520
2521 /*
2522  * @implemented
2523  */
2524 BOOL
2525 WINAPI
2526 SetDlgItemTextW(
2527   HWND hDlg,
2528   int nIDDlgItem,
2529   LPCWSTR lpString)
2530 {
2531   return SendDlgItemMessageW( hDlg, nIDDlgItem, WM_SETTEXT, 0, (LPARAM)lpString );
2532 }
2533
2534
2535 /*
2536  * @implemented
2537  */
2538 BOOL
2539 WINAPI
2540 CheckDlgButton(
2541   HWND hDlg,
2542   int nIDButton,
2543   UINT uCheck)
2544 {
2545         SendDlgItemMessageW( hDlg, nIDButton, BM_SETCHECK, uCheck, 0 );
2546         return TRUE;
2547 }
2548
2549 static BOOL CALLBACK CheckRB(HWND hwnd, LPARAM lParam)
2550 {
2551   LONG lChildID = GetWindowLongPtrW(hwnd, GWLP_ID);
2552   RADIOGROUP *lpRadioGroup = (RADIOGROUP *)lParam;
2553
2554   if((lChildID >= lpRadioGroup->firstID) &&
2555      (lChildID <= lpRadioGroup->lastID))
2556   {
2557     if (lChildID == lpRadioGroup->checkID)
2558     {
2559       SendMessageW(hwnd, BM_SETCHECK, BST_CHECKED, 0);
2560     }
2561     else
2562     {
2563       SendMessageW(hwnd, BM_SETCHECK, BST_UNCHECKED, 0);
2564     }
2565   }
2566
2567    return TRUE;
2568 }
2569
2570 /*
2571  * @implemented
2572  */
2573 BOOL
2574 WINAPI
2575 CheckRadioButton(
2576   HWND hDlg,
2577   int nIDFirstButton,
2578   int nIDLastButton,
2579   int nIDCheckButton)
2580 {
2581   RADIOGROUP radioGroup;
2582
2583   radioGroup.firstID = nIDFirstButton;
2584   radioGroup.lastID = nIDLastButton;
2585   radioGroup.checkID = nIDCheckButton;
2586
2587   return EnumChildWindows(hDlg, CheckRB, (LPARAM)&radioGroup);
2588 }