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) DefDlgProcW,    /* procW */
 132     (WNDPROC) DefDlgProcA,    /* procA */
 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                     NtUserShowWindow( 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     NtUserDestroyWindow( 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 = NtUserGetDC(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) NtUserDestroyMenu( 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) NtUserDestroyMenu( 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                     NtUserSetFocus( 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            NtUserShowWindow( 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) ) NtUserDestroyWindow( 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     NtUserSetFocus( 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     NtUserSetFocus( 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) NtUserDestroyMenu( 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, 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     size = SendMessageW(listbox, combo ? CB_GETLBTEXTLEN : LB_GETTEXTLEN, 0, 0 );
1363     if (size == LB_ERR) return FALSE;
1364
1365     if (!(buffer = HeapAlloc( GetProcessHeap(), 0, (size+2) * sizeof(WCHAR) ))) return FALSE;
1366
1367     SendMessageW( listbox, combo ? CB_GETLBTEXT : LB_GETTEXT, item, (LPARAM)buffer );
1368
1369     if ((ret = (buffer[0] == '[')))  /* drive or directory */
1370     {
1371         if (buffer[1] == '-')  /* drive */
1372         {
1373             buffer[3] = ':';
1374             buffer[4] = 0;
1375             ptr = buffer + 2;
1376         }
1377         else
1378         {
1379             buffer[strlenW(buffer)-1] = '\\';
1380             ptr = buffer + 1;
1381         }
1382     }
1383     else
1384     {
1385         /* Filenames without a dot extension must have one tacked at the end */
1386         if (strchrW(buffer, '.') == NULL)
1387         {
1388             buffer[strlenW(buffer)+1] = '\0';
1389             buffer[strlenW(buffer)] = '.';
1390         }
1391         ptr = buffer;
1392     }
1393
1394     if (!unicode)
1395     {
1396         if (len > 0 && !WideCharToMultiByte( CP_ACP, 0, ptr, -1, (LPSTR)str, len, 0, 0 ))
1397             ((LPSTR)str)[len-1] = 0;
1398     }
1399     else
1400         lstrcpynW( str, ptr, len );
1401
1402     HeapFree( GetProcessHeap(), 0, buffer );
1403     TRACE("Returning %d '%s'\n", ret, str );
1404     return ret;
1405 }
1406
1407 /***********************************************************************
1408  *           GetDlgItemEnumProc
1409  *
1410  * Callback for GetDlgItem
1411  */
1412 BOOL CALLBACK GetDlgItemEnumProc (HWND hwnd, LPARAM lParam )
1413 {
1414     GETDLGITEMINFO * info = (GETDLGITEMINFO *)lParam;
1415     if(info->nIDDlgItem == GetWindowLongW( hwnd, GWL_ID ))
1416     {
1417         info->control = hwnd;
1418         return FALSE;
1419     }
1420     return TRUE;
1421 }
1422
1423
1424 /* FUNCTIONS *****************************************************************/
1425
1426 /*
1427  * @implemented
1428  */
1429 HWND
1430 WINAPI
1431 CreateDialogIndirectParamAorW(
1432   HINSTANCE hInstance,
1433   LPCDLGTEMPLATE lpTemplate,
1434   HWND hWndParent,
1435   DLGPROC lpDialogFunc,
1436   LPARAM lParamInit,
1437   DWORD Flags)
1438 {
1439 /* FIXME:
1440  *   This function might be obsolete since I don't think it is exported by NT
1441  *   Also wine has one more parameter identifying weather it should call
1442  *   the function with unicode or not
1443  */
1444   return DIALOG_CreateIndirect( hInstance, lpTemplate, hWndParent, lpDialogFunc, lParamInit , !Flags, FALSE );
1445 }
1446
1447
1448 /*
1449  * @implemented
1450  */
1451 HWND
1452 WINAPI
1453 CreateDialogIndirectParamA(
1454   HINSTANCE hInstance,
1455   LPCDLGTEMPLATE lpTemplate,
1456   HWND hWndParent,
1457   DLGPROC lpDialogFunc,
1458   LPARAM lParamInit)
1459 {
1460   return CreateDialogIndirectParamAorW( hInstance, lpTemplate, hWndParent, lpDialogFunc, lParamInit, 2 );
1461 }
1462
1463
1464 /*
1465  * @implemented
1466  */
1467 HWND
1468 WINAPI
1469 CreateDialogIndirectParamW(
1470   HINSTANCE hInstance,
1471   LPCDLGTEMPLATE lpTemplate,
1472   HWND hWndParent,
1473   DLGPROC lpDialogFunc,
1474   LPARAM lParamInit)
1475 {
1476   return CreateDialogIndirectParamAorW( hInstance, lpTemplate, hWndParent, lpDialogFunc, lParamInit, 0);
1477 }
1478
1479
1480 /*
1481  * @implemented
1482  */
1483 HWND
1484 WINAPI
1485 CreateDialogParamA(
1486   HINSTANCE hInstance,
1487   LPCSTR lpTemplateName,
1488   HWND hWndParent,
1489   DLGPROC lpDialogFunc,
1490   LPARAM dwInitParam)
1491 {
1492         HRSRC hrsrc;
1493         LPCDLGTEMPLATE ptr;
1494
1495     if (!(hrsrc = FindResourceA( hInstance, lpTemplateName, (LPCSTR)RT_DIALOG ))) return 0;
1496     if (!(ptr = (LPCDLGTEMPLATE)LoadResource(hInstance, hrsrc))) return 0;
1497         return CreateDialogIndirectParamA( hInstance, ptr, hWndParent, lpDialogFunc, dwInitParam );
1498 }
1499
1500
1501 /*
1502  * @implemented
1503  */
1504 HWND
1505 WINAPI
1506 CreateDialogParamW(
1507   HINSTANCE hInstance,
1508   LPCWSTR lpTemplateName,
1509   HWND hWndParent,
1510   DLGPROC lpDialogFunc,
1511   LPARAM dwInitParam)
1512 {
1513         HRSRC hrsrc;
1514         LPCDLGTEMPLATE ptr;
1515
1516         if (!(hrsrc = FindResourceW( hInstance, lpTemplateName, (LPCWSTR)RT_DIALOG ))) return 0;
1517         if (!(ptr = (LPCDLGTEMPLATE)LoadResource(hInstance, hrsrc))) return 0;
1518         return CreateDialogIndirectParamW( hInstance, ptr, hWndParent, lpDialogFunc, dwInitParam );
1519 }
1520
1521
1522 /*
1523  * @implemented
1524  */
1525 LRESULT
1526 WINAPI
1527 DefDlgProcA(
1528   HWND hDlg,
1529   UINT Msg,
1530   WPARAM wParam,
1531   LPARAM lParam)
1532 {
1533     WNDPROC dlgproc;
1534     BOOL result = FALSE;
1535     DIALOGINFO * dlgInfo;
1536
1537         /* if there's no dialog info property then call default windows proc?? */
1538     if (!(dlgInfo = DIALOG_get_info(hDlg, TRUE)))
1539             return DefWindowProcA( hDlg, Msg, wParam, lParam );
1540
1541     SetWindowLongPtrW( hDlg, DWLP_MSGRESULT, 0 );
1542
1543     if ((dlgproc = (WNDPROC)GetWindowLongPtrW( hDlg, DWLP_DLGPROC )))
1544     {
1545         /* Call dialog procedure */
1546         result = CallWindowProcA( dlgproc, hDlg, Msg, wParam, lParam );
1547     }
1548
1549     if (!result && IsWindow(hDlg))
1550     {
1551         /* callback didn't process this message */
1552
1553         switch(Msg)
1554         {
1555             case WM_ERASEBKGND:
1556             case WM_SHOWWINDOW:
1557             case WM_ACTIVATE:
1558             case WM_SETFOCUS:
1559             case DM_SETDEFID:
1560             case DM_GETDEFID:
1561             case WM_NEXTDLGCTL:
1562             case WM_GETFONT:
1563             case WM_CLOSE:
1564             case WM_NCDESTROY:
1565             case WM_ENTERMENULOOP:
1566             case WM_LBUTTONDOWN:
1567             case WM_NCLBUTTONDOWN:
1568                  return DEFDLG_Proc( hDlg, Msg, wParam, lParam, dlgInfo );
1569             case WM_INITDIALOG:
1570             case WM_VKEYTOITEM:
1571             case WM_COMPAREITEM:
1572             case WM_CHARTOITEM:
1573                  break;
1574
1575             default:
1576                  return DefWindowProcA( hDlg, Msg, wParam, lParam );
1577         }
1578     }
1579     return DEFDLG_Epilog(hDlg, Msg, result);
1580 }
1581
1582
1583 /*
1584  * @implemented
1585  */
1586 LRESULT
1587 WINAPI
1588 DefDlgProcW(
1589   HWND hDlg,
1590   UINT Msg,
1591   WPARAM wParam,
1592   LPARAM lParam)
1593 {
1594     WNDPROC dlgproc;
1595     BOOL result = FALSE;
1596     DIALOGINFO * dlgInfo;
1597
1598         /* if there's no dialog info property then call default windows proc?? */
1599     if (!(dlgInfo = DIALOG_get_info(hDlg, TRUE)))
1600             return DefWindowProcW( hDlg, Msg, wParam, lParam );
1601
1602     SetWindowLongPtrW( hDlg, DWLP_MSGRESULT, 0 );
1603
1604     if ((dlgproc = (WNDPROC)GetWindowLongPtrW( hDlg, DWLP_DLGPROC )))
1605     {
1606         /* Call dialog procedure */
1607         result = CallWindowProcW( dlgproc, hDlg, Msg, wParam, lParam );
1608     }
1609
1610     if (!result && IsWindow(hDlg))
1611     {
1612         /* callback didn't process this message */
1613
1614         switch(Msg)
1615         {
1616             case WM_ERASEBKGND:
1617             case WM_SHOWWINDOW:
1618             case WM_ACTIVATE:
1619             case WM_SETFOCUS:
1620             case DM_SETDEFID:
1621             case DM_GETDEFID:
1622             case WM_NEXTDLGCTL:
1623             case WM_GETFONT:
1624             case WM_CLOSE:
1625             case WM_NCDESTROY:
1626             case WM_ENTERMENULOOP:
1627             case WM_LBUTTONDOWN:
1628             case WM_NCLBUTTONDOWN:
1629                  return DEFDLG_Proc( hDlg, Msg, wParam, lParam, dlgInfo );
1630             case WM_INITDIALOG:
1631             case WM_VKEYTOITEM:
1632             case WM_COMPAREITEM:
1633             case WM_CHARTOITEM:
1634                  break;
1635
1636             default:
1637                  return DefWindowProcW( hDlg, Msg, wParam, lParam );
1638         }
1639     }
1640     return DEFDLG_Epilog(hDlg, Msg, result);
1641 }
1642
1643
1644 /*
1645  * @implemented
1646  */
1647 INT_PTR
1648 WINAPI
1649 DialogBoxIndirectParamAorW(
1650   HINSTANCE hInstance,
1651   LPCDLGTEMPLATE hDialogTemplate,
1652   HWND hWndParent,
1653   DLGPROC lpDialogFunc,
1654   LPARAM dwInitParam,
1655   DWORD Flags)
1656 {
1657 /* FIXME:
1658  *  This function might be obsolete since I don't think it is exported by NT
1659  *  Also wine has one more parameter identifying weather it should call
1660  *  the function with unicode or not
1661  */
1662   HWND hWnd = DIALOG_CreateIndirect( hInstance, hDialogTemplate, hWndParent, lpDialogFunc, dwInitParam, !Flags, TRUE );
1663   if (hWnd) return DIALOG_DoDialogBox( hWnd, hWndParent );
1664   return -1;
1665 }
1666
1667
1668 /*
1669  * @implemented
1670  */
1671 INT_PTR
1672 WINAPI
1673 DialogBoxIndirectParamA(
1674   HINSTANCE hInstance,
1675   LPCDLGTEMPLATE hDialogTemplate,
1676   HWND hWndParent,
1677   DLGPROC lpDialogFunc,
1678   LPARAM dwInitParam)
1679 {
1680   return DialogBoxIndirectParamAorW( hInstance, hDialogTemplate, hWndParent, lpDialogFunc, dwInitParam, 2);
1681 }
1682
1683
1684 /*
1685  * @implemented
1686  */
1687 INT_PTR
1688 WINAPI
1689 DialogBoxIndirectParamW(
1690   HINSTANCE hInstance,
1691   LPCDLGTEMPLATE hDialogTemplate,
1692   HWND hWndParent,
1693   DLGPROC lpDialogFunc,
1694   LPARAM dwInitParam)
1695 {
1696   return DialogBoxIndirectParamAorW( hInstance, hDialogTemplate, hWndParent, lpDialogFunc, dwInitParam, 0);
1697 }
1698
1699
1700 /*
1701  * @implemented
1702  */
1703 INT_PTR
1704 WINAPI
1705 DialogBoxParamA(
1706   HINSTANCE hInstance,
1707   LPCSTR lpTemplateName,
1708   HWND hWndParent,
1709   DLGPROC lpDialogFunc,
1710   LPARAM dwInitParam)
1711 {
1712     HWND hwnd;
1713     HRSRC hrsrc;
1714     LPCDLGTEMPLATE ptr;
1715
1716     if (!(hrsrc = FindResourceA( hInstance, lpTemplateName, (LPCSTR)RT_DIALOG )) ||
1717         !(ptr = (LPCDLGTEMPLATE)LoadResource(hInstance, hrsrc)))
1718     {
1719         SetLastError(ERROR_RESOURCE_NAME_NOT_FOUND);
1720         return -1;
1721     }
1722     if (hWndParent != NULL && !IsWindow(hWndParent))
1723     {
1724         SetLastError(ERROR_INVALID_WINDOW_HANDLE);
1725         return 0;
1726     }
1727     hwnd = DIALOG_CreateIndirect(hInstance, ptr, hWndParent, lpDialogFunc, dwInitParam, FALSE, TRUE);
1728     if (hwnd) return DIALOG_DoDialogBox(hwnd, hWndParent);
1729     return -1;
1730 }
1731
1732
1733 /*
1734  * @implemented
1735  */
1736 INT_PTR
1737 WINAPI
1738 DialogBoxParamW(
1739   HINSTANCE hInstance,
1740   LPCWSTR lpTemplateName,
1741   HWND hWndParent,
1742   DLGPROC lpDialogFunc,
1743   LPARAM dwInitParam)
1744 {
1745     HWND hwnd;
1746     HRSRC hrsrc;
1747     LPCDLGTEMPLATE ptr;
1748
1749     if (!(hrsrc = FindResourceW( hInstance, lpTemplateName, (LPCWSTR)RT_DIALOG )) ||
1750         !(ptr = (LPCDLGTEMPLATE)LoadResource(hInstance, hrsrc)))
1751     {
1752         SetLastError(ERROR_RESOURCE_NAME_NOT_FOUND);
1753         return -1;
1754     }
1755     if (hWndParent != NULL && !IsWindow(hWndParent))
1756     {
1757         SetLastError(ERROR_INVALID_WINDOW_HANDLE);
1758         return 0;
1759     }
1760     hwnd = DIALOG_CreateIndirect(hInstance, ptr, hWndParent, lpDialogFunc, dwInitParam, TRUE, TRUE);
1761     if (hwnd) return DIALOG_DoDialogBox(hwnd, hWndParent);
1762     return -1;
1763 }
1764
1765
1766 /*
1767  * @implemented
1768  */
1769 int
1770 WINAPI
1771 DlgDirListA(
1772   HWND hDlg,
1773   LPSTR lpPathSpec,
1774   int nIDListBox,
1775   int nIDStaticPath,
1776   UINT uFileType)
1777 {
1778     return DIALOG_DlgDirListA( hDlg, lpPathSpec, nIDListBox, nIDStaticPath, uFileType, FALSE );
1779 }
1780
1781
1782 /*
1783  * @implemented
1784  */
1785 int
1786 WINAPI
1787 DlgDirListComboBoxA(
1788   HWND hDlg,
1789   LPSTR lpPathSpec,
1790   int nIDComboBox,
1791   int nIDStaticPath,
1792   UINT uFiletype)
1793 {
1794   return DIALOG_DlgDirListA( hDlg, lpPathSpec, nIDComboBox, nIDStaticPath, uFiletype, TRUE );
1795 }
1796
1797
1798 /*
1799  * @implemented
1800  */
1801 int
1802 WINAPI
1803 DlgDirListComboBoxW(
1804   HWND hDlg,
1805   LPWSTR lpPathSpec,
1806   int nIDComboBox,
1807   int nIDStaticPath,
1808   UINT uFiletype)
1809 {
1810   return DIALOG_DlgDirListW( hDlg, lpPathSpec, nIDComboBox, nIDStaticPath, uFiletype, TRUE );
1811 }
1812
1813
1814 /*
1815  * @implemented
1816  */
1817 int
1818 WINAPI
1819 DlgDirListW(
1820   HWND hDlg,
1821   LPWSTR lpPathSpec,
1822   int nIDListBox,
1823   int nIDStaticPath,
1824   UINT uFileType)
1825 {
1826   return DIALOG_DlgDirListW( hDlg, lpPathSpec, nIDListBox, nIDStaticPath, uFileType, FALSE );
1827 }
1828
1829
1830 /*
1831  * @implemented
1832  */
1833 BOOL
1834 WINAPI
1835 DlgDirSelectComboBoxExA(
1836   HWND hDlg,
1837   LPSTR lpString,
1838   int nCount,
1839   int nIDComboBox)
1840 {
1841   return DIALOG_DlgDirSelect( hDlg, (LPWSTR)lpString, nCount, nIDComboBox, FALSE, TRUE );
1842 }
1843
1844
1845 /*
1846  * @implemented
1847  */
1848 BOOL
1849 WINAPI
1850 DlgDirSelectComboBoxExW(
1851   HWND hDlg,
1852   LPWSTR lpString,
1853   int nCount,
1854   int nIDComboBox)
1855 {
1856   return DIALOG_DlgDirSelect( hDlg, (LPWSTR)lpString, nCount, nIDComboBox, TRUE, TRUE );
1857 }
1858
1859
1860 /*
1861  * @implemented
1862  */
1863 BOOL
1864 WINAPI
1865 DlgDirSelectExA(
1866   HWND hDlg,
1867   LPSTR lpString,
1868   int nCount,
1869   int nIDListBox)
1870 {
1871   return DIALOG_DlgDirSelect( hDlg, (LPWSTR)lpString, nCount, nIDListBox, FALSE, FALSE );
1872 }
1873
1874
1875 /*
1876  * @implemented
1877  */
1878 BOOL
1879 WINAPI
1880 DlgDirSelectExW(
1881   HWND hDlg,
1882   LPWSTR lpString,
1883   int nCount,
1884   int nIDListBox)
1885 {
1886   return DIALOG_DlgDirSelect( hDlg, lpString, nCount, nIDListBox, TRUE, FALSE );
1887 }
1888
1889
1890 /*
1891  * @implemented
1892  */
1893 BOOL
1894 WINAPI
1895 EndDialog(
1896   HWND hDlg,
1897   INT_PTR nResult)
1898 {
1899     BOOL wasEnabled = TRUE;
1900     DIALOGINFO * dlgInfo;
1901     HWND owner;
1902
1903     if (!(dlgInfo = GETDLGINFO(hDlg))) return FALSE;
1904
1905     dlgInfo->idResult = nResult;
1906     dlgInfo->flags |= DF_END;
1907     wasEnabled = (dlgInfo->flags & DF_OWNERENABLED);
1908
1909     if (wasEnabled && (owner = GetWindow( hDlg, GW_OWNER )))
1910         DIALOG_EnableOwner( owner );
1911
1912     /* Windows sets the focus to the dialog itself in EndDialog */
1913
1914     if (IsChild(hDlg, GetFocus()))
1915        NtUserSetFocus( hDlg );
1916
1917     /* Don't have to send a ShowWindow(SW_HIDE), just do
1918        SetWindowPos with SWP_HIDEWINDOW as done in Windows */
1919
1920     NtUserSetWindowPos(hDlg, NULL, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE
1921                        | SWP_NOZORDER | SWP_NOACTIVATE | SWP_HIDEWINDOW);
1922
1923     if (hDlg == GetActiveWindow()) WinPosActivateOtherWindow( hDlg );
1924
1925     /* unblock dialog loop */
1926     PostMessageA(hDlg, WM_NULL, 0, 0);
1927     return TRUE;
1928 }
1929
1930
1931 /*
1932  * @implemented
1933  */
1934 LONG
1935 WINAPI
1936 GetDialogBaseUnits(VOID)
1937 {
1938     static DWORD units;
1939
1940     if (!units)
1941     {
1942         HDC hdc;
1943         SIZE size;
1944
1945         if ((hdc = NtUserGetDC(0)))
1946         {
1947             size.cx = GdiGetCharDimensions( hdc, NULL, &size.cy );
1948             if (size.cx) units = MAKELONG( size.cx, size.cy );
1949             ReleaseDC( 0, hdc );
1950         }
1951     }
1952     return units;
1953 }
1954
1955
1956 /*
1957  * @implemented
1958  */
1959 int
1960 WINAPI
1961 GetDlgCtrlID(
1962   HWND hwndCtl)
1963 {
1964         return GetWindowLongPtrW( hwndCtl, GWLP_ID );
1965 }
1966
1967
1968 /*
1969  * @implemented
1970  */
1971 HWND
1972 WINAPI
1973 GetDlgItem(
1974   HWND hDlg,
1975   int nIDDlgItem)
1976 {
1977     GETDLGITEMINFO info;
1978     info.nIDDlgItem = nIDDlgItem;
1979     info.control = 0;
1980     if(hDlg && !EnumChildWindows(hDlg, (WNDENUMPROC)&GetDlgItemEnumProc, (LPARAM)&info))
1981         return info.control;
1982     else
1983         return 0;
1984 }
1985
1986
1987 /*
1988  * @implemented
1989  */
1990 UINT
1991 WINAPI
1992 GetDlgItemInt(
1993   HWND hDlg,
1994   int nIDDlgItem,
1995   BOOL *lpTranslated,
1996   BOOL bSigned)
1997 {
1998         char str[30];
1999     char * endptr;
2000     long result = 0;
2001
2002     if (lpTranslated) *lpTranslated = FALSE;
2003     if (!SendDlgItemMessageA(hDlg, nIDDlgItem, WM_GETTEXT, sizeof(str), (LPARAM)str))
2004         return 0;
2005     if (bSigned)
2006     {
2007         result = strtol( str, &endptr, 10 );
2008         if (!endptr || (endptr == str))  /* Conversion was unsuccessful */
2009             return 0;
2010                 /* FIXME: errno? */
2011         if (((result == 0) || (result == 0xFFFFFFFF))/* && (errno == ERANGE) */)
2012             return 0;
2013     }
2014     else
2015     {
2016         result = strtoul( str, &endptr, 10 );
2017         if (!endptr || (endptr == str))  /* Conversion was unsuccessful */
2018             return 0;
2019                 /* FIXME: errno? */
2020         if ((result == 0xFFFFFFFF)/* && (errno == ERANGE) */) return 0;
2021     }
2022     if (lpTranslated) *lpTranslated = TRUE;
2023     return (UINT)result;
2024 }
2025
2026
2027 /*
2028  * @implemented
2029  */
2030 UINT
2031 WINAPI
2032 GetDlgItemTextA(
2033   HWND hDlg,
2034   int nIDDlgItem,
2035   LPSTR lpString,
2036   int nMaxCount)
2037 {
2038   if (lpString && (nMaxCount > 0)) lpString[0] = '\0';
2039   return (UINT)SendDlgItemMessageA( hDlg, nIDDlgItem, WM_GETTEXT, nMaxCount, (LPARAM)lpString );
2040 }
2041
2042
2043 /*
2044  * @implemented
2045  */
2046 UINT
2047 WINAPI
2048 GetDlgItemTextW(
2049   HWND hDlg,
2050   int nIDDlgItem,
2051   LPWSTR lpString,
2052   int nMaxCount)
2053 {
2054   if (lpString && (nMaxCount > 0)) lpString[0] = '\0';
2055   return (UINT)SendDlgItemMessageW( hDlg, nIDDlgItem, WM_GETTEXT, nMaxCount, (LPARAM)lpString );
2056 }
2057
2058 /*
2059  * @implemented
2060  */
2061 HWND
2062 WINAPI
2063 GetNextDlgGroupItem(
2064   HWND hDlg,
2065   HWND hCtl,
2066   BOOL bPrevious)
2067 {
2068     HWND hwnd, hwndNext, retvalue, hwndLastGroup = 0;
2069     BOOL fLooped=FALSE;
2070     BOOL fSkipping=FALSE;
2071
2072     if (hDlg == hCtl) hCtl = NULL;
2073     if (!hCtl && bPrevious) return 0;
2074
2075         /* if the hwndCtrl is the child of the control in the hwndDlg,
2076          * then the hwndDlg has to be the parent of the hwndCtrl */
2077
2078     if (hCtl)
2079     {
2080         if (!IsChild (hDlg, hCtl)) return 0;
2081         /* Make sure hwndCtrl is a top-level child */
2082
2083     }
2084     else
2085     {
2086         /* No ctrl specified -> start from the beginning */
2087         if (!(hCtl = GetWindow( hDlg, GW_CHILD ))) return 0;
2088         /* MSDN is wrong. fPrevious does not result in the last child */
2089
2090         /* No ctrl specified -> start from the beginning */
2091         if (!(hCtl = GetWindow( hDlg, GW_CHILD ))) return 0;
2092
2093         /* MSDN is wrong. fPrevious does not result in the last child */
2094
2095         /* Maybe that first one is valid.  If so then we don't want to skip it*/
2096         if ((GetWindowLongW( hCtl, GWL_STYLE ) & (WS_VISIBLE|WS_DISABLED)) == WS_VISIBLE)
2097         {
2098             return hCtl;
2099         }
2100
2101     }
2102
2103     /* Always go forward around the group and list of controls; for the
2104      * previous control keep track; for the next break when you find one
2105      */
2106     retvalue = hCtl;
2107     hwnd = hCtl;
2108     while (hwndNext = GetWindow (hwnd, GW_HWNDNEXT),
2109            1)
2110     {
2111         while (!hwndNext)
2112         {
2113             /* Climb out until there is a next sibling of the ancestor or we
2114              * reach the top (in which case we loop back to the start)
2115              */
2116             if (hDlg == GetParent (hwnd))
2117             {
2118                 /* Wrap around to the beginning of the list, within the same
2119                  * group. (Once only)
2120                  */
2121                 if (fLooped) goto end;
2122                 fLooped = TRUE;
2123                 hwndNext = GetWindow (hDlg, GW_CHILD);
2124             }
2125             else
2126             {
2127                 hwnd = GetParent (hwnd);
2128                 hwndNext = GetWindow (hwnd, GW_HWNDNEXT);
2129             }
2130         }
2131         hwnd = hwndNext;
2132
2133         /* Wander down the leading edge of controlparents */
2134         while ( (GetWindowLongW (hwnd, GWL_EXSTYLE) & WS_EX_CONTROLPARENT) &&
2135                 ((GetWindowLongW (hwnd, GWL_STYLE) & (WS_VISIBLE | WS_DISABLED)) == WS_VISIBLE) &&
2136                 (hwndNext = GetWindow (hwnd, GW_CHILD)))
2137             hwnd = hwndNext;
2138         /* Question.  If the control is a control parent but either has no
2139          * children or is not visible/enabled then if it has a WS_GROUP does
2140          * it count?  For that matter does it count anyway?
2141          * I believe it doesn't count.
2142          */
2143
2144         if ((GetWindowLongW (hwnd, GWL_STYLE) & WS_GROUP))
2145         {
2146             hwndLastGroup = hwnd;
2147             if (!fSkipping)
2148             {
2149                 /* Look for the beginning of the group */
2150                 fSkipping = TRUE;
2151             }
2152         }
2153
2154         if (hwnd == hCtl)
2155         {
2156             if (!fSkipping) break;
2157             if (hwndLastGroup == hwnd) break;
2158             hwnd = hwndLastGroup;
2159             fSkipping = FALSE;
2160             fLooped = FALSE;
2161         }
2162
2163         if (!fSkipping &&
2164             (GetWindowLongW (hwnd, GWL_STYLE) & (WS_VISIBLE|WS_DISABLED)) ==
2165              WS_VISIBLE)
2166         {
2167             retvalue = hwnd;
2168             if (!bPrevious) break;
2169         }
2170     }
2171 end:
2172     return retvalue;
2173 }
2174
2175
2176 /*
2177  * @implemented
2178  */
2179 HWND
2180 WINAPI
2181 GetNextDlgTabItem(
2182   HWND hDlg,
2183   HWND hCtl,
2184   BOOL bPrevious)
2185 {
2186         /* Undocumented but tested under Win2000 and WinME */
2187         if (hDlg == hCtl) hCtl = NULL;
2188
2189         /* Contrary to MSDN documentation, tested under Win2000 and WinME
2190         * NB GetLastError returns whatever was set before the function was
2191         * called.
2192         */
2193         if (!hCtl && bPrevious) return 0;
2194
2195         return DIALOG_GetNextTabItem(hDlg, hDlg, hCtl, bPrevious);
2196 }
2197
2198
2199 #if 0
2200 BOOL
2201 WINAPI
2202 IsDialogMessage(
2203   HWND hDlg,
2204   LPMSG lpMsg)
2205 {
2206         return IsDialogMessageW(hDlg, lpMsg);
2207 }
2208 #endif
2209
2210 /***********************************************************************
2211  *              DIALOG_FixOneChildOnChangeFocus
2212  *
2213  * Callback helper for DIALOG_FixChildrenOnChangeFocus
2214  */
2215
2216 static BOOL CALLBACK DIALOG_FixOneChildOnChangeFocus (HWND hwndChild,
2217         LPARAM lParam)
2218 {
2219     /* If a default pushbutton then no longer default */
2220     if (DLGC_DEFPUSHBUTTON & SendMessageW (hwndChild, WM_GETDLGCODE, 0, 0))
2221         SendMessageW (hwndChild, BM_SETSTYLE, BS_PUSHBUTTON, TRUE);
2222     return TRUE;
2223 }
2224
2225 /***********************************************************************
2226  *              DIALOG_FixChildrenOnChangeFocus
2227  *
2228  * Following the change of focus that occurs for example after handling
2229  * a WM_KEYDOWN VK_TAB in IsDialogMessage, some tidying of the dialog's
2230  * children may be required.
2231  */
2232 static void DIALOG_FixChildrenOnChangeFocus (HWND hwndDlg, HWND hwndNext)
2233 {
2234     INT dlgcode_next = SendMessageW (hwndNext, WM_GETDLGCODE, 0, 0);
2235     /* INT dlgcode_dlg  = SendMessageW (hwndDlg, WM_GETDLGCODE, 0, 0); */
2236     /* Windows does ask for this.  I don't know why yet */
2237
2238     EnumChildWindows (hwndDlg, DIALOG_FixOneChildOnChangeFocus, 0);
2239
2240     /* If the button that is getting the focus WAS flagged as the default
2241      * pushbutton then ask the dialog what it thinks the default is and
2242      * set that in the default style.
2243      */
2244     if (dlgcode_next & DLGC_DEFPUSHBUTTON)
2245     {
2246         DWORD def_id = SendMessageW (hwndDlg, DM_GETDEFID, 0, 0);
2247         if (HIWORD(def_id) == DC_HASDEFID)
2248         {
2249             HWND hwndDef;
2250             def_id = LOWORD(def_id);
2251             hwndDef = GetDlgItem (hwndDlg, def_id);
2252             if (hwndDef)
2253             {
2254                 INT dlgcode_def = SendMessageW (hwndDef, WM_GETDLGCODE, 0, 0);
2255                 /* I know that if it is a button then it should already be a
2256                  * UNDEFPUSHBUTTON, since we have just told the buttons to
2257                  * change style.  But maybe they ignored our request
2258                  */
2259                 if ((dlgcode_def & DLGC_BUTTON) &&
2260                         (dlgcode_def &  DLGC_UNDEFPUSHBUTTON))
2261                 {
2262                     SendMessageW (hwndDef, BM_SETSTYLE, BS_DEFPUSHBUTTON, TRUE);
2263                 }
2264             }
2265         }
2266     }
2267     else if ((dlgcode_next & DLGC_BUTTON) && (dlgcode_next & DLGC_UNDEFPUSHBUTTON))
2268     {
2269         SendMessageW (hwndNext, BM_SETSTYLE, BS_DEFPUSHBUTTON, TRUE);
2270         /* I wonder why it doesn't send a DM_SETDEFID */
2271     }
2272 }
2273
2274 /*
2275  * @implemented
2276  */
2277 BOOL
2278 WINAPI
2279 IsDialogMessageW(
2280   HWND hDlg,
2281   LPMSG lpMsg)
2282 {
2283      INT dlgCode = 0;
2284
2285      // FIXME: hooks
2286      if (CallMsgFilterW( lpMsg, MSGF_DIALOGBOX )) return TRUE;
2287
2288      if ((hDlg != lpMsg->hwnd) && !IsChild( hDlg, lpMsg->hwnd )) return FALSE;
2289
2290     if (hDlg == GetDesktopWindow()) return FALSE;
2291
2292      hDlg = DIALOG_FindMsgDestination(hDlg);
2293
2294      switch(lpMsg->message)
2295      {
2296      case WM_KEYDOWN:
2297         dlgCode = SendMessageW( lpMsg->hwnd, WM_GETDLGCODE, lpMsg->wParam, (LPARAM)lpMsg );
2298          if (dlgCode & DLGC_WANTMESSAGE) break;
2299
2300          switch(lpMsg->wParam)
2301          {
2302          case VK_TAB:
2303             if (!(dlgCode & DLGC_WANTTAB))
2304             {
2305                 SendMessageW(hDlg, WM_CHANGEUISTATE, MAKEWPARAM(UIS_CLEAR, UISF_HIDEFOCUS), 0);
2306
2307                 /* I am not sure under which circumstances the TAB is handled
2308                  * each way.  All I do know is that it does not always simply
2309                  * send WM_NEXTDLGCTL.  (Personally I have never yet seen it
2310                  * do so but I presume someone has)
2311                  */
2312                 if (GETDLGINFO(hDlg))
2313                     SendMessageW( hDlg, WM_NEXTDLGCTL, (GetKeyState(VK_SHIFT) & 0x8000), 0 );
2314                 else
2315                 {
2316                     /* It would appear that GetNextDlgTabItem can handle being
2317                      * passed hwndDlg rather than NULL but that is undocumented
2318                      * so let's do it properly
2319                      */
2320                     HWND hwndFocus = GetFocus();
2321                     HWND hwndNext = GetNextDlgTabItem (hDlg,
2322                             hwndFocus == hDlg ? NULL : hwndFocus,
2323                             GetKeyState (VK_SHIFT) & 0x8000);
2324                     if (hwndNext)
2325                     {
2326                         dlgCode = SendMessageW (hwndNext, WM_GETDLGCODE,
2327                                 lpMsg->wParam, (LPARAM)lpMsg);
2328                         if (dlgCode & DLGC_HASSETSEL)
2329                         {
2330                             INT maxlen = 1 + SendMessageW (hwndNext, WM_GETTEXTLENGTH, 0, 0);
2331                             WCHAR *buffer = HeapAlloc (GetProcessHeap(), 0, maxlen * sizeof(WCHAR));
2332                             if (buffer)
2333                             {
2334                                 INT length;
2335                                 SendMessageW (hwndNext, WM_GETTEXT, maxlen, (LPARAM) buffer);
2336                                 length = wcslen (buffer);
2337                                 HeapFree (GetProcessHeap(), 0, buffer);
2338                                 SendMessageW (hwndNext, EM_SETSEL, 0, length);
2339                             }
2340                         }
2341                         NtUserSetFocus (hwndNext);
2342                         DIALOG_FixChildrenOnChangeFocus (hDlg, hwndNext);
2343                     }
2344                     else
2345                         return FALSE;
2346                 }
2347                 return TRUE;
2348             }
2349             break;
2350
2351          case VK_RIGHT:
2352          case VK_DOWN:
2353          case VK_LEFT:
2354          case VK_UP:
2355              if (!(dlgCode & DLGC_WANTARROWS))
2356              {
2357                  BOOL fPrevious = (lpMsg->wParam == VK_LEFT || lpMsg->wParam == VK_UP);
2358                  HWND hwndNext = GetNextDlgGroupItem (hDlg, GetFocus(), fPrevious );
2359                  SendMessageW( hDlg, WM_NEXTDLGCTL, (WPARAM)hwndNext, 1 );
2360                  return TRUE;
2361              }
2362              break;
2363
2364          case VK_CANCEL:
2365          case VK_ESCAPE:
2366              SendMessageW( hDlg, WM_COMMAND, IDCANCEL, (LPARAM)GetDlgItem( hDlg, IDCANCEL ) );
2367              return TRUE;
2368
2369          case VK_EXECUTE:
2370          case VK_RETURN:
2371               {
2372                  DWORD dw;
2373                  if ((GetFocus() == lpMsg->hwnd) &&
2374                      (SendMessageW (lpMsg->hwnd, WM_GETDLGCODE, 0, 0) & DLGC_DEFPUSHBUTTON))
2375                  {
2376                      SendMessageW (hDlg, WM_COMMAND, MAKEWPARAM (GetDlgCtrlID(lpMsg->hwnd),BN_CLICKED), (LPARAM)lpMsg->hwnd);
2377                  }
2378                  else if (DC_HASDEFID == HIWORD(dw = SendMessageW (hDlg, DM_GETDEFID, 0, 0)))
2379                  {
2380                      SendMessageW( hDlg, WM_COMMAND, MAKEWPARAM( LOWORD(dw), BN_CLICKED ),
2381                                      (LPARAM)GetDlgItem(hDlg, LOWORD(dw)));
2382                  }
2383                  else
2384                  {
2385                      SendMessageW( hDlg, WM_COMMAND, IDOK, (LPARAM)GetDlgItem( hDlg, IDOK ) );
2386
2387                  }
2388              }
2389              return TRUE;
2390          }
2391          break;
2392
2393      case WM_CHAR:
2394          dlgCode = SendMessageW( lpMsg->hwnd, WM_GETDLGCODE, lpMsg->wParam, (LPARAM)lpMsg );
2395          if (dlgCode & (DLGC_WANTCHARS|DLGC_WANTMESSAGE)) break;
2396          if (lpMsg->wParam == '\t' && (dlgCode & DLGC_WANTTAB)) break;
2397          /* drop through */
2398
2399      case WM_SYSCHAR:
2400          if (DIALOG_IsAccelerator( lpMsg->hwnd, hDlg, lpMsg->wParam ))
2401          {
2402              /* don't translate or dispatch */
2403              return TRUE;
2404          }
2405          break;
2406
2407      case WM_SYSKEYDOWN:
2408          /* If the ALT key is being pressed display the keyboard cues */
2409          if (lpMsg->lParam & (1 << 29))
2410              SendMessageW(hDlg, WM_CHANGEUISTATE, MAKEWPARAM(UIS_CLEAR, UISF_HIDEACCEL | UISF_HIDEFOCUS), 0);
2411          break;
2412      }
2413
2414      TranslateMessage( lpMsg );
2415      DispatchMessageW( lpMsg );
2416      return TRUE;
2417 }
2418
2419
2420 /*
2421  * @implemented
2422  */
2423 UINT
2424 WINAPI
2425 IsDlgButtonChecked(
2426   HWND hDlg,
2427   int nIDButton)
2428 {
2429   return (UINT)SendDlgItemMessageW( hDlg, nIDButton, BM_GETCHECK, 0, 0 );
2430 }
2431
2432
2433 /*
2434  * @implemented
2435  */
2436 BOOL
2437 WINAPI
2438 MapDialogRect(
2439   HWND hDlg,
2440   LPRECT lpRect)
2441 {
2442         DIALOGINFO * dlgInfo;
2443         if (!(dlgInfo = GETDLGINFO(hDlg))) return FALSE;
2444         lpRect->left   = MulDiv(lpRect->left, dlgInfo->xBaseUnit, 4);
2445         lpRect->right  = MulDiv(lpRect->right, dlgInfo->xBaseUnit, 4);
2446         lpRect->top    = MulDiv(lpRect->top, dlgInfo->yBaseUnit, 8);
2447         lpRect->bottom = MulDiv(lpRect->bottom, dlgInfo->yBaseUnit, 8);
2448         return TRUE;
2449 }
2450
2451
2452 /*
2453  * @implemented
2454  */
2455 LRESULT
2456 WINAPI
2457 SendDlgItemMessageA(
2458   HWND hDlg,
2459   int nIDDlgItem,
2460   UINT Msg,
2461   WPARAM wParam,
2462   LPARAM lParam)
2463 {
2464         HWND hwndCtrl = GetDlgItem( hDlg, nIDDlgItem );
2465         if (hwndCtrl) return SendMessageA( hwndCtrl, Msg, wParam, lParam );
2466         else return 0;
2467 }
2468
2469
2470 /*
2471  * @implemented
2472  */
2473 LRESULT
2474 WINAPI
2475 SendDlgItemMessageW(
2476   HWND hDlg,
2477   int nIDDlgItem,
2478   UINT Msg,
2479   WPARAM wParam,
2480   LPARAM lParam)
2481 {
2482         HWND hwndCtrl = GetDlgItem( hDlg, nIDDlgItem );
2483         if (hwndCtrl) return SendMessageW( hwndCtrl, Msg, wParam, lParam );
2484         else return 0;
2485 }
2486
2487
2488 /*
2489  * @implemented
2490  */
2491 BOOL
2492 WINAPI
2493 SetDlgItemInt(
2494   HWND hDlg,
2495   int nIDDlgItem,
2496   UINT uValue,
2497   BOOL bSigned)
2498 {
2499         char str[20];
2500
2501         if (bSigned) sprintf( str, "%d", (INT)uValue );
2502         else sprintf( str, "%u", uValue );
2503         SendDlgItemMessageA( hDlg, nIDDlgItem, WM_SETTEXT, 0, (LPARAM)str );
2504         return TRUE;
2505 }
2506
2507
2508 /*
2509  * @implemented
2510  */
2511 BOOL
2512 WINAPI
2513 SetDlgItemTextA(
2514   HWND hDlg,
2515   int nIDDlgItem,
2516   LPCSTR lpString)
2517 {
2518   return SendDlgItemMessageA( hDlg, nIDDlgItem, WM_SETTEXT, 0, (LPARAM)lpString );
2519 }
2520
2521
2522 /*
2523  * @implemented
2524  */
2525 BOOL
2526 WINAPI
2527 SetDlgItemTextW(
2528   HWND hDlg,
2529   int nIDDlgItem,
2530   LPCWSTR lpString)
2531 {
2532   return SendDlgItemMessageW( hDlg, nIDDlgItem, WM_SETTEXT, 0, (LPARAM)lpString );
2533 }
2534
2535
2536 /*
2537  * @implemented
2538  */
2539 BOOL
2540 WINAPI
2541 CheckDlgButton(
2542   HWND hDlg,
2543   int nIDButton,
2544   UINT uCheck)
2545 {
2546         SendDlgItemMessageW( hDlg, nIDButton, BM_SETCHECK, uCheck, 0 );
2547         return TRUE;
2548 }
2549
2550 static BOOL CALLBACK CheckRB(HWND hwnd, LPARAM lParam)
2551 {
2552   LONG lChildID = GetWindowLongPtrW(hwnd, GWLP_ID);
2553   RADIOGROUP *lpRadioGroup = (RADIOGROUP *)lParam;
2554
2555   if((lChildID >= lpRadioGroup->firstID) &&
2556      (lChildID <= lpRadioGroup->lastID))
2557   {
2558     if (lChildID == lpRadioGroup->checkID)
2559     {
2560       SendMessageW(hwnd, BM_SETCHECK, BST_CHECKED, 0);
2561     }
2562     else
2563     {
2564       SendMessageW(hwnd, BM_SETCHECK, BST_UNCHECKED, 0);
2565     }
2566   }
2567
2568    return TRUE;
2569 }
2570
2571 /*
2572  * @implemented
2573  */
2574 BOOL
2575 WINAPI
2576 CheckRadioButton(
2577   HWND hDlg,
2578   int nIDFirstButton,
2579   int nIDLastButton,
2580   int nIDCheckButton)
2581 {
2582   RADIOGROUP radioGroup;
2583
2584   radioGroup.firstID = nIDFirstButton;
2585   radioGroup.lastID = nIDLastButton;
2586   radioGroup.checkID = nIDCheckButton;
2587
2588   return EnumChildWindows(hDlg, CheckRB, (LPARAM)&radioGroup);
2589 }