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