windows/dialog.c

   1 /*
   2  * Dialog functions
   3  *
   4  * Copyright 1993, 1994, 1996 Alexandre Julliard
   5  */
   6
   7 #include <ctype.h>
   8 #include <errno.h>
   9 #include <limits.h>
  10 #include <stdlib.h>
  11 #include <stdio.h>
  12 #include <string.h>
  13
  14 #include "windef.h"
  15 #include "winnls.h"
  16 #include "winbase.h"
  17 #include "wingdi.h"
  18 #include "winuser.h"
  19 #include "windowsx.h"
  20 #include "wine/winuser16.h"
  21 #include "wine/winbase16.h"
  22 #include "wine/unicode.h"
  23 #include "wine/port.h"
  24 #include "controls.h"
  25 #include "heap.h"
  26 #include "win.h"
  27 #include "user.h"
  28 #include "message.h"
  29 #include "queue.h"
  30 #include "debugtools.h"
  31
  32 DEFAULT_DEBUG_CHANNEL(dialog);
  33
  34
  35   /* Dialog control information */
  36 typedef struct
  37 {
  38     DWORD      style;
  39     DWORD      exStyle;
  40     DWORD      helpId;
  41     INT16      x;
  42     INT16      y;
  43     INT16      cx;
  44     INT16      cy;
  45     UINT     id;
  46     LPCSTR     className;
  47     LPCSTR     windowName;
  48     LPVOID     data;
  49 } DLG_CONTROL_INFO;
  50
  51   /* Dialog template */
  52 typedef struct
  53 {
  54     DWORD      style;
  55     DWORD      exStyle;
  56     DWORD      helpId;
  57     UINT16     nbItems;
  58     INT16      x;
  59     INT16      y;
  60     INT16      cx;
  61     INT16      cy;
  62     LPCSTR     menuName;
  63     LPCSTR     className;
  64     LPCSTR     caption;
  65     WORD       pointSize;
  66     WORD       weight;
  67     BOOL     italic;
  68     LPCSTR     faceName;
  69     BOOL     dialogEx;
  70 } DLG_TEMPLATE;
  71
  72   /* Radio button group */
  73 typedef struct
  74 {
  75     UINT firstID;
  76     UINT lastID;
  77     UINT checkID;
  78 } RADIOGROUP;
  79
  80   /* Dialog base units */
  81 static WORD xBaseUnit = 0, yBaseUnit = 0;
  82
  83
  84 /*********************************************************************
  85  * dialog class descriptor
  86  */
  87 const struct builtin_class_descr DIALOG_builtin_class =
  88 {
  89     DIALOG_CLASS_ATOM,  /* name */
  90     CS_GLOBALCLASS | CS_SAVEBITS, /* style  */
  91     DefDlgProcA,        /* procA */
  92     DefDlgProcW,        /* procW */
  93     DLGWINDOWEXTRA,     /* extra */
  94     IDC_ARROWA,         /* cursor */
  95     0                   /* brush */
  96 };
  97
  98
  99 /***********************************************************************
 100  *           DIALOG_EnableOwner
 101  *
 102  * Helper function for modal dialogs to enable again the
 103  * owner of the dialog box.
 104  */
 105 void DIALOG_EnableOwner( HWND hOwner, BOOL ownerWasEnabled)
 106 {
 107     /* Owner must be a top-level window */
 108     if (hOwner)
 109         hOwner = WIN_GetTopParent( hOwner );
 110     if (!hOwner) return;
 111     if (ownerWasEnabled)
 112         EnableWindow( hOwner, TRUE );
 113 }
 114
 115
 116 /***********************************************************************
 117  *           DIALOG_DisableOwner
 118  *
 119  * Helper function for modal dialogs to disable the
 120  * owner of the dialog box. Returns TRUE if owner was enabled.
 121  */
 122 BOOL DIALOG_DisableOwner( HWND hOwner )
 123 {
 124     /* Owner must be a top-level window */
 125     if (hOwner)
 126         hOwner = WIN_GetTopParent( hOwner );
 127     if (!hOwner) return FALSE;
 128     if (IsWindowEnabled( hOwner ))
 129     {
 130         EnableWindow( hOwner, FALSE );
 131         return TRUE;
 132     }
 133     else
 134         return FALSE;
 135 }
 136
 137 /***********************************************************************
 138  *           DIALOG_GetCharSizeFromDC
 139  *
 140  *
 141  *  Calculates the *true* average size of English characters in the
 142  *  specified font as oppposed to the one returned by GetTextMetrics.
 143  *
 144  *  Latest: the X font driver will now compute a proper average width
 145  *  so this code can be removed
 146  */
 147 static BOOL DIALOG_GetCharSizeFromDC( HDC hDC, HFONT hFont, SIZE * pSize )
 148 {
 149     BOOL Success = FALSE;
 150     HFONT hFontPrev = 0;
 151     pSize->cx = xBaseUnit;
 152     pSize->cy = yBaseUnit;
 153     if ( hDC )
 154     {
 155         /* select the font */
 156         TEXTMETRICA tm;
 157         memset(&tm,0,sizeof(tm));
 158         if (hFont) hFontPrev = SelectFont(hDC,hFont);
 159         if (GetTextMetricsA(hDC,&tm))
 160         {
 161             pSize->cx = tm.tmAveCharWidth;
 162             pSize->cy = tm.tmHeight;
 163
 164             /* if variable width font */
 165             if (tm.tmPitchAndFamily & TMPF_FIXED_PITCH)
 166             {
 167                 SIZE total;
 168                 const char* szAvgChars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
 169
 170                 /* Calculate a true average as opposed to the one returned
 171                  * by tmAveCharWidth. This works better when dealing with
 172                  * proportional spaced fonts and (more important) that's
 173                  * how Microsoft's dialog creation code calculates the size
 174                  * of the font
 175                  */
 176                 if (GetTextExtentPointA(hDC,szAvgChars,sizeof(szAvgChars),&total))
 177                 {
 178                    /* round up */
 179                     pSize->cx = ((2*total.cx/sizeof(szAvgChars)) + 1)/2;
 180                     Success = TRUE;
 181                 }
 182             }
 183             else
 184             {
 185                 Success = TRUE;
 186             }
 187             /* Use the text metrics */
 188             TRACE("Using tm: %ldx%ld (dlg: %ld x %ld) (%s)\n",
 189                   tm.tmAveCharWidth, tm.tmHeight, pSize->cx, pSize->cy,
 190                   tm.tmPitchAndFamily & TMPF_FIXED_PITCH ? "variable" : "fixed");
 191             pSize->cx = tm.tmAveCharWidth;
 192             pSize->cy = tm.tmHeight;
 193         }
 194         /* select the original font */
 195         if (hFontPrev) SelectFont(hDC,hFontPrev);
 196     }
 197     return (Success);
 198 }
 199
 200 /***********************************************************************
 201  *           DIALOG_GetCharSize
 202  *
 203  *  A convenient variant of DIALOG_GetCharSizeFromDC.
 204  */
 205 static BOOL DIALOG_GetCharSize( HFONT hFont, SIZE * pSize )
 206 {
 207     HDC  hDC = GetDC(0);
 208     BOOL Success = DIALOG_GetCharSizeFromDC( hDC, hFont, pSize );
 209     ReleaseDC(0, hDC);
 210     return Success;
 211 }
 212
 213 /***********************************************************************
 214  *           DIALOG_Init
 215  *
 216  * Initialisation of the dialog manager.
 217  */
 218 BOOL DIALOG_Init(void)
 219 {
 220     HDC hdc;
 221     SIZE size;
 222
 223       /* Calculate the dialog base units */
 224
 225     if (!(hdc = CreateDCA( "DISPLAY", NULL, NULL, NULL )))
 226     {
 227         ERR("Could not create Display DC\n");
 228         return FALSE;
 229     }
 230
 231     if (!DIALOG_GetCharSizeFromDC( hdc, 0, &size ))
 232     {
 233         DeleteDC( hdc );
 234         ERR("Could not initialize base dialog units\n");
 235         return FALSE;
 236     }
 237
 238     DeleteDC( hdc );
 239     xBaseUnit = size.cx;
 240     yBaseUnit = size.cy;
 241
 242     TRACE("base units = %d,%d\n", xBaseUnit, yBaseUnit );
 243     return TRUE;
 244 }
 245
 246
 247 /***********************************************************************
 248  *           DIALOG_GetControl16
 249  *
 250  * Return the class and text of the control pointed to by ptr,
 251  * fill the header structure and return a pointer to the next control.
 252  */
 253 static LPCSTR DIALOG_GetControl16( LPCSTR p, DLG_CONTROL_INFO *info )
 254 {
 255     static char buffer[10];
 256     int int_id;
 257
 258     info->x       = GET_WORD(p);  p += sizeof(WORD);
 259     info->y       = GET_WORD(p);  p += sizeof(WORD);
 260     info->cx      = GET_WORD(p);  p += sizeof(WORD);
 261     info->cy      = GET_WORD(p);  p += sizeof(WORD);
 262     info->id      = GET_WORD(p);  p += sizeof(WORD);
 263     info->style   = GET_DWORD(p); p += sizeof(DWORD);
 264     info->exStyle = 0;
 265
 266     if (*p & 0x80)
 267     {
 268         switch((BYTE)*p)
 269         {
 270             case 0x80: strcpy( buffer, "BUTTON" ); break;
 271             case 0x81: strcpy( buffer, "EDIT" ); break;
 272             case 0x82: strcpy( buffer, "STATIC" ); break;
 273             case 0x83: strcpy( buffer, "LISTBOX" ); break;
 274             case 0x84: strcpy( buffer, "SCROLLBAR" ); break;
 275             case 0x85: strcpy( buffer, "COMBOBOX" ); break;
 276             default:   buffer[0] = '\0'; break;
 277         }
 278         info->className = buffer;
 279         p++;
 280     }
 281     else
 282     {
 283         info->className = p;
 284         p += strlen(p) + 1;
 285     }
 286
 287     int_id = ((BYTE)*p == 0xff);
 288     if (int_id)
 289     {
 290           /* Integer id, not documented (?). Only works for SS_ICON controls */
 291         info->windowName = (LPCSTR)(UINT)GET_WORD(p+1);
 292         p += 3;
 293     }
 294     else
 295     {
 296         info->windowName = p;
 297         p += strlen(p) + 1;
 298     }
 299
 300     if (*p)
 301     {
 302         /* Additional CTLDATA available for this control. */
 303         info->data = SEGPTR_ALLOC(*p);
 304         memcpy( info->data, p + 1, *p );
 305     }
 306     else info->data = NULL;
 307
 308     p += *p + 1;
 309
 310     if(int_id)
 311       TRACE("   %s %04x %d, %d, %d, %d, %d, %08lx, %08lx\n",
 312                       info->className,  LOWORD(info->windowName),
 313                       info->id, info->x, info->y, info->cx, info->cy,
 314                       info->style, (DWORD)SEGPTR_GET(info->data) );
 315     else
 316       TRACE("   %s '%s' %d, %d, %d, %d, %d, %08lx, %08lx\n",
 317                       info->className,  info->windowName,
 318                       info->id, info->x, info->y, info->cx, info->cy,
 319                       info->style, (DWORD)SEGPTR_GET(info->data) );
 320
 321     return p;
 322 }
 323
 324
 325 /***********************************************************************
 326  *           DIALOG_GetControl32
 327  *
 328  * Return the class and text of the control pointed to by ptr,
 329  * fill the header structure and return a pointer to the next control.
 330  */
 331 static const WORD *DIALOG_GetControl32( const WORD *p, DLG_CONTROL_INFO *info,
 332                                         BOOL dialogEx )
 333 {
 334     if (dialogEx)
 335     {
 336         info->helpId  = GET_DWORD(p); p += 2;
 337         info->exStyle = GET_DWORD(p); p += 2;
 338         info->style   = GET_DWORD(p); p += 2;
 339     }
 340     else
 341     {
 342         info->helpId  = 0;
 343         info->style   = GET_DWORD(p); p += 2;
 344         info->exStyle = GET_DWORD(p); p += 2;
 345     }
 346     info->x       = GET_WORD(p); p++;
 347     info->y       = GET_WORD(p); p++;
 348     info->cx      = GET_WORD(p); p++;
 349     info->cy      = GET_WORD(p); p++;
 350
 351     if (dialogEx)
 352     {
 353         /* id is a DWORD for DIALOGEX */
 354         info->id = GET_DWORD(p);
 355         p += 2;
 356     }
 357     else
 358     {
 359         info->id = GET_WORD(p);
 360         p++;
 361     }
 362
 363     if (GET_WORD(p) == 0xffff)
 364     {
 365         static const WCHAR class_names[6][10] =
 366         {
 367             { 'B','u','t','t','o','n', },             /* 0x80 */
 368             { 'E','d','i','t', },                     /* 0x81 */
 369             { 'S','t','a','t','i','c', },             /* 0x82 */
 370             { 'L','i','s','t','B','o','x', },         /* 0x83 */
 371             { 'S','c','r','o','l','l','B','a','r', }, /* 0x84 */
 372             { 'C','o','m','b','o','B','o','x', }      /* 0x85 */
 373         };
 374         WORD id = GET_WORD(p+1);
 375         if ((id >= 0x80) && (id <= 0x85))
 376             info->className = (LPCSTR)class_names[id - 0x80];
 377         else
 378         {
 379             info->className = NULL;
 380             ERR("Unknown built-in class id %04x\n", id );
 381         }
 382         p += 2;
 383     }
 384     else
 385     {
 386         info->className = (LPCSTR)p;
 387         p += strlenW( (LPCWSTR)p ) + 1;
 388     }
 389
 390     if (GET_WORD(p) == 0xffff)  /* Is it an integer id? */
 391     {
 392         info->windowName = (LPCSTR)(UINT)GET_WORD(p + 1);
 393         p += 2;
 394     }
 395     else
 396     {
 397         info->windowName = (LPCSTR)p;
 398         p += strlenW( (LPCWSTR)p ) + 1;
 399     }
 400
 401     TRACE("    %s %s %d, %d, %d, %d, %d, %08lx, %08lx, %08lx\n",
 402           debugstr_w( (LPCWSTR)info->className ),
 403           debugres_w( (LPCWSTR)info->windowName ),
 404           info->id, info->x, info->y, info->cx, info->cy,
 405           info->style, info->exStyle, info->helpId );
 406
 407     if (GET_WORD(p))
 408     {
 409         if (TRACE_ON(dialog))
 410         {
 411             WORD i, count = GET_WORD(p) / sizeof(WORD);
 412             TRACE("  BEGIN\n");
 413             TRACE("    ");
 414             for (i = 0; i < count; i++) DPRINTF( "%04x,", GET_WORD(p+i+1) );
 415             DPRINTF("\n");
 416             TRACE("  END\n" );
 417         }
 418         info->data = (LPVOID)(p + 1);
 419         p += GET_WORD(p) / sizeof(WORD);
 420     }
 421     else info->data = NULL;
 422     p++;
 423
 424     /* Next control is on dword boundary */
 425     return (const WORD *)((((int)p) + 3) & ~3);
 426 }
 427
 428
 429 /***********************************************************************
 430  *           DIALOG_CreateControls
 431  *
 432  * Create the control windows for a dialog.
 433  */
 434 static BOOL DIALOG_CreateControls( WND *pWnd, LPCSTR template,
 435                                      const DLG_TEMPLATE *dlgTemplate,
 436                                      HINSTANCE hInst, BOOL win32 )
 437 {
 438     DIALOGINFO *dlgInfo = (DIALOGINFO *)pWnd->wExtra;
 439     DLG_CONTROL_INFO info;
 440     HWND hwndCtrl, hwndDefButton = 0;
 441     INT items = dlgTemplate->nbItems;
 442
 443     TRACE(" BEGIN\n" );
 444     while (items--)
 445     {
 446         if (!win32)
 447         {
 448             HINSTANCE16 instance;
 449             template = DIALOG_GetControl16( template, &info );
 450             if (HIWORD(info.className) && !strcmp( info.className, "EDIT") &&
 451                 ((pWnd->dwStyle & DS_LOCALEDIT) != DS_LOCALEDIT))
 452             {
 453                 if (!dlgInfo->hDialogHeap)
 454                 {
 455                     dlgInfo->hDialogHeap = GlobalAlloc16(GMEM_FIXED, 0x10000);
 456                     if (!dlgInfo->hDialogHeap)
 457                     {
 458                         ERR("Insufficient memory to create heap for edit control\n" );
 459                         continue;
 460                     }
 461                     LocalInit16(dlgInfo->hDialogHeap, 0, 0xffff);
 462                 }
 463                 instance = dlgInfo->hDialogHeap;
 464             }
 465             else instance = (HINSTANCE16)hInst;
 466
 467             hwndCtrl = CreateWindowEx16( info.exStyle | WS_EX_NOPARENTNOTIFY,
 468                                          info.className, info.windowName,
 469                                          info.style | WS_CHILD,
 470                                          MulDiv(info.x, dlgInfo->xBaseUnit, 4),
 471                                          MulDiv(info.y, dlgInfo->yBaseUnit, 8),
 472                                          MulDiv(info.cx, dlgInfo->xBaseUnit, 4),
 473                                          MulDiv(info.cy, dlgInfo->yBaseUnit, 8),
 474                                          pWnd->hwndSelf, (HMENU16)info.id,
 475                                          instance, (LPVOID)SEGPTR_GET(info.data) );
 476
 477             if (info.data) SEGPTR_FREE(info.data);
 478         }
 479         else
 480         {
 481             template = (LPCSTR)DIALOG_GetControl32( (WORD *)template, &info,
 482                                                     dlgTemplate->dialogEx );
 483             hwndCtrl = CreateWindowExW( info.exStyle | WS_EX_NOPARENTNOTIFY,
 484                                           (LPCWSTR)info.className,
 485                                           (LPCWSTR)info.windowName,
 486                                           info.style | WS_CHILD,
 487                                           MulDiv(info.x, dlgInfo->xBaseUnit, 4),
 488                                           MulDiv(info.y, dlgInfo->yBaseUnit, 8),
 489                                           MulDiv(info.cx, dlgInfo->xBaseUnit, 4),
 490                                           MulDiv(info.cy, dlgInfo->yBaseUnit, 8),
 491                                           pWnd->hwndSelf, (HMENU)info.id,
 492                                           hInst, info.data );
 493         }
 494         if (!hwndCtrl) return FALSE;
 495
 496             /* Send initialisation messages to the control */
 497         if (dlgInfo->hUserFont) SendMessageA( hwndCtrl, WM_SETFONT,
 498                                              (WPARAM)dlgInfo->hUserFont, 0 );
 499         if (SendMessageA(hwndCtrl, WM_GETDLGCODE, 0, 0) & DLGC_DEFPUSHBUTTON)
 500         {
 501               /* If there's already a default push-button, set it back */
 502               /* to normal and use this one instead. */
 503             if (hwndDefButton)
 504                 SendMessageA( hwndDefButton, BM_SETSTYLE,
 505                                 BS_PUSHBUTTON,FALSE );
 506             hwndDefButton = hwndCtrl;
 507             dlgInfo->idResult = GetWindowWord( hwndCtrl, GWW_ID );
 508         }
 509     }
 510     TRACE(" END\n" );
 511     return TRUE;
 512 }
 513
 514
 515 /***********************************************************************
 516  *           DIALOG_ParseTemplate16
 517  *
 518  * Fill a DLG_TEMPLATE structure from the dialog template, and return
 519  * a pointer to the first control.
 520  */
 521 static LPCSTR DIALOG_ParseTemplate16( LPCSTR p, DLG_TEMPLATE * result )
 522 {
 523     result->style   = GET_DWORD(p); p += sizeof(DWORD);
 524     result->exStyle = 0;
 525     result->nbItems = (unsigned char) *p++;
 526     result->x       = GET_WORD(p);  p += sizeof(WORD);
 527     result->y       = GET_WORD(p);  p += sizeof(WORD);
 528     result->cx      = GET_WORD(p);  p += sizeof(WORD);
 529     result->cy      = GET_WORD(p);  p += sizeof(WORD);
 530     TRACE("DIALOG %d, %d, %d, %d\n",
 531                     result->x, result->y, result->cx, result->cy );
 532     TRACE(" STYLE %08lx\n", result->style );
 533
 534     /* Get the menu name */
 535
 536     switch( (BYTE)*p )
 537     {
 538     case 0:
 539         result->menuName = 0;
 540         p++;
 541         break;
 542     case 0xff:
 543         result->menuName = (LPCSTR)(UINT)GET_WORD( p + 1 );
 544         p += 3;
 545         TRACE(" MENU %04x\n", LOWORD(result->menuName) );
 546         break;
 547     default:
 548         result->menuName = p;
 549         TRACE(" MENU '%s'\n", p );
 550         p += strlen(p) + 1;
 551         break;
 552     }
 553
 554     /* Get the class name */
 555
 556     if (*p)
 557     {
 558         result->className = p;
 559         TRACE(" CLASS '%s'\n", result->className );
 560     }
 561     else result->className = DIALOG_CLASS_ATOM;
 562     p += strlen(p) + 1;
 563
 564     /* Get the window caption */
 565
 566     result->caption = p;
 567     p += strlen(p) + 1;
 568     TRACE(" CAPTION '%s'\n", result->caption );
 569
 570     /* Get the font name */
 571
 572     if (result->style & DS_SETFONT)
 573     {
 574         result->pointSize = GET_WORD(p);
 575         p += sizeof(WORD);
 576         result->faceName = p;
 577         p += strlen(p) + 1;
 578         TRACE(" FONT %d,'%s'\n",
 579                         result->pointSize, result->faceName );
 580     }
 581     return p;
 582 }
 583
 584
 585 /***********************************************************************
 586  *           DIALOG_ParseTemplate32
 587  *
 588  * Fill a DLG_TEMPLATE structure from the dialog template, and return
 589  * a pointer to the first control.
 590  */
 591 static LPCSTR DIALOG_ParseTemplate32( LPCSTR template, DLG_TEMPLATE * result )
 592 {
 593     const WORD *p = (const WORD *)template;
 594
 595     result->style = GET_DWORD(p); p += 2;
 596     if (result->style == 0xffff0001)  /* DIALOGEX resource */
 597     {
 598         result->dialogEx = TRUE;
 599         result->helpId   = GET_DWORD(p); p += 2;
 600         result->exStyle  = GET_DWORD(p); p += 2;
 601         result->style    = GET_DWORD(p); p += 2;
 602     }
 603     else
 604     {
 605         result->dialogEx = FALSE;
 606         result->helpId   = 0;
 607         result->exStyle  = GET_DWORD(p); p += 2;
 608     }
 609     result->nbItems = GET_WORD(p); p++;
 610     result->x       = GET_WORD(p); p++;
 611     result->y       = GET_WORD(p); p++;
 612     result->cx      = GET_WORD(p); p++;
 613     result->cy      = GET_WORD(p); p++;
 614     TRACE("DIALOG%s %d, %d, %d, %d, %ld\n",
 615            result->dialogEx ? "EX" : "", result->x, result->y,
 616            result->cx, result->cy, result->helpId );
 617     TRACE(" STYLE 0x%08lx\n", result->style );
 618     TRACE(" EXSTYLE 0x%08lx\n", result->exStyle );
 619
 620     /* Get the menu name */
 621
 622     switch(GET_WORD(p))
 623     {
 624     case 0x0000:
 625         result->menuName = NULL;
 626         p++;
 627         break;
 628     case 0xffff:
 629         result->menuName = (LPCSTR)(UINT)GET_WORD( p + 1 );
 630         p += 2;
 631         TRACE(" MENU %04x\n", LOWORD(result->menuName) );
 632         break;
 633     default:
 634         result->menuName = (LPCSTR)p;
 635         TRACE(" MENU %s\n", debugstr_w( (LPCWSTR)p ));
 636         p += strlenW( (LPCWSTR)p ) + 1;
 637         break;
 638     }
 639
 640     /* Get the class name */
 641
 642     switch(GET_WORD(p))
 643     {
 644     case 0x0000:
 645         result->className = DIALOG_CLASS_ATOM;
 646         p++;
 647         break;
 648     case 0xffff:
 649         result->className = (LPCSTR)(UINT)GET_WORD( p + 1 );
 650         p += 2;
 651         TRACE(" CLASS %04x\n", LOWORD(result->className) );
 652         break;
 653     default:
 654         result->className = (LPCSTR)p;
 655         TRACE(" CLASS %s\n", debugstr_w( (LPCWSTR)p ));
 656         p += strlenW( (LPCWSTR)p ) + 1;
 657         break;
 658     }
 659
 660     /* Get the window caption */
 661
 662     result->caption = (LPCSTR)p;
 663     p += strlenW( (LPCWSTR)p ) + 1;
 664     TRACE(" CAPTION %s\n", debugstr_w( (LPCWSTR)result->caption ) );
 665
 666     /* Get the font name */
 667
 668     if (result->style & DS_SETFONT)
 669     {
 670         result->pointSize = GET_WORD(p);
 671         p++;
 672         if (result->dialogEx)
 673         {
 674             result->weight = GET_WORD(p); p++;
 675             result->italic = LOBYTE(GET_WORD(p)); p++;
 676         }
 677         else
 678         {
 679             result->weight = FW_DONTCARE;
 680             result->italic = FALSE;
 681         }
 682         result->faceName = (LPCSTR)p;
 683         p += strlenW( (LPCWSTR)p ) + 1;
 684         TRACE(" FONT %d, %s, %d, %s\n",
 685               result->pointSize, debugstr_w( (LPCWSTR)result->faceName ),
 686               result->weight, result->italic ? "TRUE" : "FALSE" );
 687     }
 688
 689     /* First control is on dword boundary */
 690     return (LPCSTR)((((int)p) + 3) & ~3);
 691 }
 692
 693
 694 /***********************************************************************
 695  *           DIALOG_CreateIndirect
 696  *       Creates a dialog box window
 697  *
 698  *       modal = TRUE if we are called from a modal dialog box.
 699  *       (it's more compatible to do it here, as under Windows the owner
 700  *       is never disabled if the dialog fails because of an invalid template)
 701  */
 702 static HWND DIALOG_CreateIndirect( HINSTANCE hInst, LPCSTR dlgTemplate,
 703                                    BOOL win32Template, HWND owner,
 704                                    DLGPROC16 dlgProc, LPARAM param,
 705                                    WINDOWPROCTYPE procType, BOOL modal )
 706 {
 707     HMENU16 hMenu = 0;
 708     HFONT16 hFont = 0;
 709     HWND hwnd;
 710     RECT rect;
 711     WND * wndPtr;
 712     DLG_TEMPLATE template;
 713     DIALOGINFO * dlgInfo;
 714     WORD xUnit = xBaseUnit;
 715     WORD yUnit = yBaseUnit;
 716     BOOL ownerEnabled = TRUE;
 717
 718       /* Parse dialog template */
 719
 720     if (!dlgTemplate) return 0;
 721     if (win32Template)
 722         dlgTemplate = DIALOG_ParseTemplate32( dlgTemplate, &template );
 723     else
 724         dlgTemplate = DIALOG_ParseTemplate16( dlgTemplate, &template );
 725
 726       /* Load menu */
 727
 728     if (template.menuName)
 729     {
 730         if (!win32Template) hMenu = LoadMenu16( hInst, template.menuName );
 731         else hMenu = LoadMenuW( hInst, (LPCWSTR)template.menuName );
 732     }
 733
 734       /* Create custom font if needed */
 735
 736     if (template.style & DS_SETFONT)
 737     {
 738           /* The font height must be negative as it is a point size */
 739           /* and must be converted to pixels first */
 740           /* (see CreateFont() documentation in the Windows SDK).   */
 741         HDC dc;
 742         int pixels;
 743         if (((short)template.pointSize) < 0)
 744             pixels = -((short)template.pointSize);
 745         else
 746         {
 747             dc = GetDC(0);
 748             pixels = template.pointSize * GetDeviceCaps(dc , LOGPIXELSY)/72;
 749             ReleaseDC(0, dc);
 750         }
 751         if (win32Template)
 752             hFont = CreateFontW( -pixels, 0, 0, 0, template.weight,
 753                                  template.italic, FALSE, FALSE,
 754                                  DEFAULT_CHARSET, 0, 0,
 755                                  PROOF_QUALITY, FF_DONTCARE,
 756                                  (LPCWSTR)template.faceName );
 757         else
 758             hFont = CreateFontA( -pixels, 0, 0, 0, FW_DONTCARE,
 759                                  FALSE, FALSE, FALSE,
 760                                  DEFAULT_CHARSET, 0, 0,
 761                                  PROOF_QUALITY, FF_DONTCARE,
 762                                  template.faceName );
 763         if (hFont)
 764         {
 765             SIZE charSize;
 766             if (DIALOG_GetCharSize(hFont,&charSize))
 767             {
 768                 xUnit = charSize.cx;
 769                 yUnit = charSize.cy;
 770             }
 771         }
 772         TRACE("units = %d,%d\n", xUnit, yUnit );
 773     }
 774
 775     /* Create dialog main window */
 776
 777     rect.left = rect.top = 0;
 778     rect.right = MulDiv(template.cx, xUnit, 4);
 779     rect.bottom =  MulDiv(template.cy, yUnit, 8);
 780     if (template.style & DS_MODALFRAME)
 781         template.exStyle |= WS_EX_DLGMODALFRAME;
 782     AdjustWindowRectEx( &rect, template.style,
 783                           hMenu ? TRUE : FALSE , template.exStyle );
 784     rect.right -= rect.left;
 785     rect.bottom -= rect.top;
 786
 787     if ((INT16)template.x == CW_USEDEFAULT16)
 788     {
 789         rect.left = rect.top = win32Template? CW_USEDEFAULT : CW_USEDEFAULT16;
 790     }
 791     else
 792     {
 793         if (template.style & DS_CENTER)
 794         {
 795             rect.left = (GetSystemMetrics(SM_CXSCREEN) - rect.right) / 2;
 796             rect.top = (GetSystemMetrics(SM_CYSCREEN) - rect.bottom) / 2;
 797         }
 798         else
 799         {
 800             rect.left += MulDiv(template.x, xUnit, 4);
 801             rect.top += MulDiv(template.y, yUnit, 8);
 802         }
 803         if ( !(template.style & WS_CHILD) )
 804         {
 805             INT16 dX, dY;
 806
 807             if( !(template.style & DS_ABSALIGN) )
 808                 ClientToScreen( owner, (POINT *)&rect );
 809
 810             /* try to fit it into the desktop */
 811
 812             if( (dX = rect.left + rect.right + GetSystemMetrics(SM_CXDLGFRAME)
 813                  - GetSystemMetrics(SM_CXSCREEN)) > 0 ) rect.left -= dX;
 814             if( (dY = rect.top + rect.bottom + GetSystemMetrics(SM_CYDLGFRAME)
 815                  - GetSystemMetrics(SM_CYSCREEN)) > 0 ) rect.top -= dY;
 816             if( rect.left < 0 ) rect.left = 0;
 817             if( rect.top < 0 ) rect.top = 0;
 818         }
 819     }
 820
 821     if (modal)
 822         ownerEnabled = DIALOG_DisableOwner( owner );
 823
 824     if (!win32Template)
 825         hwnd = CreateWindowEx16(template.exStyle, template.className,
 826                                 template.caption, template.style & ~WS_VISIBLE,
 827                                 rect.left, rect.top, rect.right, rect.bottom,
 828                                 owner, hMenu, hInst, NULL );
 829     else
 830         hwnd = CreateWindowExW(template.exStyle, (LPCWSTR)template.className,
 831                                  (LPCWSTR)template.caption,
 832                                  template.style & ~WS_VISIBLE,
 833                                  rect.left, rect.top, rect.right, rect.bottom,
 834                                  owner, hMenu, hInst, NULL );
 835
 836     if (!hwnd)
 837     {
 838         if (hFont) DeleteObject( hFont );
 839         if (hMenu) DestroyMenu( hMenu );
 840         if (modal)
 841             DIALOG_EnableOwner(owner, ownerEnabled);
 842         return 0;
 843     }
 844     wndPtr = WIN_FindWndPtr( hwnd );
 845     wndPtr->flags |= WIN_ISDIALOG;
 846     wndPtr->helpContext = template.helpId;
 847
 848       /* Initialise dialog extra data */
 849
 850     dlgInfo = (DIALOGINFO *)wndPtr->wExtra;
 851     WINPROC_SetProc( &dlgInfo->dlgProc, (WNDPROC16)dlgProc, procType, WIN_PROC_WINDOW );
 852     dlgInfo->hUserFont = hFont;
 853     dlgInfo->hMenu     = hMenu;
 854     dlgInfo->xBaseUnit = xUnit;
 855     dlgInfo->yBaseUnit = yUnit;
 856     dlgInfo->msgResult = 0;
 857     dlgInfo->idResult  = 0;
 858     dlgInfo->flags     = ownerEnabled ? DF_OWNERENABLED: 0;
 859     dlgInfo->hDialogHeap = 0;
 860
 861     if (dlgInfo->hUserFont)
 862         SendMessageA( hwnd, WM_SETFONT, (WPARAM)dlgInfo->hUserFont, 0 );
 863
 864     /* Create controls */
 865
 866     if (DIALOG_CreateControls( wndPtr, dlgTemplate, &template,
 867                                hInst, win32Template ))
 868     {
 869         HWND hwndPreInitFocus;
 870
 871         /* Send initialisation messages and set focus */
 872
 873         dlgInfo->hwndFocus = GetNextDlgTabItem( hwnd, 0, FALSE );
 874
 875         hwndPreInitFocus = GetFocus();
 876         if (SendMessageA( hwnd, WM_INITDIALOG, (WPARAM)dlgInfo->hwndFocus, param ))
 877         {
 878             /* check where the focus is again,
 879              * some controls status might have changed in WM_INITDIALOG */
 880             dlgInfo->hwndFocus = GetNextDlgTabItem( hwnd, 0, FALSE);
 881             SetFocus( dlgInfo->hwndFocus );
 882         }
 883         else
 884         {
 885             /* If the dlgproc has returned FALSE (indicating handling of keyboard focus)
 886                but the focus has not changed, set the focus where we expect it. */
 887             if ( (wndPtr->dwStyle & WS_VISIBLE) && ( GetFocus() == hwndPreInitFocus ) )
 888             {
 889                 dlgInfo->hwndFocus = GetNextDlgTabItem( hwnd, 0, FALSE);
 890                 SetFocus( dlgInfo->hwndFocus );
 891             }
 892         }
 893
 894         if (template.style & WS_VISIBLE && !(wndPtr->dwStyle & WS_VISIBLE))
 895         {
 896            ShowWindow( hwnd, SW_SHOWNORMAL );   /* SW_SHOW doesn't always work */
 897         }
 898         WIN_ReleaseWndPtr(wndPtr);
 899         return hwnd;
 900     }
 901     WIN_ReleaseWndPtr(wndPtr);
 902     if( IsWindow(hwnd) ) DestroyWindow( hwnd );
 903     if (modal)
 904         DIALOG_EnableOwner(owner, ownerEnabled);
 905     return 0;
 906 }
 907
 908
 909 /***********************************************************************
 910  *              CreateDialog (USER.89)
 911  */
 912 HWND16 WINAPI CreateDialog16( HINSTANCE16 hInst, LPCSTR dlgTemplate,
 913                               HWND16 owner, DLGPROC16 dlgProc )
 914 {
 915     return CreateDialogParam16( hInst, dlgTemplate, owner, dlgProc, 0 );
 916 }
 917
 918
 919 /***********************************************************************
 920  *              CreateDialogParam (USER.241)
 921  */
 922 HWND16 WINAPI CreateDialogParam16( HINSTANCE16 hInst, LPCSTR dlgTemplate,
 923                                    HWND16 owner, DLGPROC16 dlgProc,
 924                                    LPARAM param )
 925 {
 926     HWND16 hwnd = 0;
 927     HRSRC16 hRsrc;
 928     HGLOBAL16 hmem;
 929     LPCVOID data;
 930
 931     TRACE("%04x,%s,%04x,%08lx,%ld\n",
 932           hInst, debugres_a(dlgTemplate), owner, (DWORD)dlgProc, param );
 933
 934     if (!(hRsrc = FindResource16( hInst, dlgTemplate, RT_DIALOGA ))) return 0;
 935     if (!(hmem = LoadResource16( hInst, hRsrc ))) return 0;
 936     if (!(data = LockResource16( hmem ))) hwnd = 0;
 937     else hwnd = CreateDialogIndirectParam16( hInst, data, owner,
 938                                              dlgProc, param );
 939     FreeResource16( hmem );
 940     return hwnd;
 941 }
 942
 943 /***********************************************************************
 944  *              CreateDialogParamA (USER32.@)
 945  */
 946 HWND WINAPI CreateDialogParamA( HINSTANCE hInst, LPCSTR name,
 947                                     HWND owner, DLGPROC dlgProc,
 948                                     LPARAM param )
 949 {
 950     HANDLE hrsrc = FindResourceA( hInst, name, RT_DIALOGA );
 951     if (!hrsrc) return 0;
 952     return CreateDialogIndirectParamA( hInst,
 953                                          (LPVOID)LoadResource(hInst, hrsrc),
 954                                          owner, dlgProc, param );
 955 }
 956
 957
 958 /***********************************************************************
 959  *              CreateDialogParamW (USER32.@)
 960  */
 961 HWND WINAPI CreateDialogParamW( HINSTANCE hInst, LPCWSTR name,
 962                                     HWND owner, DLGPROC dlgProc,
 963                                     LPARAM param )
 964 {
 965     HANDLE hrsrc = FindResourceW( hInst, name, RT_DIALOGW );
 966     if (!hrsrc) return 0;
 967     return CreateDialogIndirectParamW( hInst,
 968                                          (LPVOID)LoadResource(hInst, hrsrc),
 969                                          owner, dlgProc, param );
 970 }
 971
 972
 973 /***********************************************************************
 974  *              CreateDialogIndirect (USER.219)
 975  */
 976 HWND16 WINAPI CreateDialogIndirect16( HINSTANCE16 hInst, LPCVOID dlgTemplate,
 977                                       HWND16 owner, DLGPROC16 dlgProc )
 978 {
 979     return CreateDialogIndirectParam16( hInst, dlgTemplate, owner, dlgProc, 0);
 980 }
 981
 982
 983 /***********************************************************************
 984  *              CreateDialogIndirectParam (USER.242)
 985  *              CreateDialogIndirectParam16 (USER32.@)
 986  */
 987 HWND16 WINAPI CreateDialogIndirectParam16( HINSTANCE16 hInst,
 988                                            LPCVOID dlgTemplate,
 989                                            HWND16 owner, DLGPROC16 dlgProc,
 990                                            LPARAM param )
 991 {
 992     return DIALOG_CreateIndirect( hInst, dlgTemplate, FALSE, owner,
 993                                   dlgProc, param, WIN_PROC_16, FALSE );
 994 }
 995
 996
 997 /***********************************************************************
 998  *              CreateDialogIndirectParamA (USER32.@)
 999  */
