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