git.oblomov.eu Git - wine/blob - windows/dialog.c

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