1000 HWND WINAPI CreateDialogIndirectParamA( HINSTANCE hInst,
1001                                             LPCVOID dlgTemplate,
1002                                             HWND owner, DLGPROC dlgProc,
1003                                             LPARAM param )
1004 {
1005     return DIALOG_CreateIndirect( hInst, dlgTemplate, TRUE, owner,
1006                                   (DLGPROC16)dlgProc, param, WIN_PROC_32A, FALSE );
1007 }
1008
1009 /***********************************************************************
1010  *              CreateDialogIndirectParamAorW (USER32.@)
1011  */
1012 HWND WINAPI CreateDialogIndirectParamAorW( HINSTANCE hInst,
1013                                             LPCVOID dlgTemplate,
1014                                             HWND owner, DLGPROC dlgProc,
1015                                             LPARAM param )
1016 {   FIXME("assume WIN_PROC_32W\n");
1017     return DIALOG_CreateIndirect( hInst, dlgTemplate, TRUE, owner,
1018                                   (DLGPROC16)dlgProc, param, WIN_PROC_32W, FALSE );
1019 }
1020
1021 /***********************************************************************
1022  *              CreateDialogIndirectParamW (USER32.@)
1023  */
1024 HWND WINAPI CreateDialogIndirectParamW( HINSTANCE hInst,
1025                                             LPCVOID dlgTemplate,
1026                                             HWND owner, DLGPROC dlgProc,
1027                                             LPARAM param )
1028 {
1029     return DIALOG_CreateIndirect( hInst, dlgTemplate, TRUE, owner,
1030                                   (DLGPROC16)dlgProc, param, WIN_PROC_32W, FALSE );
1031 }
1032
1033
1034 /***********************************************************************
1035  *           DIALOG_DoDialogBox
1036  */
1037 static INT DIALOG_DoDialogBox( HWND hwnd, HWND owner )
1038 {
1039     WND * wndPtr;
1040     DIALOGINFO * dlgInfo;
1041     MSG msg;
1042     INT retval;
1043     HWND ownerMsg = WIN_GetTopParent( owner );
1044
1045     if (!(wndPtr = WIN_FindWndPtr( hwnd ))) return -1;
1046     dlgInfo = (DIALOGINFO *)wndPtr->wExtra;
1047
1048     if (!(dlgInfo->flags & DF_END)) /* was EndDialog called in WM_INITDIALOG ? */
1049     {
1050         ShowWindow( hwnd, SW_SHOW );
1051         while (MSG_InternalGetMessage(QMSG_WIN32A, &msg, hwnd, ownerMsg, MSGF_DIALOGBOX,
1052                                       PM_REMOVE, !(wndPtr->dwStyle & DS_NOIDLEMSG), NULL ))
1053         {
1054             if (!(dlgInfo->flags & DF_END) && (!IsDialogMessageA( hwnd, &msg)))
1055             {
1056                 TranslateMessage( &msg );
1057                 DispatchMessageA( &msg );
1058             }
1059             if (dlgInfo->flags & DF_END) break;
1060         }
1061     }
1062     DIALOG_EnableOwner( owner, (dlgInfo->flags & DF_OWNERENABLED) );
1063     retval = dlgInfo->idResult;
1064     WIN_ReleaseWndPtr(wndPtr);
1065     DestroyWindow( hwnd );
1066     return retval;
1067 }
1068
1069
1070 /***********************************************************************
1071  *              DialogBox (USER.87)
1072  */
1073 INT16 WINAPI DialogBox16( HINSTANCE16 hInst, LPCSTR dlgTemplate,
1074                           HWND16 owner, DLGPROC16 dlgProc )
1075 {
1076     return DialogBoxParam16( hInst, dlgTemplate, owner, dlgProc, 0 );
1077 }
1078
1079
1080 /***********************************************************************
1081  *              DialogBoxParam (USER.239)
1082  */
1083 INT16 WINAPI DialogBoxParam16( HINSTANCE16 hInst, LPCSTR template,
1084                                HWND16 owner, DLGPROC16 dlgProc, LPARAM param )
1085 {
1086     HWND16 hwnd = 0;
1087     HRSRC16 hRsrc;
1088     HGLOBAL16 hmem;
1089     LPCVOID data;
1090     int ret = -1;
1091
1092     if (!(hRsrc = FindResource16( hInst, template, RT_DIALOGA ))) return 0;
1093     if (!(hmem = LoadResource16( hInst, hRsrc ))) return 0;
1094     if (!(data = LockResource16( hmem ))) hwnd = 0;
1095     else hwnd = DIALOG_CreateIndirect( hInst, data, FALSE, owner,
1096                                   dlgProc, param, WIN_PROC_16, TRUE );
1097     if (hwnd)
1098         ret =(INT16)DIALOG_DoDialogBox( hwnd, owner );
1099     if (data) GlobalUnlock16( hmem );
1100     FreeResource16( hmem );
1101     return ret;
1102 }
1103
1104
1105 /***********************************************************************
1106  *              DialogBoxParamA (USER32.@)
1107  */
1108 INT WINAPI DialogBoxParamA( HINSTANCE hInst, LPCSTR name,
1109                                 HWND owner, DLGPROC dlgProc, LPARAM param )
1110 {
1111     HWND hwnd;
1112     HANDLE hrsrc = FindResourceA( hInst, name, RT_DIALOGA );
1113     if (!hrsrc) return 0;
1114     hwnd = DIALOG_CreateIndirect( hInst, (LPVOID)LoadResource(hInst, hrsrc),
1115                                   TRUE, owner,
1116                                   (DLGPROC16) dlgProc, param, WIN_PROC_32A, TRUE );
1117     if (hwnd) return DIALOG_DoDialogBox( hwnd, owner );
1118     return -1;
1119 }
1120
1121
1122 /***********************************************************************
1123  *              DialogBoxParamW (USER32.@)
1124  */
1125 INT WINAPI DialogBoxParamW( HINSTANCE hInst, LPCWSTR name,
1126                                 HWND owner, DLGPROC dlgProc, LPARAM param )
1127 {
1128     HWND hwnd;
1129     HANDLE hrsrc = FindResourceW( hInst, name, RT_DIALOGW );
1130     if (!hrsrc) return 0;
1131     hwnd = DIALOG_CreateIndirect( hInst, (LPVOID)LoadResource(hInst, hrsrc),
1132                                   TRUE, owner,
1133                                   (DLGPROC16)dlgProc, param, WIN_PROC_32W, TRUE );
1134     if (hwnd) return DIALOG_DoDialogBox( hwnd, owner );
1135     return -1;
1136 }
1137
1138
1139 /***********************************************************************
1140  *              DialogBoxIndirect (USER.218)
1141  */
1142 INT16 WINAPI DialogBoxIndirect16( HINSTANCE16 hInst, HANDLE16 dlgTemplate,
1143                                   HWND16 owner, DLGPROC16 dlgProc )
1144 {
1145     return DialogBoxIndirectParam16( hInst, dlgTemplate, owner, dlgProc, 0 );
1146 }
1147
1148
1149 /***********************************************************************
1150  *              DialogBoxIndirectParam (USER.240)
1151  *              DialogBoxIndirectParam16 (USER32.@)
1152  */
1153 INT16 WINAPI DialogBoxIndirectParam16( HINSTANCE16 hInst, HANDLE16 dlgTemplate,
1154                                        HWND16 owner, DLGPROC16 dlgProc,
1155                                        LPARAM param )
1156 {
1157     HWND16 hwnd;
1158     LPCVOID ptr;
1159
1160     if (!(ptr = GlobalLock16( dlgTemplate ))) return -1;
1161     hwnd = DIALOG_CreateIndirect( hInst, ptr, FALSE, owner,
1162                                   dlgProc, param, WIN_PROC_16, TRUE );
1163     GlobalUnlock16( dlgTemplate );
1164     if (hwnd) return DIALOG_DoDialogBox( hwnd, owner );
1165     return -1;
1166 }
1167
1168
1169 /***********************************************************************
1170  *              DialogBoxIndirectParamA (USER32.@)
1171  */
1172 INT WINAPI DialogBoxIndirectParamA(HINSTANCE hInstance, LPCVOID template,
1173                                        HWND owner, DLGPROC dlgProc,
1174                                        LPARAM param )
1175 {
1176     HWND hwnd = DIALOG_CreateIndirect( hInstance, template, TRUE, owner,
1177                                   (DLGPROC16) dlgProc, param, WIN_PROC_32A, TRUE );
1178     if (hwnd) return DIALOG_DoDialogBox( hwnd, owner );
1179     return -1;
1180 }
1181
1182
1183 /***********************************************************************
1184  *              DialogBoxIndirectParamW (USER32.@)
1185  */
1186 INT WINAPI DialogBoxIndirectParamW(HINSTANCE hInstance, LPCVOID template,
1187                                        HWND owner, DLGPROC dlgProc,
1188                                        LPARAM param )
1189 {
1190     HWND hwnd = DIALOG_CreateIndirect( hInstance, template, TRUE, owner,
1191                                   (DLGPROC16)dlgProc, param, WIN_PROC_32W, TRUE );
1192     if (hwnd) return DIALOG_DoDialogBox( hwnd, owner );
1193     return -1;
1194 }
1195
1196 /***********************************************************************
1197  *              DialogBoxIndirectParamAorW (USER32.@)
1198  */
1199 INT WINAPI DialogBoxIndirectParamAorW(HINSTANCE hInstance, LPCVOID template,
1200                                        HWND owner, DLGPROC dlgProc,
1201                                        LPARAM param, DWORD x )
1202 {
1203     HWND hwnd;
1204     FIXME("0x%08x %p 0x%08x %p 0x%08lx 0x%08lx\n",
1205       hInstance, template, owner, dlgProc, param, x);
1206     hwnd = DIALOG_CreateIndirect( hInstance, template, TRUE, owner,
1207                                   (DLGPROC16)dlgProc, param, WIN_PROC_32W, TRUE );
1208     if (hwnd) return DIALOG_DoDialogBox( hwnd, owner );
1209     return -1;
1210 }
1211
1212 /***********************************************************************
1213  *              EndDialog (USER.88)
1214  */
1215 BOOL16 WINAPI EndDialog16( HWND16 hwnd, INT16 retval )
1216 {
1217     return EndDialog( hwnd, retval );
1218 }
1219
1220
1221 /***********************************************************************
1222  *              EndDialog (USER32.@)
1223  */
1224 BOOL WINAPI EndDialog( HWND hwnd, INT retval )
1225 {
1226     WND * wndPtr = WIN_FindWndPtr( hwnd );
1227     BOOL wasEnabled = TRUE;
1228     DIALOGINFO * dlgInfo;
1229
1230     TRACE("%04x %d\n", hwnd, retval );
1231
1232     if (!wndPtr)
1233     {
1234         ERR("got invalid window handle (%04x); buggy app !?\n", hwnd);
1235         return FALSE;
1236     }
1237
1238     if ((dlgInfo = (DIALOGINFO *)wndPtr->wExtra))
1239     {
1240         dlgInfo->idResult = retval;
1241         dlgInfo->flags |= DF_END;
1242         wasEnabled = (dlgInfo->flags & DF_OWNERENABLED);
1243     }
1244
1245     if(wndPtr->owner)
1246        DIALOG_EnableOwner( wndPtr->owner->hwndSelf, wasEnabled );
1247
1248     /* Windows sets the focus to the dialog itself in EndDialog */
1249
1250     if (IsChild(hwnd, GetFocus()))
1251        SetFocus(wndPtr->hwndSelf);
1252
1253     /* Don't have to send a ShowWindow(SW_HIDE), just do
1254        SetWindowPos with SWP_HIDEWINDOW as done in Windows */
1255
1256     SetWindowPos(hwnd, (HWND)0, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE
1257                  | SWP_NOZORDER | SWP_NOACTIVATE | SWP_HIDEWINDOW);
1258
1259     WIN_ReleaseWndPtr(wndPtr);
1260     /* unblock dialog loop */
1261     PostMessageA(hwnd, WM_NULL, 0, 0);
1262     return TRUE;
1263 }
1264
1265
1266 /***********************************************************************
1267  *           DIALOG_IsAccelerator
1268  */
1269 static BOOL DIALOG_IsAccelerator( HWND hwnd, HWND hwndDlg, WPARAM vKey )
1270 {
1271     HWND hwndControl = hwnd;
1272     HWND hwndNext;
1273     WND *wndPtr;
1274     BOOL RetVal = FALSE;
1275     INT dlgCode;
1276
1277         do
1278         {
1279             wndPtr = WIN_FindWndPtr( hwndControl );
1280             if ( (wndPtr != NULL) &&
1281                  ((wndPtr->dwStyle & (WS_VISIBLE | WS_DISABLED)) == WS_VISIBLE) )
1282             {
1283                 dlgCode = SendMessageA( hwndControl, WM_GETDLGCODE, 0, 0 );
1284                 if ( (dlgCode & (DLGC_BUTTON | DLGC_STATIC)) &&
1285                      (wndPtr->text!=NULL))
1286                 {
1287                     /* find the accelerator key */
1288                     LPWSTR p = wndPtr->text - 2;
1289                     char a_char = vKey;
1290                     WCHAR w_char = 0;
1291
1292                     do
1293                     {
1294                         p = strchrW( p + 2, '&' );
1295                     }
1296                     while (p != NULL && p[1] == '&');
1297
1298                     /* and check if it's the one we're looking for */
1299                     MultiByteToWideChar(CP_ACP, 0, &a_char, 1, &w_char, 1);
1300                     if (p != NULL && toupperW( p[1] ) == toupperW( w_char ) )
1301                     {
1302                         if ((dlgCode & DLGC_STATIC) ||
1303                             (wndPtr->dwStyle & 0x0f) == BS_GROUPBOX )
1304                         {
1305                             /* set focus to the control */
1306                             SendMessageA( hwndDlg, WM_NEXTDLGCTL,
1307                                     hwndControl, 1);
1308                             /* and bump it on to next */
1309                             SendMessageA( hwndDlg, WM_NEXTDLGCTL, 0, 0);
1310                         }
1311                         else if (dlgCode & DLGC_BUTTON)
1312                         {
1313                             /* send BM_CLICK message to the control */
1314                             SendMessageA( hwndControl, BM_CLICK, 0, 0 );
1315                         }
1316
1317                         RetVal = TRUE;
1318                         WIN_ReleaseWndPtr(wndPtr);
1319                         break;
1320                     }
1321                 }
1322                 hwndNext = GetWindow( hwndControl, GW_CHILD );
1323             }
1324             else
1325             {
1326                 hwndNext = 0;
1327             }
1328             WIN_ReleaseWndPtr(wndPtr);
1329             if (!hwndNext)
1330             {
1331                 hwndNext = GetWindow( hwndControl, GW_HWNDNEXT );
1332             }
1333             while (!hwndNext && hwndControl)
1334             {
1335                 hwndControl = GetParent( hwndControl );
1336                 if (hwndControl == hwndDlg)
1337                 {
1338                     if(hwnd==hwndDlg){  /* prevent endless loop */
1339                         hwndNext=hwnd;
1340                         break;
1341                     }
1342                     hwndNext = GetWindow( hwndDlg, GW_CHILD );
1343                 }
1344                 else
1345                 {
1346                     hwndNext = GetWindow( hwndControl, GW_HWNDNEXT );
1347                 }
1348             }
1349             hwndControl = hwndNext;
1350         }
1351         while (hwndControl && (hwndControl != hwnd));
1352
1353     return RetVal;
1354 }
1355
1356 /***********************************************************************
1357  *           DIALOG_FindMsgDestination
1358  *
1359  * The messages that IsDialogMessage sends may not go to the dialog
1360  * calling IsDialogMessage if that dialog is a child, and it has the
1361  * DS_CONTROL style set.
1362  * We propagate up until we hit one that does not have DS_CONTROL, or
1363  * whose parent is not a dialog.
1364  *
1365  * This is undocumented behaviour.
1366  */
1367 static HWND DIALOG_FindMsgDestination( HWND hwndDlg )
1368 {
1369     while (GetWindowLongA(hwndDlg, GWL_STYLE) & DS_CONTROL)
1370     {
1371         WND *pParent;
1372         HWND hParent = GetParent(hwndDlg);
1373         if (!hParent) break;
1374
1375         pParent = WIN_FindWndPtr(hParent);
1376         if (!pParent) break;
1377
1378         if (!(pParent->flags & WIN_ISDIALOG))
1379         {
1380             WIN_ReleaseWndPtr(pParent);
1381             break;
1382         }
1383         WIN_ReleaseWndPtr(pParent);
1384
1385         hwndDlg = hParent;
1386     }
1387
1388     return hwndDlg;
1389 }
1390
1391 /***********************************************************************
1392  *           DIALOG_IsDialogMessage
1393  */
1394 static BOOL DIALOG_IsDialogMessage( HWND hwnd, HWND hwndDlg,
1395                                       UINT message, WPARAM wParam,
1396                                       LPARAM lParam, BOOL *translate,
1397                                       BOOL *dispatch, INT dlgCode )
1398 {
1399     *translate = *dispatch = FALSE;
1400
1401     if (message == WM_PAINT)
1402     {
1403         /* Apparently, we have to handle this one as well */
1404         *dispatch = TRUE;
1405         return TRUE;
1406     }
1407
1408       /* Only the key messages get special processing */
1409     if ((message != WM_KEYDOWN) &&
1410         (message != WM_SYSKEYDOWN) &&
1411         (message != WM_SYSCHAR) &&
1412         (message != WM_CHAR))
1413         return FALSE;
1414
1415     if (dlgCode & DLGC_WANTMESSAGE)
1416     {
1417         *translate = *dispatch = TRUE;
1418         return TRUE;
1419     }
1420
1421     hwndDlg = DIALOG_FindMsgDestination(hwndDlg);
1422
1423     switch(message)
1424     {
1425     case WM_KEYDOWN:
1426         switch(wParam)
1427         {
1428         case VK_TAB:
1429             if (!(dlgCode & DLGC_WANTTAB))
1430             {
1431                 SendMessageA( hwndDlg, WM_NEXTDLGCTL,
1432                                 (GetKeyState(VK_SHIFT) & 0x8000), 0 );
1433                 return TRUE;
1434             }
1435             break;
1436
1437         case VK_RIGHT:
1438         case VK_DOWN:
1439         case VK_LEFT:
1440         case VK_UP:
1441             if (!(dlgCode & DLGC_WANTARROWS))
1442             {
1443                 BOOL fPrevious = (wParam == VK_LEFT || wParam == VK_UP);
1444                 HWND hwndNext =
1445                     GetNextDlgGroupItem (hwndDlg, GetFocus(), fPrevious );
1446                 SendMessageA( hwndDlg, WM_NEXTDLGCTL, hwndNext, 1 );
1447                 return TRUE;
1448             }
1449             break;
1450
1451         case VK_ESCAPE:
1452             SendMessageA( hwndDlg, WM_COMMAND, IDCANCEL,
1453                             (LPARAM)GetDlgItem( hwndDlg, IDCANCEL ) );
1454             return TRUE;
1455
1456         case VK_RETURN:
1457             {
1458                 DWORD dw = SendMessage16( hwndDlg, DM_GETDEFID, 0, 0 );
1459                 if (HIWORD(dw) == DC_HASDEFID)
1460                 {
1461                     SendMessageA( hwndDlg, WM_COMMAND,
1462                                     MAKEWPARAM( LOWORD(dw), BN_CLICKED ),
1463                                     (LPARAM)GetDlgItem(hwndDlg, LOWORD(dw)));
1464                 }
1465                 else
1466                 {
1467                     SendMessageA( hwndDlg, WM_COMMAND, IDOK,
1468                                     (LPARAM)GetDlgItem( hwndDlg, IDOK ) );
1469
1470                 }
1471             }
1472             return TRUE;
1473         }
1474         *translate = TRUE;
1475         break; /* case WM_KEYDOWN */
1476
1477     case WM_CHAR:
1478         if (dlgCode & DLGC_WANTCHARS) break;
1479         /* drop through */
1480
1481     case WM_SYSCHAR:
1482         if (DIALOG_IsAccelerator( hwnd, hwndDlg, wParam ))
1483         {
1484             /* don't translate or dispatch */
1485             return TRUE;
1486         }
1487         break;
1488
1489     case WM_SYSKEYDOWN:
1490         *translate = TRUE;
1491         break;
1492     }
1493
1494     /* If we get here, the message has not been treated specially */
1495     /* and can be sent to its destination window. */
1496     *dispatch = TRUE;
1497     return TRUE;
1498 }
1499
1500
1501 /***********************************************************************
1502  *              IsDialogMessage (USER.90)
1503  */
1504 BOOL16 WINAPI IsDialogMessage16( HWND16 hwndDlg, SEGPTR msg16 )
1505 {
1506     LPMSG16 msg = MapSL(msg16);
1507     BOOL ret, translate, dispatch;
1508     INT dlgCode = 0;
1509
1510     if ((hwndDlg != msg->hwnd) && !IsChild16( hwndDlg, msg->hwnd ))
1511         return FALSE;
1512
1513     if ((msg->message == WM_KEYDOWN) ||
1514         (msg->message == WM_CHAR))
1515     {
1516        dlgCode = SendMessage16( msg->hwnd, WM_GETDLGCODE, 0, (LPARAM)msg16);
1517     }
1518     ret = DIALOG_IsDialogMessage( msg->hwnd, hwndDlg, msg->message,
1519                                   msg->wParam, msg->lParam,
1520                                   &translate, &dispatch, dlgCode );
1521     if (translate) TranslateMessage16( msg );
1522     if (dispatch) DispatchMessage16( msg );
1523     return ret;
1524 }
1525
1526
1527 /***********************************************************************
1528  *              IsDialogMessageA (USER32.@)
1529  */
1530 BOOL WINAPI IsDialogMessageA( HWND hwndDlg, LPMSG msg )
1531 {
1532     BOOL ret, translate, dispatch;
1533     INT dlgCode = 0;
1534
1535     if ((hwndDlg != msg->hwnd) && !IsChild( hwndDlg, msg->hwnd ))
1536         return FALSE;
1537
1538     if ((msg->message == WM_KEYDOWN) ||
1539         (msg->message == WM_CHAR))
1540     {
1541         dlgCode = SendMessageA( msg->hwnd, WM_GETDLGCODE, 0, (LPARAM)msg);
1542     }
1543     ret = DIALOG_IsDialogMessage( msg->hwnd, hwndDlg, msg->message,
1544                                   msg->wParam, msg->lParam,
1545                                   &translate, &dispatch, dlgCode );
1546     if (translate) TranslateMessage( msg );
1547     if (dispatch) DispatchMessageA( msg );
1548     return ret;
1549 }
1550
1551
1552 /***********************************************************************
1553  *              IsDialogMessageW (USER32.@)
1554  */
1555 BOOL WINAPI IsDialogMessageW( HWND hwndDlg, LPMSG msg )
1556 {
1557     BOOL ret, translate, dispatch;
1558     INT dlgCode = 0;
1559
1560     if ((hwndDlg != msg->hwnd) && !IsChild( hwndDlg, msg->hwnd ))
1561         return FALSE;
1562
1563     if ((msg->message == WM_KEYDOWN) ||
1564         (msg->message == WM_CHAR))
1565     {
1566         dlgCode = SendMessageW( msg->hwnd, WM_GETDLGCODE, 0, (LPARAM)msg);
1567     }
1568     ret = DIALOG_IsDialogMessage( msg->hwnd, hwndDlg, msg->message,
1569                                   msg->wParam, msg->lParam,
1570                                   &translate, &dispatch, dlgCode );
1571     if (translate) TranslateMessage( msg );
1572     if (dispatch) DispatchMessageW( msg );
1573     return ret;
1574 }
1575
1576
1577 /***********************************************************************
1578  *              GetDlgCtrlID (USER.277)
1579  */
1580 INT16 WINAPI GetDlgCtrlID16( HWND16 hwnd )
1581 {
1582     WND *wndPtr = WIN_FindWndPtr(hwnd);
1583     INT16 retvalue;
1584
1585     if (!wndPtr) return 0;
1586
1587     retvalue = wndPtr->wIDmenu;
1588     WIN_ReleaseWndPtr(wndPtr);
1589     return retvalue;
1590 }
1591
1592
1593 /***********************************************************************
1594  *              GetDlgCtrlID (USER32.@)
1595  */
1596 INT WINAPI GetDlgCtrlID( HWND hwnd )
1597 {
1598     INT retvalue;
1599     WND *wndPtr = WIN_FindWndPtr(hwnd);
1600     if (!wndPtr) return 0;
1601     retvalue = wndPtr->wIDmenu;
1602     WIN_ReleaseWndPtr(wndPtr);
1603     return retvalue;
1604 }
1605
1606
1607 /***********************************************************************
1608  *              GetDlgItem (USER.91)
1609  */
1610 HWND16 WINAPI GetDlgItem16( HWND16 hwndDlg, INT16 id )
1611 {
1612     WND *pWnd;
1613
1614     if (!(pWnd = WIN_FindWndPtr( hwndDlg ))) return 0;
1615     for (WIN_UpdateWndPtr(&pWnd,pWnd->child); pWnd; WIN_UpdateWndPtr(&pWnd,pWnd->next))
1616         if (pWnd->wIDmenu == (UINT16)id)
1617         {
1618             HWND16 retvalue = pWnd->hwndSelf;
1619             WIN_ReleaseWndPtr(pWnd);
1620             return retvalue;
1621         }
1622     return 0;
1623 }
1624
1625
1626 /***********************************************************************
1627  *              GetDlgItem (USER32.@)
1628  */
1629 HWND WINAPI GetDlgItem( HWND hwndDlg, INT id )
1630 {
1631     WND *pWnd;
1632
1633     if (!(pWnd = WIN_FindWndPtr( hwndDlg ))) return 0;
1634     for (WIN_UpdateWndPtr(&pWnd,pWnd->child); pWnd;WIN_UpdateWndPtr(&pWnd,pWnd->next))
1635         if (pWnd->wIDmenu == (UINT16)id)
1636         {
1637             HWND retvalue = pWnd->hwndSelf;
1638             WIN_ReleaseWndPtr(pWnd);
1639             return retvalue;
1640         }
1641     return 0;
1642 }
1643
1644
1645 /*******************************************************************
1646  *              SendDlgItemMessage (USER.101)
1647  */
1648 LRESULT WINAPI SendDlgItemMessage16( HWND16 hwnd, INT16 id, UINT16 msg,
1649                                      WPARAM16 wParam, LPARAM lParam )
1650 {
1651     HWND16 hwndCtrl = GetDlgItem16( hwnd, id );
1652     if (hwndCtrl) return SendMessage16( hwndCtrl, msg, wParam, lParam );
1653     else return 0;
1654 }
1655
1656
1657 /*******************************************************************
1658  *              SendDlgItemMessageA (USER32.@)
1659  */
1660 LRESULT WINAPI SendDlgItemMessageA( HWND hwnd, INT id, UINT msg,
1661                                       WPARAM wParam, LPARAM lParam )
1662 {
1663     HWND hwndCtrl = GetDlgItem( hwnd, id );
1664     if (hwndCtrl) return SendMessageA( hwndCtrl, msg, wParam, lParam );
1665     else return 0;
1666 }
1667
1668
1669 /*******************************************************************
1670  *              SendDlgItemMessageW (USER32.@)
1671  */
1672 LRESULT WINAPI SendDlgItemMessageW( HWND hwnd, INT id, UINT msg,
1673                                       WPARAM wParam, LPARAM lParam )
1674 {
1675     HWND hwndCtrl = GetDlgItem( hwnd, id );
1676     if (hwndCtrl) return SendMessageW( hwndCtrl, msg, wParam, lParam );
1677     else return 0;
1678 }
1679
1680
1681 /*******************************************************************
1682  *              SetDlgItemText (USER.92)
1683  */
1684 void WINAPI SetDlgItemText16( HWND16 hwnd, INT16 id, SEGPTR lpString )
1685 {
1686     SendDlgItemMessage16( hwnd, id, WM_SETTEXT, 0, (LPARAM)lpString );
1687 }
1688
1689
1690 /*******************************************************************
1691  *              SetDlgItemTextA (USER32.@)
1692  */
1693 BOOL WINAPI SetDlgItemTextA( HWND hwnd, INT id, LPCSTR lpString )
1694 {
1695     return SendDlgItemMessageA( hwnd, id, WM_SETTEXT, 0, (LPARAM)lpString );
1696 }
1697
1698
1699 /*******************************************************************
1700  *              SetDlgItemTextW (USER32.@)
1701  */
1702 BOOL WINAPI SetDlgItemTextW( HWND hwnd, INT id, LPCWSTR lpString )
1703 {
1704     return SendDlgItemMessageW( hwnd, id, WM_SETTEXT, 0, (LPARAM)lpString );
1705 }
1706
1707
1708 /***********************************************************************
1709  *              GetDlgItemText (USER.93)
1710  */
1711 INT16 WINAPI GetDlgItemText16( HWND16 hwnd, INT16 id, SEGPTR str, UINT16 len )
1712 {
1713     return (INT16)SendDlgItemMessage16( hwnd, id, WM_GETTEXT,
1714                                         len, (LPARAM)str );
1715 }
1716
1717
1718 /***********************************************************************
1719  *              GetDlgItemTextA (USER32.@)
1720  */
1721 INT WINAPI GetDlgItemTextA( HWND hwnd, INT id, LPSTR str, UINT len )
1722 {
1723     return (INT)SendDlgItemMessageA( hwnd, id, WM_GETTEXT,
1724                                          len, (LPARAM)str );
1725 }
1726
1727
1728 /***********************************************************************
1729  *              GetDlgItemTextW (USER32.@)
1730  */
1731 INT WINAPI GetDlgItemTextW( HWND hwnd, INT id, LPWSTR str, UINT len )
1732 {
1733     return (INT)SendDlgItemMessageW( hwnd, id, WM_GETTEXT,
1734                                          len, (LPARAM)str );
1735 }
1736
1737
1738 /*******************************************************************
1739  *              SetDlgItemInt (USER.94)
1740  */
1741 void WINAPI SetDlgItemInt16( HWND16 hwnd, INT16 id, UINT16 value, BOOL16 fSigned )
1742 {
1743     SetDlgItemInt( hwnd, (UINT)(UINT16)id, value, fSigned );
1744 }
1745
1746
1747 /*******************************************************************
1748  *              SetDlgItemInt (USER32.@)
1749  */
1750 BOOL WINAPI SetDlgItemInt( HWND hwnd, INT id, UINT value,
1751                              BOOL fSigned )
1752 {
1753     char str[20];
1754
1755     if (fSigned) sprintf( str, "%d", (INT)value );
1756     else sprintf( str, "%u", value );
1757     SendDlgItemMessageA( hwnd, id, WM_SETTEXT, 0, (LPARAM)str );
1758     return TRUE;
1759 }
1760
1761
1762 /***********************************************************************
1763  *              GetDlgItemInt (USER.95)
1764  */
1765 UINT16 WINAPI GetDlgItemInt16( HWND16 hwnd, INT16 id, BOOL16 *translated,
1766                                BOOL16 fSigned )
1767 {
1768     UINT result;
1769     BOOL ok;
1770
1771     if (translated) *translated = FALSE;
1772     result = GetDlgItemInt( hwnd, (UINT)(UINT16)id, &ok, fSigned );
1773     if (!ok) return 0;
1774     if (fSigned)
1775     {
1776         if (((INT)result < -32767) || ((INT)result > 32767)) return 0;
1777     }
1778     else
1779     {
1780         if (result > 65535) return 0;
1781     }
1782     if (translated) *translated = TRUE;
1783     return (UINT16)result;
1784 }
1785
1786
1787 /***********************************************************************
1788  *              GetDlgItemInt (USER32.@)
1789  */
1790 UINT WINAPI GetDlgItemInt( HWND hwnd, INT id, BOOL *translated,
1791                                BOOL fSigned )
1792 {
1793     char str[30];
1794     char * endptr;
1795     long result = 0;
1796
1797     if (translated) *translated = FALSE;
1798     if (!SendDlgItemMessageA(hwnd, id, WM_GETTEXT, sizeof(str), (LPARAM)str))
1799         return 0;
1800     if (fSigned)
1801     {
1802         result = strtol( str, &endptr, 10 );
1803         if (!endptr || (endptr == str))  /* Conversion was unsuccessful */
1804             return 0;
1805         if (((result == LONG_MIN) || (result == LONG_MAX)) && (errno==ERANGE))
1806             return 0;
1807     }
1808     else
1809     {
1810         result = strtoul( str, &endptr, 10 );
1811         if (!endptr || (endptr == str))  /* Conversion was unsuccessful */
1812             return 0;
1813         if ((result == ULONG_MAX) && (errno == ERANGE)) return 0;
1814     }
1815     if (translated) *translated = TRUE;
1816     return (UINT)result;
1817 }
1818
1819
1820 /***********************************************************************
1821  *              CheckDlgButton (USER.97)
1822  */
1823 BOOL16 WINAPI CheckDlgButton16( HWND16 hwnd, INT16 id, UINT16 check )
1824 {
1825     SendDlgItemMessageA( hwnd, id, BM_SETCHECK, check, 0 );
1826     return TRUE;
1827 }
1828
1829
1830 /***********************************************************************
1831  *              CheckDlgButton (USER32.@)
1832  */
1833 BOOL WINAPI CheckDlgButton( HWND hwnd, INT id, UINT check )
1834 {
1835     SendDlgItemMessageA( hwnd, id, BM_SETCHECK, check, 0 );
1836     return TRUE;
1837 }
1838
1839
1840 /***********************************************************************
1841  *              IsDlgButtonChecked (USER.98)
1842  */
1843 UINT16 WINAPI IsDlgButtonChecked16( HWND16 hwnd, UINT16 id )
1844 {
1845     return (UINT16)SendDlgItemMessageA( hwnd, id, BM_GETCHECK, 0, 0 );
1846 }
1847
1848
1849 /***********************************************************************
1850  *              IsDlgButtonChecked (USER32.@)
1851  */
1852 UINT WINAPI IsDlgButtonChecked( HWND hwnd, UINT id )
1853 {
1854     return (UINT)SendDlgItemMessageA( hwnd, id, BM_GETCHECK, 0, 0 );
1855 }
1856
1857
1858 /***********************************************************************
1859  *              CheckRadioButton (USER.96)
1860  */
1861 BOOL16 WINAPI CheckRadioButton16( HWND16 hwndDlg, UINT16 firstID,
1862                                   UINT16 lastID, UINT16 checkID )
1863 {
1864     return CheckRadioButton( hwndDlg, firstID, lastID, checkID );
1865 }
1866
1867
1868 /***********************************************************************
1869  *           CheckRB
1870  *
1871  * Callback function used to check/uncheck radio buttons that fall
1872  * within a specific range of IDs.
1873  */
1874 static BOOL CALLBACK CheckRB(HWND hwndChild, LPARAM lParam)
1875 {
1876     LONG lChildID = GetWindowLongA(hwndChild, GWL_ID);
1877     RADIOGROUP *lpRadioGroup = (RADIOGROUP *) lParam;
1878
1879     if ((lChildID >= lpRadioGroup->firstID) &&
1880         (lChildID <= lpRadioGroup->lastID))
1881     {
1882         if (lChildID == lpRadioGroup->checkID)
1883         {
1884             SendMessageA(hwndChild, BM_SETCHECK, BST_CHECKED, 0);
1885         }
1886         else
1887         {
1888             SendMessageA(hwndChild, BM_SETCHECK, BST_UNCHECKED, 0);
1889         }
1890     }
1891
1892     return TRUE;
1893 }
1894
1895
1896 /***********************************************************************
1897  *              CheckRadioButton (USER32.@)
1898  */
1899 BOOL WINAPI CheckRadioButton( HWND hwndDlg, UINT firstID,
1900                               UINT lastID, UINT checkID )
1901 {
1902     RADIOGROUP radioGroup;
1903
1904     /* perform bounds checking for a radio button group */
1905     radioGroup.firstID = min(min(firstID, lastID), checkID);
1906     radioGroup.lastID = max(max(firstID, lastID), checkID);
1907     radioGroup.checkID = checkID;
1908
1909     return EnumChildWindows(hwndDlg, (WNDENUMPROC)CheckRB,
1910                             (LPARAM)&radioGroup);
1911 }
1912
1913
1914 /***********************************************************************
1915  *              GetDialogBaseUnits (USER.243) (USER32.@)
1916  */
1917 DWORD WINAPI GetDialogBaseUnits(void)
1918 {
1919     return MAKELONG( xBaseUnit, yBaseUnit );
1920 }
1921
1922
1923 /***********************************************************************
1924  *              MapDialogRect (USER.103)
1925  */
1926 void WINAPI MapDialogRect16( HWND16 hwnd, LPRECT16 rect )
1927 {
1928     DIALOGINFO * dlgInfo;
1929     WND * wndPtr = WIN_FindWndPtr( hwnd );
1930     if (!wndPtr) return;
1931     dlgInfo = (DIALOGINFO *)wndPtr->wExtra;
1932     rect->left   = MulDiv(rect->left, dlgInfo->xBaseUnit, 4);
1933     rect->right  = MulDiv(rect->right, dlgInfo->xBaseUnit, 4);
1934     rect->top    = MulDiv(rect->top, dlgInfo->yBaseUnit, 8);
1935     rect->bottom = MulDiv(rect->bottom, dlgInfo->yBaseUnit, 8);
1936     WIN_ReleaseWndPtr(wndPtr);
1937 }
1938
1939
1940 /***********************************************************************
1941  *              MapDialogRect (USER32.@)
1942  */
1943 BOOL WINAPI MapDialogRect( HWND hwnd, LPRECT rect )
1944 {
1945     DIALOGINFO * dlgInfo;
1946     WND * wndPtr = WIN_FindWndPtr( hwnd );
1947     if (!wndPtr) return FALSE;
1948     dlgInfo = (DIALOGINFO *)wndPtr->wExtra;
1949     rect->left   = MulDiv(rect->left, dlgInfo->xBaseUnit, 4);
1950     rect->right  = MulDiv(rect->right, dlgInfo->xBaseUnit, 4);
1951     rect->top    = MulDiv(rect->top, dlgInfo->yBaseUnit, 8);
1952     rect->bottom = MulDiv(rect->bottom, dlgInfo->yBaseUnit, 8);
1953     WIN_ReleaseWndPtr(wndPtr);
1954     return TRUE;
1955 }
1956
1957
1958 /***********************************************************************
1959  *              GetNextDlgGroupItem (USER.227)
1960  */
1961 HWND16 WINAPI GetNextDlgGroupItem16( HWND16 hwndDlg, HWND16 hwndCtrl,
1962                                      BOOL16 fPrevious )
1963 {
1964     return (HWND16)GetNextDlgGroupItem( hwndDlg, hwndCtrl, fPrevious );
1965 }
1966
1967
1968 /***********************************************************************
1969  *              GetNextDlgGroupItem (USER32.@)
1970  */
1971 HWND WINAPI GetNextDlgGroupItem( HWND hwndDlg, HWND hwndCtrl,
1972                                      BOOL fPrevious )
1973 {
1974     WND *pWnd = NULL,
1975         *pWndLast = NULL,
1976         *pWndCtrl = NULL,
1977         *pWndDlg = NULL;
1978     HWND retvalue;
1979
1980     if(hwndCtrl)
1981     {
1982         /* if the hwndCtrl is the child of the control in the hwndDlg,
1983          * then the hwndDlg has to be the parent of the hwndCtrl */
1984         if(GetParent(hwndCtrl) != hwndDlg && GetParent(GetParent(hwndCtrl)) == hwndDlg)
1985             hwndDlg = GetParent(hwndCtrl);
1986     }
1987
1988     if (!(pWndDlg = WIN_FindWndPtr( hwndDlg ))) return 0;
1989     if (hwndCtrl)
1990     {
1991         if (!(pWndCtrl = WIN_FindWndPtr( hwndCtrl )))
1992     {
1993             retvalue = 0;
1994             goto END;
1995         }
1996         /* Make sure hwndCtrl is a top-level child */
1997         while (pWndCtrl->parent && (pWndCtrl->parent != pWndDlg))
1998             WIN_UpdateWndPtr(&pWndCtrl,pWndCtrl->parent);
1999         if (pWndCtrl->parent != pWndDlg)
2000         {
2001             retvalue = 0;
2002             goto END;
2003         }
2004     }
2005     else
2006     {
2007         /* No ctrl specified -> start from the beginning */
2008         if (!(pWndCtrl = WIN_LockWndPtr(pWndDlg->child)))
2009         {
2010             retvalue = 0;
2011             goto END;
2012         }
2013         if (fPrevious)
2014             while (pWndCtrl->next) WIN_UpdateWndPtr(&pWndCtrl,pWndCtrl->next);
2015     }
2016
2017     pWndLast = WIN_LockWndPtr(pWndCtrl);
2018     pWnd = WIN_LockWndPtr(pWndCtrl->next);
2019
2020     while (1)
2021     {
2022         if (!pWnd || (pWnd->dwStyle & WS_GROUP))
2023         {
2024             /* Wrap-around to the beginning of the group */
2025             WND *pWndTemp;
2026
2027             WIN_UpdateWndPtr( &pWnd, pWndDlg->child );
2028             for ( pWndTemp = WIN_LockWndPtr( pWnd );
2029                   pWndTemp;
2030                   WIN_UpdateWndPtr( &pWndTemp, pWndTemp->next) )
2031             {
2032                 if (pWndTemp->dwStyle & WS_GROUP) WIN_UpdateWndPtr( &pWnd, pWndTemp );
2033                 if (pWndTemp == pWndCtrl) break;
2034             }
2035             WIN_ReleaseWndPtr( pWndTemp );
2036         }
2037         if (pWnd == pWndCtrl) break;
2038         if ((pWnd->dwStyle & WS_VISIBLE) && !(pWnd->dwStyle & WS_DISABLED))
2039         {
2040             WIN_UpdateWndPtr(&pWndLast,pWnd);
2041             if (!fPrevious) break;
2042         }
2043         WIN_UpdateWndPtr(&pWnd,pWnd->next);
2044     }
2045     retvalue = pWndLast->hwndSelf;
2046
2047     WIN_ReleaseWndPtr(pWndLast);
2048     WIN_ReleaseWndPtr(pWnd);
2049 END:
2050     WIN_ReleaseWndPtr(pWndCtrl);
2051     WIN_ReleaseWndPtr(pWndDlg);
2052
2053     return retvalue;
2054 }
2055
2056
2057 /***********************************************************************
2058  *              GetNextDlgTabItem (USER.228)
2059  */
2060 HWND16 WINAPI GetNextDlgTabItem16( HWND16 hwndDlg, HWND16 hwndCtrl,
2061                                    BOOL16 fPrevious )
2062 {
2063     return (HWND16)GetNextDlgTabItem( hwndDlg, hwndCtrl, fPrevious );
2064 }
2065
2066 /***********************************************************************
2067  *           DIALOG_GetNextTabItem
2068  *
2069  * Helper for GetNextDlgTabItem
2070  */
2071 static HWND DIALOG_GetNextTabItem( HWND hwndMain, HWND hwndDlg, HWND hwndCtrl, BOOL fPrevious )
2072 {
2073     LONG dsStyle;
2074     LONG exStyle;
2075     UINT wndSearch = fPrevious ? GW_HWNDPREV : GW_HWNDNEXT;
2076     HWND retWnd = 0;
2077     HWND hChildFirst = 0;
2078
2079     if(!hwndCtrl)
2080     {
2081         hChildFirst = GetWindow(hwndDlg,GW_CHILD);
2082         if(fPrevious) hChildFirst = GetWindow(hChildFirst,GW_HWNDLAST);
2083     }
2084     else
2085     {
2086         HWND hParent = GetParent(hwndCtrl);
2087         BOOL bValid = FALSE;
2088         while( hParent)
2089         {
2090             if(hParent == hwndMain)
2091             {
2092                 bValid = TRUE;
2093                 break;
2094             }
2095             hParent = GetParent(hParent);
2096         }
2097         if(bValid)
2098         {
2099             hChildFirst = GetWindow(hwndCtrl,wndSearch);
2100             if(!hChildFirst)
2101             {
2102                 if(GetParent(hwndCtrl) != hwndMain)
2103                     hChildFirst = GetWindow(GetParent(hwndCtrl),wndSearch);
2104                 else
2105                 {
2106                     if(fPrevious)
2107                         hChildFirst = GetWindow(hwndCtrl,GW_HWNDLAST);
2108                     else
2109                         hChildFirst = GetWindow(hwndCtrl,GW_HWNDFIRST);
2110                 }
2111             }
2112         }
2113     }
2114     while(hChildFirst)
2115     {
2116         BOOL bCtrl = FALSE;
2117         while(hChildFirst)
2118         {
2119             dsStyle = GetWindowLongA(hChildFirst,GWL_STYLE);
2120             exStyle = GetWindowLongA(hChildFirst,GWL_EXSTYLE);
2121             if( (dsStyle & DS_CONTROL || exStyle & WS_EX_CONTROLPARENT) && (dsStyle & WS_VISIBLE) && !(dsStyle & WS_DISABLED))
2122             {
2123                 bCtrl=TRUE;
2124                 break;
2125             }
2126             else if( (dsStyle & WS_TABSTOP) && (dsStyle & WS_VISIBLE) && !(dsStyle & WS_DISABLED))
2127                 break;
2128             hChildFirst = GetWindow(hChildFirst,wndSearch);
2129         }
2130         if(hChildFirst)
2131         {
2132             if(bCtrl)
2133                 retWnd = DIALOG_GetNextTabItem(hwndMain,hChildFirst,(HWND)NULL,fPrevious );
2134             else
2135                 retWnd = hChildFirst;
2136         }
2137         if(retWnd) break;
2138         hChildFirst = GetWindow(hChildFirst,wndSearch);
2139     }
2140     if(!retWnd && hwndCtrl)
2141     {
2142         HWND hParent = GetParent(hwndCtrl);
2143         while(hParent)
2144         {
2145             if(hParent == hwndMain) break;
2146             retWnd = DIALOG_GetNextTabItem(hwndMain,GetParent(hParent),hParent,fPrevious );
2147             if(retWnd) break;
2148             hParent = GetParent(hParent);
2149         }
2150         if(!retWnd)
2151             retWnd = DIALOG_GetNextTabItem(hwndMain,hwndMain,(HWND)NULL,fPrevious );
2152     }
2153     return retWnd;
2154 }
2155
2156 /***********************************************************************
2157  *              GetNextDlgTabItem (USER32.@)
2158  */
2159 HWND WINAPI GetNextDlgTabItem( HWND hwndDlg, HWND hwndCtrl,
2160                                    BOOL fPrevious )
2161 {
2162     return DIALOG_GetNextTabItem(hwndDlg,hwndDlg,hwndCtrl,fPrevious);
2163 }
2164
2165 /**********************************************************************
2166  *           DIALOG_DlgDirSelect
2167  *
2168  * Helper function for DlgDirSelect*
2169  */
2170 static BOOL DIALOG_DlgDirSelect( HWND hwnd, LPSTR str, INT len,
2171                                    INT id, BOOL win32, BOOL unicode,
2172                                    BOOL combo )
2173 {
2174     char *buffer, *ptr;
2175     INT item, size;
2176     BOOL ret;
2177     HWND listbox = GetDlgItem( hwnd, id );
2178
2179     TRACE("%04x '%s' %d\n", hwnd, str, id );
2180     if (!listbox) return FALSE;
2181     if (win32)
2182     {
2183         item = SendMessageA(listbox, combo ? CB_GETCURSEL
2184                                              : LB_GETCURSEL, 0, 0 );
2185         if (item == LB_ERR) return FALSE;
2186         size = SendMessageA(listbox, combo ? CB_GETLBTEXTLEN
2187                                              : LB_GETTEXTLEN, 0, 0 );
2188         if (size == LB_ERR) return FALSE;
2189     }
2190     else
2191     {
2192         item = SendMessageA(listbox, combo ? CB_GETCURSEL16
2193                                              : LB_GETCURSEL16, 0, 0 );
2194         if (item == LB_ERR) return FALSE;
2195         size = SendMessageA(listbox, combo ? CB_GETLBTEXTLEN16
2196                                              : LB_GETTEXTLEN16, 0, 0 );
2197         if (size == LB_ERR) return FALSE;
2198     }
2199
2200     if (!(buffer = SEGPTR_ALLOC( size+1 ))) return FALSE;
2201
2202     if (win32)
2203         SendMessageA( listbox, combo ? CB_GETLBTEXT : LB_GETTEXT,
2204                         item, (LPARAM)buffer );
2205     else
2206         SendMessage16( listbox, combo ? CB_GETLBTEXT16 : LB_GETTEXT16,
2207                        item, (LPARAM)SEGPTR_GET(buffer) );
2208
2209     if ((ret = (buffer[0] == '[')))  /* drive or directory */
2210     {
2211         if (buffer[1] == '-')  /* drive */
2212         {
2213             buffer[3] = ':';
2214             buffer[4] = 0;
2215             ptr = buffer + 2;
2216         }
2217         else
2218         {
2219             buffer[strlen(buffer)-1] = '\\';
2220             ptr = buffer + 1;
2221         }
2222     }
2223     else ptr = buffer;
2224
2225     if (unicode)
2226     {
2227         if (len > 0 && !MultiByteToWideChar( CP_ACP, 0, ptr, -1, (LPWSTR)str, len ))
2228             ((LPWSTR)str)[len-1] = 0;
2229     }
2230     else lstrcpynA( str, ptr, len );
2231     SEGPTR_FREE( buffer );
2232     TRACE("Returning %d '%s'\n", ret, str );
2233     return ret;
2234 }
2235
2236
2237 /**********************************************************************
2238  *          DIALOG_DlgDirList
2239  *
2240  * Helper function for DlgDirList*
2241  */
2242 static INT DIALOG_DlgDirList( HWND hDlg, LPSTR spec, INT idLBox,
2243                                 INT idStatic, UINT attrib, BOOL combo )
2244 {
2245     HWND hwnd;
2246     LPSTR orig_spec = spec;
2247
2248 #define SENDMSG(msg,wparam,lparam) \
2249     ((attrib & DDL_POSTMSGS) ? PostMessageA( hwnd, msg, wparam, lparam ) \
2250                              : SendMessageA( hwnd, msg, wparam, lparam ))
2251
2252     TRACE("%04x '%s' %d %d %04x\n",
2253                     hDlg, spec ? spec : "NULL", idLBox, idStatic, attrib );
2254
2255     /* If the path exists and is a directory, chdir to it */
2256     if (!spec || !spec[0] || SetCurrentDirectoryA( spec )) spec = "*.*";
2257     else
2258     {
2259         char *p, *p2;
2260         p = spec;
2261         if ((p2 = strrchr( p, '\\' ))) p = p2;
2262         if ((p2 = strrchr( p, '/' ))) p = p2;
2263         if (p != spec)
2264         {
2265             char sep = *p;
2266             *p = 0;
2267             if (!SetCurrentDirectoryA( spec ))
2268             {
2269                 *p = sep;  /* Restore the original spec */
2270                 return FALSE;
2271             }
2272             spec = p + 1;
2273         }
2274     }
2275
2276     TRACE( "mask=%s\n", spec );
2277
2278     if (idLBox && ((hwnd = GetDlgItem( hDlg, idLBox )) != 0))
2279     {
2280         SENDMSG( combo ? CB_RESETCONTENT : LB_RESETCONTENT, 0, 0 );
2281         if (attrib & DDL_DIRECTORY)
2282         {
2283             if (!(attrib & DDL_EXCLUSIVE))
2284             {
2285                 if (SENDMSG( combo ? CB_DIR : LB_DIR,
2286                              attrib & ~(DDL_DIRECTORY | DDL_DRIVES),
2287                              (LPARAM)spec ) == LB_ERR)
2288                     return FALSE;
2289             }
2290             if (SENDMSG( combo ? CB_DIR : LB_DIR,
2291                        (attrib & (DDL_DIRECTORY | DDL_DRIVES)) | DDL_EXCLUSIVE,
2292                          (LPARAM)"*.*" ) == LB_ERR)
2293                 return FALSE;
2294         }
2295         else
2296         {
2297             if (SENDMSG( combo ? CB_DIR : LB_DIR, attrib,
2298                          (LPARAM)spec ) == LB_ERR)
2299                 return FALSE;
2300         }
2301     }
2302
2303     if (idStatic && ((hwnd = GetDlgItem( hDlg, idStatic )) != 0))
2304     {
2305         char temp[MAX_PATH];
2306         GetCurrentDirectoryA( sizeof(temp), temp );
2307         CharLowerA( temp );
2308         /* Can't use PostMessage() here, because the string is on the stack */
2309         SetDlgItemTextA( hDlg, idStatic, temp );
2310     }
2311
2312     if (orig_spec && (spec != orig_spec))
2313     {
2314         /* Update the original file spec */
2315         char *p = spec;
2316         while ((*orig_spec++ = *p++));
2317     }
2318
2319     return TRUE;
2320 #undef SENDMSG
2321 }
2322
2323
2324 /**********************************************************************
2325  *          DIALOG_DlgDirListW
2326  *
2327  * Helper function for DlgDirList*W
2328  */
2329 static INT DIALOG_DlgDirListW( HWND hDlg, LPWSTR spec, INT idLBox,
2330                                  INT idStatic, UINT attrib, BOOL combo )
2331 {
2332     if (spec)
2333     {
2334         LPSTR specA = HEAP_strdupWtoA( GetProcessHeap(), 0, spec );
2335         INT ret = DIALOG_DlgDirList( hDlg, specA, idLBox, idStatic,
2336                                        attrib, combo );
2337         MultiByteToWideChar( CP_ACP, 0, specA, -1, spec, 0x7fffffff );
2338         HeapFree( GetProcessHeap(), 0, specA );
2339         return ret;
2340     }
2341     return DIALOG_DlgDirList( hDlg, NULL, idLBox, idStatic, attrib, combo );
2342 }
2343
2344
2345 /**********************************************************************
2346  *              DlgDirSelect (USER.99)
2347  */
2348 BOOL16 WINAPI DlgDirSelect16( HWND16 hwnd, LPSTR str, INT16 id )
2349 {
2350     return DlgDirSelectEx16( hwnd, str, 128, id );
2351 }
2352
2353
2354 /**********************************************************************
2355  *              DlgDirSelectComboBox (USER.194)
2356  */
2357 BOOL16 WINAPI DlgDirSelectComboBox16( HWND16 hwnd, LPSTR str, INT16 id )
2358 {
2359     return DlgDirSelectComboBoxEx16( hwnd, str, 128, id );
2360 }
2361
2362
2363 /**********************************************************************
2364  *              DlgDirSelectEx (USER.422)
2365  */
2366 BOOL16 WINAPI DlgDirSelectEx16( HWND16 hwnd, LPSTR str, INT16 len, INT16 id )
2367 {
2368     return DIALOG_DlgDirSelect( hwnd, str, len, id, FALSE, FALSE, FALSE );
2369 }
2370
2371
2372 /**********************************************************************
2373  *              DlgDirSelectExA (USER32.@)
2374  */
2375 BOOL WINAPI DlgDirSelectExA( HWND hwnd, LPSTR str, INT len, INT id )
2376 {
2377     return DIALOG_DlgDirSelect( hwnd, str, len, id, TRUE, FALSE, FALSE );
2378 }
2379
2380
2381 /**********************************************************************
2382  *              DlgDirSelectExW (USER32.@)
2383  */
2384 BOOL WINAPI DlgDirSelectExW( HWND hwnd, LPWSTR str, INT len, INT id )
2385 {
2386     return DIALOG_DlgDirSelect( hwnd, (LPSTR)str, len, id, TRUE, TRUE, FALSE );
2387 }
2388
2389
2390 /**********************************************************************
2391  *              DlgDirSelectComboBoxEx (USER.423)
2392  */
2393 BOOL16 WINAPI DlgDirSelectComboBoxEx16( HWND16 hwnd, LPSTR str, INT16 len,
2394                                         INT16 id )
2395 {
2396     return DIALOG_DlgDirSelect( hwnd, str, len, id, FALSE, FALSE, TRUE );
2397 }
2398
2399
2400 /**********************************************************************
2401  *              DlgDirSelectComboBoxExA (USER32.@)
2402  */
2403 BOOL WINAPI DlgDirSelectComboBoxExA( HWND hwnd, LPSTR str, INT len,
2404                                          INT id )
2405 {
2406     return DIALOG_DlgDirSelect( hwnd, str, len, id, TRUE, FALSE, TRUE );
2407 }
2408
2409
2410 /**********************************************************************
2411  *              DlgDirSelectComboBoxExW (USER32.@)
2412  */
2413 BOOL WINAPI DlgDirSelectComboBoxExW( HWND hwnd, LPWSTR str, INT len,
2414                                          INT id)
2415 {
2416     return DIALOG_DlgDirSelect( hwnd, (LPSTR)str, len, id, TRUE, TRUE, TRUE );
2417 }
2418
2419
2420 /**********************************************************************
2421  *              DlgDirList (USER.100)
2422  */
2423 INT16 WINAPI DlgDirList16( HWND16 hDlg, LPSTR spec, INT16 idLBox,
2424                            INT16 idStatic, UINT16 attrib )
2425 {
2426     /* according to Win16 docs, DDL_DRIVES should make DDL_EXCLUSIVE
2427      * be set automatically (this is different in Win32, and
2428      * DIALOG_DlgDirList sends Win32 messages to the control,
2429      * so do it here) */
2430     if (attrib & DDL_DRIVES) attrib |= DDL_EXCLUSIVE;
2431     return DIALOG_DlgDirList( hDlg, spec, idLBox, idStatic, attrib, FALSE );
2432 }
2433
2434
2435 /**********************************************************************
2436  *              DlgDirListA (USER32.@)
2437  */
2438 INT WINAPI DlgDirListA( HWND hDlg, LPSTR spec, INT idLBox,
2439                             INT idStatic, UINT attrib )
2440 {
2441     return DIALOG_DlgDirList( hDlg, spec, idLBox, idStatic, attrib, FALSE );
2442 }
2443
2444
2445 /**********************************************************************
2446  *              DlgDirListW (USER32.@)
2447  */
2448 INT WINAPI DlgDirListW( HWND hDlg, LPWSTR spec, INT idLBox,
2449                             INT idStatic, UINT attrib )
2450 {
2451     return DIALOG_DlgDirListW( hDlg, spec, idLBox, idStatic, attrib, FALSE );
2452 }
2453
2454
2455 /**********************************************************************
2456  *              DlgDirListComboBox (USER.195)
2457  */
2458 INT16 WINAPI DlgDirListComboBox16( HWND16 hDlg, LPSTR spec, INT16 idCBox,
2459                                    INT16 idStatic, UINT16 attrib )
2460 {
2461     return DIALOG_DlgDirList( hDlg, spec, idCBox, idStatic, attrib, TRUE );
2462 }
2463
2464
2465 /**********************************************************************
2466  *              DlgDirListComboBoxA (USER32.@)
2467  */
2468 INT WINAPI DlgDirListComboBoxA( HWND hDlg, LPSTR spec, INT idCBox,
2469                                     INT idStatic, UINT attrib )
2470 {
2471     return DIALOG_DlgDirList( hDlg, spec, idCBox, idStatic, attrib, TRUE );
2472 }
2473
2474
2475 /**********************************************************************
2476  *              DlgDirListComboBoxW (USER32.@)
2477  */
2478 INT WINAPI DlgDirListComboBoxW( HWND hDlg, LPWSTR spec, INT idCBox,
2479                                     INT idStatic, UINT attrib )
2480 {
2481     return DIALOG_DlgDirListW( hDlg, spec, idCBox, idStatic, attrib, TRUE );
2482 }