git.oblomov.eu Git - wine/blob - dlls/commdlg/filedlg.c

   1 /*
   2  * COMMDLG - File Dialogs
   3  *
   4  * Copyright 1994 Martin Ayotte
   5  * Copyright 1996 Albrecht Kleine
   6  */
   7 #include <ctype.h>
   8 #include <stdlib.h>
   9 #include <string.h>
  10 #include "winbase.h"
  11 #include "wine/winbase16.h"
  12 #include "wine/winuser16.h"
  13 #include "ldt.h"
  14 #include "heap.h"
  15 #include "commdlg.h"
  16 #include "resource.h"
  17 #include "dialog.h"
  18 #include "dlgs.h"
  19 #include "module.h"
  20 #include "drive.h"
  21 #include "debugtools.h"
  22 #include "winproc.h"
  23 #include "cderr.h"
  24 #include "tweak.h"
  25
  26 DEFAULT_DEBUG_CHANNEL(commdlg)
  27
  28 #include "cdlg.h"
  29
  30 static HICON16 hFolder = 0;
  31 static HICON16 hFolder2 = 0;
  32 static HICON16 hFloppy = 0;
  33 static HICON16 hHDisk = 0;
  34 static HICON16 hCDRom = 0;
  35 static HICON16 hNet = 0;
  36 static int fldrHeight = 0;
  37 static int fldrWidth = 0;
  38
  39 static const char defaultfilter[]=" \0\0";
  40 #define OFN_PROP "FILEDLG_OFN_LPARAM"
  41
  42 /***********************************************************************
  43  *
  44  * Windows 3.1 OpenFileName/SaveFileName dialog
  45  *
  46  */
  47 /***********************************************************************
  48  *                              FileDlg_Init                    [internal]
  49  */
  50 static BOOL FileDlg_Init(void)
  51 {
  52     static BOOL initialized = 0;
  53     CURSORICONINFO *fldrInfo;
  54
  55     if (!initialized) {
  56         if (!hFolder) hFolder = LoadIcon16(0, MAKEINTRESOURCE16(OIC_FOLDER));
  57         if (!hFolder2) hFolder2 = LoadIcon16(0, MAKEINTRESOURCE16(OIC_FOLDER2));
  58         if (!hFloppy) hFloppy = LoadIcon16(0, MAKEINTRESOURCE16(OIC_FLOPPY));
  59         if (!hHDisk) hHDisk = LoadIcon16(0, MAKEINTRESOURCE16(OIC_HDISK));
  60         if (!hCDRom) hCDRom = LoadIcon16(0, MAKEINTRESOURCE16(OIC_CDROM));
  61         if (!hNet) hNet = LoadIcon16(0, MAKEINTRESOURCE16(OIC_NETWORK));
  62         if (hFolder == 0 || hFolder2 == 0 || hFloppy == 0 ||
  63             hHDisk == 0 || hCDRom == 0 || hNet == 0)
  64         {
  65             ERR("Error loading icons !\n");
  66             return FALSE;
  67         }
  68         fldrInfo = (CURSORICONINFO *) GlobalLock16( hFolder2 );
  69         if (!fldrInfo)
  70         {
  71             ERR("Error measuring icons !\n");
  72             return FALSE;
  73         }
  74         fldrHeight = fldrInfo -> nHeight;
  75         fldrWidth = fldrInfo -> nWidth;
  76         GlobalUnlock16( hFolder2 );
  77         initialized = TRUE;
  78     }
  79     return TRUE;
  80 }
  81
  82 /***********************************************************************
  83  *           FileOpenDlgProc [internal]
  84  *
  85  * FIXME: Convert to real 32-bit message processing
  86  */
  87 static LRESULT WINAPI FileOpenDlgProc(HWND hDlg, UINT msg,
  88                                       WPARAM wParam, LPARAM lParam)
  89 {
  90     UINT16 msg16;
  91     MSGPARAM16 mp16;
  92
  93     mp16.lParam = lParam;
  94     if (WINPROC_MapMsg32ATo16( hDlg, msg, wParam,
  95                                &msg16, &mp16.wParam, &mp16.lParam ) == -1)
  96         return 0;
  97     mp16.lResult = FileOpenDlgProc16( (HWND16)hDlg, msg16,
  98                                       mp16.wParam, mp16.lParam );
  99
 100     WINPROC_UnmapMsg32ATo16( hDlg, msg, wParam, lParam, &mp16 );
 101     return mp16.lResult;
 102 }
 103
 104 /***********************************************************************
 105  *           FileSaveDlgProc [internal]
 106  *
 107  * FIXME: Convert to real 32-bit message processing
 108  */
 109 static LRESULT WINAPI FileSaveDlgProc(HWND hDlg, UINT msg,
 110                                       WPARAM wParam, LPARAM lParam)
 111 {
 112     UINT16 msg16;
 113     MSGPARAM16 mp16;
 114
 115     mp16.lParam = lParam;
 116     if (WINPROC_MapMsg32ATo16( hDlg, msg, wParam,
 117                                &msg16, &mp16.wParam, &mp16.lParam ) == -1)
 118         return 0;
 119     mp16.lResult = FileSaveDlgProc16( (HWND16)hDlg, msg16,
 120                                       mp16.wParam, mp16.lParam );
 121
 122     WINPROC_UnmapMsg32ATo16( hDlg, msg, wParam, lParam, &mp16 );
 123     return mp16.lResult;
 124 }
 125
 126 /***********************************************************************
 127  *           GetOpenFileName16   (COMMDLG.1)
 128  *
 129  * Creates a dialog box for the user to select a file to open.
 130  *
 131  * RETURNS
 132  *    TRUE on success: user selected a valid file
 133  *    FALSE on cancel, error, close or filename-does-not-fit-in-buffer.
 134  *
 135  * BUGS
 136  *    unknown, there are some FIXME's left.
 137  */
 138 BOOL16 WINAPI GetOpenFileName16(
 139                                 SEGPTR ofn /* addess of structure with data*/
 140                                 )
 141 {
 142     HINSTANCE hInst;
 143     HANDLE hDlgTmpl = 0, hResInfo;
 144     BOOL bRet = FALSE, win32Format = FALSE;
 145     HWND hwndDialog;
 146     LPOPENFILENAME16 lpofn = (LPOPENFILENAME16)PTR_SEG_TO_LIN(ofn);
 147     LPCVOID template;
 148     char defaultopen[]="Open File";
 149     char *str=0,*str1=0;
 150
 151     if (!lpofn || !FileDlg_Init()) return FALSE;
 152
 153     if (lpofn->Flags & OFN_WINE) {
 154             if (lpofn->Flags & OFN_ENABLETEMPLATEHANDLE)
 155             {
 156                 if (!(template = LockResource( MapHModuleSL(lpofn->hInstance ))))
 157                 {
 158                     COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
 159                     return FALSE;
 160                 }
 161             }
 162             else if (lpofn->Flags & OFN_ENABLETEMPLATE)
 163             {
 164                 if (!(hResInfo = FindResourceA(MapHModuleSL(lpofn->hInstance),
 165                                                 PTR_SEG_TO_LIN(lpofn->lpTemplateName), RT_DIALOGA)))
 166                 {
 167                     COMDLG32_SetCommDlgExtendedError(CDERR_FINDRESFAILURE);
 168                     return FALSE;
 169                 }
 170                 if (!(hDlgTmpl = LoadResource( MapHModuleSL(lpofn->hInstance),
 171                                                  hResInfo )) ||
 172                     !(template = LockResource( hDlgTmpl )))
 173                 {
 174                     COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
 175                     return FALSE;
 176                 }
 177             } else {
 178                 if (!(hResInfo = FindResourceA(COMMDLG_hInstance32, "OPEN_FILE", RT_DIALOGA)))
 179                 {
 180                     COMDLG32_SetCommDlgExtendedError(CDERR_FINDRESFAILURE);
 181                     return FALSE;
 182                 }
 183                 if (!(hDlgTmpl = LoadResource(COMMDLG_hInstance32, hResInfo )) ||
 184                     !(template = LockResource( hDlgTmpl )))
 185                 {
 186                     COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
 187                     return FALSE;
 188                 }
 189             }
 190             win32Format = TRUE;
 191     } else {
 192             if (lpofn->Flags & OFN_ENABLETEMPLATEHANDLE)
 193             {
 194                 if (!(template = LockResource16( lpofn->hInstance )))
 195                 {
 196                     COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
 197                     return FALSE;
 198                 }
 199             }
 200             else if (lpofn->Flags & OFN_ENABLETEMPLATE)
 201             {
 202                 if (!(hResInfo = FindResource16(lpofn->hInstance,
 203                                                 lpofn->lpTemplateName,
 204                                                 RT_DIALOG16)))
 205                 {
 206                     COMDLG32_SetCommDlgExtendedError(CDERR_FINDRESFAILURE);
 207                     return FALSE;
 208                 }
 209                 if (!(hDlgTmpl = LoadResource16( lpofn->hInstance, hResInfo )) ||
 210                     !(template = LockResource16( hDlgTmpl )))
 211                 {
 212                     COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
 213                     return FALSE;
 214                 }
 215             } else {
 216                 if (!(hResInfo = FindResourceA(COMMDLG_hInstance32, "OPEN_FILE", RT_DIALOGA)))
 217                 {
 218                     COMDLG32_SetCommDlgExtendedError(CDERR_FINDRESFAILURE);
 219                     return FALSE;
 220                 }
 221                 if (!(hDlgTmpl = LoadResource(COMMDLG_hInstance32, hResInfo )) ||
 222                     !(template = LockResource( hDlgTmpl )))
 223                 {
 224                     COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
 225                     return FALSE;
 226                 }
 227                 win32Format = TRUE;
 228             }
 229     }
 230
 231     hInst = GetWindowLongA( lpofn->hwndOwner, GWL_HINSTANCE );
 232
 233     if (!(lpofn->lpstrFilter))
 234       {
 235        str = SEGPTR_ALLOC(sizeof(defaultfilter));
 236        TRACE("Alloc %p default for Filetype in GetOpenFileName\n",str);
 237        memcpy(str,defaultfilter,sizeof(defaultfilter));
 238        lpofn->lpstrFilter=SEGPTR_GET(str);
 239       }
 240
 241     if (!(lpofn->lpstrTitle))
 242       {
 243        str1 = SEGPTR_ALLOC(strlen(defaultopen)+1);
 244        TRACE("Alloc %p default for Title in GetOpenFileName\n",str1);
 245        strcpy(str1,defaultopen);
 246        lpofn->lpstrTitle=SEGPTR_GET(str1);
 247       }
 248
 249     /* FIXME: doesn't handle win32 format correctly yet */
 250     hwndDialog = DIALOG_CreateIndirect( hInst, template, win32Format,
 251                                         lpofn->hwndOwner,
 252                                         (DLGPROC16)FileOpenDlgProc,
 253                                         ofn, WIN_PROC_32A );
 254     if (hwndDialog) bRet = DIALOG_DoDialogBox( hwndDialog, lpofn->hwndOwner );
 255
 256     if (str1)
 257       {
 258        TRACE("Freeing %p default for Title in GetOpenFileName\n",str1);
 259         SEGPTR_FREE(str1);
 260        lpofn->lpstrTitle=0;
 261       }
 262
 263     if (str)
 264       {
 265        TRACE("Freeing %p default for Filetype in GetOpenFileName\n",str);
 266         SEGPTR_FREE(str);
 267        lpofn->lpstrFilter=0;
 268       }
 269
 270     if (hDlgTmpl) {
 271             if (lpofn->Flags & OFN_WINE)
 272                     FreeResource( hDlgTmpl );
 273             else
 274                     FreeResource16( hDlgTmpl );
 275     }
 276
 277     TRACE("return lpstrFile='%s' !\n",
 278            (LPSTR)PTR_SEG_TO_LIN(lpofn->lpstrFile));
 279     return bRet;
 280 }
 281
 282
 283 /***********************************************************************
 284  *           GetSaveFileName   (COMMDLG.2)
 285  *
 286  * Creates a dialog box for the user to select a file to save.
 287  *
 288  * RETURNS
 289  *    TRUE on succes: user enters a valid file
 290  *    FALSE on cancel, error, close or filename-does-not-fit-in-buffer.
 291  *
 292  * BUGS
 293  *    unknown. There are some FIXME's left.
 294  */
 295 BOOL16 WINAPI GetSaveFileName16(
 296                                 SEGPTR ofn /* addess of structure with data*/
 297                                 )
 298 {
 299     HINSTANCE hInst;
 300     HANDLE hDlgTmpl = 0;
 301     BOOL bRet = FALSE, win32Format = FALSE;
 302     LPOPENFILENAME16 lpofn = (LPOPENFILENAME16)PTR_SEG_TO_LIN(ofn);
 303     LPCVOID template;
 304     HWND hwndDialog;
 305     char defaultsave[]="Save as";
 306     char *str =0,*str1=0;
 307
 308     if (!lpofn || !FileDlg_Init()) return FALSE;
 309
 310     if (lpofn->Flags & OFN_WINE) {
 311             if (lpofn->Flags & OFN_ENABLETEMPLATEHANDLE)
 312             {
 313                 if (!(template = LockResource( MapHModuleSL(lpofn->hInstance ))))
 314                 {
 315                     COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
 316                     return FALSE;
 317                 }
 318             }
 319             else if (lpofn->Flags & OFN_ENABLETEMPLATE)
 320             {
 321                 HANDLE hResInfo;
 322                 if (!(hResInfo = FindResourceA(MapHModuleSL(lpofn->hInstance),
 323                                                  PTR_SEG_TO_LIN(lpofn->lpTemplateName),
 324                                                  RT_DIALOGA)))
 325                 {
 326                     COMDLG32_SetCommDlgExtendedError(CDERR_FINDRESFAILURE);
 327                     return FALSE;
 328                 }
 329                 if (!(hDlgTmpl = LoadResource(MapHModuleSL(lpofn->hInstance),
 330                                                 hResInfo)) ||
 331                     !(template = LockResource(hDlgTmpl)))
 332                 {
 333                     COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
 334                     return FALSE;
 335                 }
 336                 win32Format= TRUE;
 337             } else {
 338                 HANDLE hResInfo;
 339                 if (!(hResInfo = FindResourceA(COMMDLG_hInstance32, "SAVE_FILE", RT_DIALOGA)))
 340                 {
 341                     COMDLG32_SetCommDlgExtendedError(CDERR_FINDRESFAILURE);
 342                     return FALSE;
 343                 }
 344                 if (!(hDlgTmpl = LoadResource(COMMDLG_hInstance32, hResInfo )) ||
 345                     !(template = LockResource( hDlgTmpl )))
 346                 {
 347                     COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
 348                     return FALSE;
 349                 }
 350                 win32Format = TRUE;
 351             }
 352     } else {
 353             if (lpofn->Flags & OFN_ENABLETEMPLATEHANDLE)
 354             {
 355                 if (!(template = LockResource16( lpofn->hInstance )))
 356                 {
 357                     COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
 358                     return FALSE;
 359                 }
 360             }
 361             else if (lpofn->Flags & OFN_ENABLETEMPLATE)
 362             {
 363                 HANDLE16 hResInfo;
 364                 if (!(hResInfo = FindResource16(lpofn->hInstance,
 365                                                 lpofn->lpTemplateName,
 366                                                 RT_DIALOG16)))
 367                 {
 368                     COMDLG32_SetCommDlgExtendedError(CDERR_FINDRESFAILURE);
 369                     return FALSE;
 370                 }
 371                 if (!(hDlgTmpl = LoadResource16( lpofn->hInstance, hResInfo )) ||
 372                     !(template = LockResource16( hDlgTmpl )))
 373                 {
 374                     COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
 375                     return FALSE;
 376                 }
 377         } else {
 378                 HANDLE hResInfo;
 379                 if (!(hResInfo = FindResourceA(COMMDLG_hInstance32, "SAVE_FILE", RT_DIALOGA)))
 380                 {
 381                     COMDLG32_SetCommDlgExtendedError(CDERR_FINDRESFAILURE);
 382                     return FALSE;
 383                 }
 384                 if (!(hDlgTmpl = LoadResource(COMMDLG_hInstance32, hResInfo )) ||
 385                     !(template = LockResource( hDlgTmpl )))
 386                 {
 387                     COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
 388                     return FALSE;
 389                 }
 390                 win32Format = TRUE;
 391         }
 392     }
 393
 394     hInst = GetWindowLongA( lpofn->hwndOwner, GWL_HINSTANCE );
 395
 396     if (!(lpofn->lpstrFilter))
 397       {
 398        str = SEGPTR_ALLOC(sizeof(defaultfilter));
 399        TRACE("Alloc default for Filetype in GetSaveFileName\n");
 400        memcpy(str,defaultfilter,sizeof(defaultfilter));
 401        lpofn->lpstrFilter=SEGPTR_GET(str);
 402       }
 403
 404     if (!(lpofn->lpstrTitle))
 405       {
 406        str1 = SEGPTR_ALLOC(sizeof(defaultsave)+1);
 407        TRACE("Alloc default for Title in GetSaveFileName\n");
 408        strcpy(str1,defaultsave);
 409        lpofn->lpstrTitle=SEGPTR_GET(str1);
 410       }
 411
 412     hwndDialog = DIALOG_CreateIndirect( hInst, template, win32Format,
 413                                         lpofn->hwndOwner,
 414                                         (DLGPROC16)FileSaveDlgProc,
 415                                         ofn, WIN_PROC_32A );
 416     if (hwndDialog) bRet = DIALOG_DoDialogBox( hwndDialog, lpofn->hwndOwner );
 417
 418     if (str1)
 419       {
 420        TRACE("Freeing %p default for Title in GetSaveFileName\n",str1);
 421         SEGPTR_FREE(str1);
 422        lpofn->lpstrTitle=0;
 423       }
 424
 425     if (str)
 426       {
 427        TRACE("Freeing %p default for Filetype in GetSaveFileName\n",str);
 428         SEGPTR_FREE(str);
 429        lpofn->lpstrFilter=0;
 430       }
 431
 432     if (hDlgTmpl) {
 433             if (lpofn->Flags & OFN_WINE)
 434                     FreeResource( hDlgTmpl );
 435             else
 436                     FreeResource16( hDlgTmpl );
 437     }
 438
 439     TRACE("return lpstrFile='%s' !\n",
 440             (LPSTR)PTR_SEG_TO_LIN(lpofn->lpstrFile));
 441     return bRet;
 442 }
 443
 444 /***********************************************************************
 445  *                              FILEDLG_StripEditControl        [internal]
 446  * Strip pathnames off the contents of the edit control.
 447  */
 448 static void FILEDLG_StripEditControl(HWND16 hwnd)
 449 {
 450     char temp[512], *cp;
 451
 452     GetDlgItemTextA( hwnd, edt1, temp, sizeof(temp) );
 453     cp = strrchr(temp, '\\');
 454     if (cp != NULL) {
 455         strcpy(temp, cp+1);
 456     }
 457     cp = strrchr(temp, ':');
 458     if (cp != NULL) {
 459         strcpy(temp, cp+1);
 460     }
 461     /* FIXME: shouldn't we do something with the result here? ;-) */
 462 }
 463
 464 /***********************************************************************
 465  *                              FILEDLG_ScanDir                 [internal]
 466  */
 467 static BOOL FILEDLG_ScanDir(HWND16 hWnd, LPSTR newPath)
 468 {
 469     char                buffer[512];
 470          char*                  str = buffer;
 471     int                         drive;
 472     HWND                hlb;
 473
 474     lstrcpynA(buffer, newPath, sizeof(buffer));
 475
 476     if (str[0] && (str[1] == ':')) {
 477         drive = toupper(str[0]) - 'A';
 478         str += 2;
 479         if (!DRIVE_SetCurrentDrive(drive))
 480                           return FALSE;
 481     } else {
 482                  drive = DRIVE_GetCurrentDrive();
 483          }
 484
 485     if (str[0] && !DRIVE_Chdir(drive, str)) {
 486                  return FALSE;
 487     }
 488
 489     GetDlgItemTextA(hWnd, edt1, buffer, sizeof(buffer));
 490     if ((hlb = GetDlgItem(hWnd, lst1)) != 0) {
 491                  char*  scptr; /* ptr on semi-colon */
 492                  char*  filter = buffer;
 493
 494                  TRACE("Using filter %s\n", filter);
 495                  SendMessageA(hlb, LB_RESETCONTENT, 0, 0);
 496                  while (filter) {
 497                          scptr = strchr(filter, ';');
 498                          if (scptr)     *scptr = 0;
 499                          TRACE("Using file spec %s\n", filter);
 500                          if (SendMessageA(hlb, LB_DIR, 0, (LPARAM)filter) == LB_ERR)
 501                                  return FALSE;
 502                          if (scptr) *scptr = ';';
 503                          filter = (scptr) ? (scptr + 1) : 0;
 504                  }
 505          }
 506
 507     strcpy(buffer, "*.*");
 508     return DlgDirListA(hWnd, buffer, lst2, stc1, DDL_EXCLUSIVE | DDL_DIRECTORY);
 509 }
 510
 511 /***********************************************************************
 512  *                              FILEDLG_GetFileType             [internal]
 513  */
 514
 515 static LPSTR FILEDLG_GetFileType(LPSTR cfptr, LPSTR fptr, WORD index)
 516 {
 517   int n, i;
 518   i = 0;
 519   if (cfptr)
 520     for ( ;(n = strlen(cfptr)) != 0; i++)
 521       {
 522         cfptr += n + 1;
 523         if (i == index)
 524           return cfptr;
 525         cfptr += strlen(cfptr) + 1;
 526       }
 527   if (fptr)
 528     for ( ;(n = strlen(fptr)) != 0; i++)
 529       {
 530         fptr += n + 1;
 531         if (i == index)
 532           return fptr;
 533         fptr += strlen(fptr) + 1;
 534     }
 535   return "*.*"; /* FIXME */
 536 }
 537
 538 /***********************************************************************
 539  *                              FILEDLG_WMDrawItem              [internal]
 540  */
 541 static LONG FILEDLG_WMDrawItem(HWND16 hWnd, WPARAM16 wParam, LPARAM lParam,int savedlg)
 542 {
 543     LPDRAWITEMSTRUCT16 lpdis = (LPDRAWITEMSTRUCT16)PTR_SEG_TO_LIN(lParam);
 544     char *str;
 545     HICON16 hIcon;
 546     COLORREF oldText = 0, oldBk = 0;
 547
 548     if (lpdis->CtlType == ODT_LISTBOX && lpdis->CtlID == lst1)
 549     {
 550         if (!(str = SEGPTR_ALLOC(512))) return FALSE;
 551         SendMessage16(lpdis->hwndItem, LB_GETTEXT16, lpdis->itemID,
 552                       (LPARAM)SEGPTR_GET(str));
 553
 554         if ((lpdis->itemState & ODS_SELECTED) && !savedlg)
 555         {
 556             oldBk = SetBkColor( lpdis->hDC, GetSysColor( COLOR_HIGHLIGHT ) );
 557             oldText = SetTextColor( lpdis->hDC, GetSysColor(COLOR_HIGHLIGHTTEXT));
 558         }
 559         if (savedlg)
 560             SetTextColor(lpdis->hDC,GetSysColor(COLOR_GRAYTEXT) );
 561
 562         ExtTextOut16(lpdis->hDC, lpdis->rcItem.left + 1,
 563                   lpdis->rcItem.top + 1, ETO_OPAQUE | ETO_CLIPPED,
 564                   &(lpdis->rcItem), str, strlen(str), NULL);
 565
 566         if (lpdis->itemState & ODS_SELECTED)
 567             DrawFocusRect16( lpdis->hDC, &(lpdis->rcItem) );
 568
 569         if ((lpdis->itemState & ODS_SELECTED) && !savedlg)
 570         {
 571             SetBkColor( lpdis->hDC, oldBk );
 572             SetTextColor( lpdis->hDC, oldText );
 573         }
 574         SEGPTR_FREE(str);
 575         return TRUE;
 576     }
 577
 578     if (lpdis->CtlType == ODT_LISTBOX && lpdis->CtlID == lst2)
 579     {
 580         if (!(str = SEGPTR_ALLOC(512))) return FALSE;
 581         SendMessage16(lpdis->hwndItem, LB_GETTEXT16, lpdis->itemID,
 582                       (LPARAM)SEGPTR_GET(str));
 583
 584         if (lpdis->itemState & ODS_SELECTED)
 585         {
 586             oldBk = SetBkColor( lpdis->hDC, GetSysColor( COLOR_HIGHLIGHT ) );
 587             oldText = SetTextColor( lpdis->hDC, GetSysColor(COLOR_HIGHLIGHTTEXT));
 588         }
 589         ExtTextOut16(lpdis->hDC, lpdis->rcItem.left + fldrWidth,
 590                   lpdis->rcItem.top + 1, ETO_OPAQUE | ETO_CLIPPED,
 591                   &(lpdis->rcItem), str, strlen(str), NULL);
 592
 593         if (lpdis->itemState & ODS_SELECTED)
 594             DrawFocusRect16( lpdis->hDC, &(lpdis->rcItem) );
 595
 596         if (lpdis->itemState & ODS_SELECTED)
 597         {
 598             SetBkColor( lpdis->hDC, oldBk );
 599             SetTextColor( lpdis->hDC, oldText );
 600         }
 601         DrawIcon(lpdis->hDC, lpdis->rcItem.left, lpdis->rcItem.top, hFolder);
 602         SEGPTR_FREE(str);
 603         return TRUE;
 604     }
 605     if (lpdis->CtlType == ODT_COMBOBOX && lpdis->CtlID == cmb2)
 606     {
 607         if (!(str = SEGPTR_ALLOC(512))) return FALSE;
 608         SendMessage16(lpdis->hwndItem, CB_GETLBTEXT16, lpdis->itemID,
 609                       (LPARAM)SEGPTR_GET(str));
 610         switch(DRIVE_GetType( str[2] - 'a' ))
 611         {
 612         case TYPE_FLOPPY:  hIcon = hFloppy; break;
 613         case TYPE_CDROM:   hIcon = hCDRom; break;
 614         case TYPE_NETWORK: hIcon = hNet; break;
 615         case TYPE_HD:
 616         default:           hIcon = hHDisk; break;
 617         }
 618         if (lpdis->itemState & ODS_SELECTED)
 619         {
 620             oldBk = SetBkColor( lpdis->hDC, GetSysColor( COLOR_HIGHLIGHT ) );
 621             oldText = SetTextColor( lpdis->hDC, GetSysColor(COLOR_HIGHLIGHTTEXT));
 622         }
 623         ExtTextOut16(lpdis->hDC, lpdis->rcItem.left + fldrWidth,
 624                   lpdis->rcItem.top + 1, ETO_OPAQUE | ETO_CLIPPED,
 625                   &(lpdis->rcItem), str, strlen(str), NULL);
 626
 627         if (lpdis->itemState & ODS_SELECTED)
 628         {
 629             SetBkColor( lpdis->hDC, oldBk );
 630             SetTextColor( lpdis->hDC, oldText );
 631         }
 632         DrawIcon(lpdis->hDC, lpdis->rcItem.left, lpdis->rcItem.top, hIcon);
 633         SEGPTR_FREE(str);
 634         return TRUE;
 635     }
 636     return FALSE;
 637 }
 638
 639 /***********************************************************************
 640  *                              FILEDLG_WMMeasureItem           [internal]
 641  */
 642 static LONG FILEDLG_WMMeasureItem(HWND16 hWnd, WPARAM16 wParam, LPARAM lParam)
 643 {
 644     LPMEASUREITEMSTRUCT16 lpmeasure;
 645
 646     lpmeasure = (LPMEASUREITEMSTRUCT16)PTR_SEG_TO_LIN(lParam);
 647     lpmeasure->itemHeight = fldrHeight;
 648     return TRUE;
 649 }
 650
 651 /***********************************************************************
 652  *                              FILEDLG_HookCallChk             [internal]
 653  */
 654 static int FILEDLG_HookCallChk(LPOPENFILENAME16 lpofn)
 655 {
 656  if (lpofn)
 657   if (lpofn->Flags & OFN_ENABLEHOOK)
 658    if (lpofn->lpfnHook)
 659     return 1;
 660  return 0;
 661 }
 662
 663 /***********************************************************************
 664  *                              FILEDLG_CallWindowProc             [internal]
 665  *
 666  * Adapt the structures back for win32 calls so the callee can read lpCustData
 667  */
 668 static BOOL FILEDLG_CallWindowProc(LPOPENFILENAME16 lpofn,HWND hwnd,
 669         UINT wMsg,WPARAM wParam,LPARAM lParam
 670
 671 ) {
 672         BOOL            needstruct;
 673         BOOL          result = FALSE;
 674         WINDOWPROCTYPE  ProcType;               /* Type of Hook Function to be called. */
 675
 676         /* TRUE if lParam points to the OPENFILENAME16 Structure */
 677         needstruct = (PTR_SEG_TO_LIN(lParam) == lpofn);
 678
 679         ProcType   = (lpofn->Flags & OFN_WINE)
 680                      ? (lpofn->Flags & OFN_UNICODE)             /* 32-Bit call to GetOpenFileName */
 681                        ? WIN_PROC_32W : WIN_PROC_32A
 682                      : WIN_PROC_16;                             /* 16-Bit call to GetOpenFileName */
 683
 684         if (!(lpofn->Flags & OFN_WINE))
 685                 /* Call to 16-Bit Hooking function... No Problem at all. */
 686                 return (BOOL)CallWindowProc16(
 687                         (WNDPROC16)lpofn->lpfnHook,hwnd,(UINT16)wMsg,(WPARAM16)wParam,lParam
 688                 );
 689         /* |OFN_WINE32 */
 690         if (needstruct)
 691         {
 692            /* Parameter lParam points to lpofn... Convert Structure Data... */
 693            if (lpofn->Flags & OFN_UNICODE)
 694            {
 695                 OPENFILENAMEW ofnw;
 696
 697                 /* FIXME: probably needs more converted */
 698                 ofnw.lCustData = lpofn->lCustData;
 699                 return (BOOL)CallWindowProcW(
 700                          (WNDPROC)lpofn->lpfnHook,hwnd,wMsg,wParam,(LPARAM)&ofnw
 701                 );
 702            }
 703            else /* ! |OFN_UNICODE */
 704            {
 705                 OPENFILENAMEA ofna;
 706
 707                 /* FIXME: probably needs more converted */
 708                 ofna.lCustData = lpofn->lCustData;
 709                 return (BOOL)CallWindowProcA(
 710                         (WNDPROC)lpofn->lpfnHook,hwnd,wMsg,wParam,(LPARAM)&ofna
 711                 );
 712            }
 713         }
 714         else /* ! needstruct */
 715         {
 716                 HWINDOWPROC     hWindowProc=NULL;
 717
 718                 if (WINPROC_SetProc(&hWindowProc, (WNDPROC16)lpofn->lpfnHook, ProcType, WIN_PROC_WINDOW))
 719                 {
 720                     /* Call Window Procedure converting 16-Bit Type Parameters to 32-Bit Type Parameters */
 721                     result = CallWindowProc16( (WNDPROC16)hWindowProc,
 722                                                       hwnd, wMsg, wParam, lParam );
 723
 724                     result = LOWORD(result);
 725
 726                     WINPROC_FreeProc( hWindowProc, WIN_PROC_WINDOW );
 727                 }
 728
 729                 return result;
 730
 731         }
 732 }
 733
 734
 735 /***********************************************************************
 736  *                              FILEDLG_WMInitDialog            [internal]
 737  */
 738
 739 static LONG FILEDLG_WMInitDialog(HWND16 hWnd, WPARAM16 wParam, LPARAM lParam)
 740 {
 741   int i, n;
 742   LPOPENFILENAME16 lpofn;
 743   char tmpstr[512];
 744   LPSTR pstr, old_pstr;
 745   SetPropA(hWnd,OFN_PROP,lParam);
 746   lpofn = (LPOPENFILENAME16)PTR_SEG_TO_LIN(lParam);
 747   if (lpofn->lpstrTitle) SetWindowText16( hWnd, lpofn->lpstrTitle );
 748   /* read custom filter information */
 749   if (lpofn->lpstrCustomFilter)
 750     {
 751       pstr = (LPSTR)PTR_SEG_TO_LIN(lpofn->lpstrCustomFilter);
 752       n = 0;
 753       TRACE("lpstrCustomFilter = %p\n", pstr);
 754       while(*pstr)
 755         {
 756           old_pstr = pstr;
 757           i = SendDlgItemMessage16(hWnd, cmb1, CB_ADDSTRING16, 0,
 758                                    (LPARAM)lpofn->lpstrCustomFilter + n );
 759           n += strlen(pstr) + 1;
 760           pstr += strlen(pstr) + 1;
 761           TRACE("add str='%s' "
 762                           "associated to '%s'\n", old_pstr, pstr);
 763           SendDlgItemMessage16(hWnd, cmb1, CB_SETITEMDATA16, i, (LPARAM)pstr);
 764           n += strlen(pstr) + 1;
 765           pstr += strlen(pstr) + 1;
 766         }
 767     }
 768   /* read filter information */
 769   if (lpofn->lpstrFilter) {
 770         pstr = (LPSTR)PTR_SEG_TO_LIN(lpofn->lpstrFilter);
 771         n = 0;
 772         while(*pstr) {
 773           old_pstr = pstr;
 774           i = SendDlgItemMessage16(hWnd, cmb1, CB_ADDSTRING16, 0,
 775                                        (LPARAM)lpofn->lpstrFilter + n );
 776           n += strlen(pstr) + 1;
 777           pstr += strlen(pstr) + 1;
 778           TRACE("add str='%s' "
 779                           "associated to '%s'\n", old_pstr, pstr);
 780           SendDlgItemMessage16(hWnd, cmb1, CB_SETITEMDATA16, i, (LPARAM)pstr);
 781           n += strlen(pstr) + 1;
 782           pstr += strlen(pstr) + 1;
 783         }
 784   }
 785   /* set default filter */
 786   if (lpofn->nFilterIndex == 0 && lpofn->lpstrCustomFilter == (SEGPTR)NULL)
 787         lpofn->nFilterIndex = 1;
 788   SendDlgItemMessage16(hWnd, cmb1, CB_SETCURSEL16, lpofn->nFilterIndex - 1, 0);
 789   lstrcpynA(tmpstr, FILEDLG_GetFileType(PTR_SEG_TO_LIN(lpofn->lpstrCustomFilter),
 790              PTR_SEG_TO_LIN(lpofn->lpstrFilter), lpofn->nFilterIndex - 1),512);
 791   TRACE("nFilterIndex = %ld, SetText of edt1 to '%s'\n",
 792                         lpofn->nFilterIndex, tmpstr);
 793   SetDlgItemTextA( hWnd, edt1, tmpstr );
 794   /* get drive list */
 795   *tmpstr = 0;
 796   DlgDirListComboBoxA(hWnd, tmpstr, cmb2, 0, DDL_DRIVES | DDL_EXCLUSIVE);
 797   /* read initial directory */
 798   if (PTR_SEG_TO_LIN(lpofn->lpstrInitialDir) != NULL)
 799     {
 800       int len;
 801       lstrcpynA(tmpstr, PTR_SEG_TO_LIN(lpofn->lpstrInitialDir), 511);
 802       len=strlen(tmpstr);
 803       if (len > 0 && tmpstr[len-1] != '\\'  && tmpstr[len-1] != ':') {
 804         tmpstr[len]='\\';
 805         tmpstr[len+1]='\0';
 806       }
 807     }
 808   else
 809     *tmpstr = 0;
 810   if (!FILEDLG_ScanDir(hWnd, tmpstr)) {
 811     *tmpstr = 0;
 812     if (!FILEDLG_ScanDir(hWnd, tmpstr))
 813       WARN("Couldn't read initial directory %s!\n",tmpstr);
 814   }
 815   /* select current drive in combo 2, omit missing drives */
 816   for(i=0, n=-1; i<=DRIVE_GetCurrentDrive(); i++)
 817     if (DRIVE_IsValid(i))                  n++;
 818   SendDlgItemMessage16(hWnd, cmb2, CB_SETCURSEL16, n, 0);
 819   if (!(lpofn->Flags & OFN_SHOWHELP))
 820     ShowWindow(GetDlgItem(hWnd, pshHelp), SW_HIDE);
 821   if (lpofn->Flags & OFN_HIDEREADONLY)
 822     ShowWindow(GetDlgItem(hWnd, chx1), SW_HIDE);
 823   if (FILEDLG_HookCallChk(lpofn))
 824      return (BOOL16)FILEDLG_CallWindowProc(lpofn,hWnd,WM_INITDIALOG,wParam,lParam );
 825   else
 826      return TRUE;
 827 }
 828
 829 /***********************************************************************
 830  *                              FILEDLG_WMCommand               [internal]
 831  */
 832 BOOL in_update=FALSE;
 833
 834 static LRESULT FILEDLG_WMCommand(HWND16 hWnd, WPARAM16 wParam, LPARAM lParam)
 835 {
 836   LONG lRet;
 837   LPOPENFILENAME16 lpofn;
 838   OPENFILENAME16 ofn2;
 839   char tmpstr[512], tmpstr2[512];
 840   LPSTR pstr, pstr2;
 841   UINT16 control,notification;
 842
 843   /* Notifications are packaged differently in Win32 */
 844   control = wParam;
 845   notification = HIWORD(lParam);
 846
 847   lpofn = (LPOPENFILENAME16)PTR_SEG_TO_LIN(GetPropA(hWnd,OFN_PROP));
 848   switch (control)
 849     {
 850     case lst1: /* file list */
 851       FILEDLG_StripEditControl(hWnd);
 852       if (notification == LBN_DBLCLK)
 853         goto almost_ok;
 854       lRet = SendDlgItemMessage16(hWnd, lst1, LB_GETCURSEL16, 0, 0);
 855       if (lRet == LB_ERR) return TRUE;
 856       if ((pstr = SEGPTR_ALLOC(512)))
 857       {
 858           SendDlgItemMessage16(hWnd, lst1, LB_GETTEXT16, lRet,
 859                                (LPARAM)SEGPTR_GET(pstr));
 860           SetDlgItemTextA( hWnd, edt1, pstr );
 861           SEGPTR_FREE(pstr);
 862       }
 863       if (FILEDLG_HookCallChk(lpofn))
 864        FILEDLG_CallWindowProc(lpofn,hWnd,
 865                   RegisterWindowMessageA( LBSELCHSTRING ),
 866                   control, MAKELONG(lRet,CD_LBSELCHANGE));
 867       /* FIXME: for OFN_ALLOWMULTISELECT we need CD_LBSELSUB, CD_SELADD, CD_LBSELNOITEMS */
 868       return TRUE;
 869     case lst2: /* directory list */
 870       FILEDLG_StripEditControl(hWnd);
 871       if (notification == LBN_DBLCLK)
 872         {
 873           lRet = SendDlgItemMessage16(hWnd, lst2, LB_GETCURSEL16, 0, 0);
 874           if (lRet == LB_ERR) return TRUE;
 875           pstr = SEGPTR_ALLOC(512);
 876           SendDlgItemMessage16(hWnd, lst2, LB_GETTEXT16, lRet,
 877                              (LPARAM)SEGPTR_GET(pstr));
 878           strcpy( tmpstr, pstr );
 879           SEGPTR_FREE(pstr);
 880           if (tmpstr[0] == '[')
 881             {
 882               tmpstr[strlen(tmpstr) - 1] = 0;
 883               strcpy(tmpstr,tmpstr+1);
 884             }
 885           strcat(tmpstr, "\\");
 886           goto reset_scan;
 887         }
 888       return TRUE;
 889     case cmb1: /* file type drop list */
 890       if (notification == CBN_SELCHANGE)
 891         {
 892           *tmpstr = 0;
 893           goto reset_scan;
 894         }
 895       return TRUE;
 896     case chx1:
 897       return TRUE;
 898     case pshHelp:
 899       return TRUE;
 900     case cmb2: /* disk drop list */
 901       FILEDLG_StripEditControl(hWnd);
 902       lRet = SendDlgItemMessage16(hWnd, cmb2, CB_GETCURSEL16, 0, 0L);
 903       if (lRet == LB_ERR) return 0;
 904       pstr = SEGPTR_ALLOC(512);
 905       SendDlgItemMessage16(hWnd, cmb2, CB_GETLBTEXT16, lRet,
 906                            (LPARAM)SEGPTR_GET(pstr));
 907       sprintf(tmpstr, "%c:", pstr[2]);
 908       SEGPTR_FREE(pstr);
 909     reset_scan:
 910       lRet = SendDlgItemMessage16(hWnd, cmb1, CB_GETCURSEL16, 0, 0);
 911       if (lRet == LB_ERR)
 912         return TRUE;
 913       pstr = (LPSTR)SendDlgItemMessage16(hWnd, cmb1, CB_GETITEMDATA16, lRet, 0);
 914       TRACE("Selected filter : %s\n", pstr);
 915       SetDlgItemTextA( hWnd, edt1, pstr );
 916       FILEDLG_ScanDir(hWnd, tmpstr);
 917       in_update=TRUE;
 918     case IDOK:
 919     almost_ok:
 920       ofn2=*lpofn; /* for later restoring */
 921       GetDlgItemTextA( hWnd, edt1, tmpstr, sizeof(tmpstr) );
 922       pstr = strrchr(tmpstr, '\\');
 923       if (pstr == NULL)
 924         pstr = strrchr(tmpstr, ':');
 925       if (strchr(tmpstr,'*') != NULL || strchr(tmpstr,'?') != NULL)
 926         {
 927           /* edit control contains wildcards */
 928           if (pstr != NULL)
 929             {
 930               lstrcpynA(tmpstr2, pstr+1, 512);
 931               *(pstr+1) = 0;
 932             }
 933           else
 934             {
 935               strcpy(tmpstr2, tmpstr);
 936               *tmpstr=0;
 937             }
 938           TRACE("tmpstr=%s, tmpstr2=%s\n", tmpstr, tmpstr2);
 939           SetDlgItemTextA( hWnd, edt1, tmpstr2 );
 940           FILEDLG_ScanDir(hWnd, tmpstr);
 941           return TRUE;
 942         }
 943       /* no wildcards, we might have a directory or a filename */
 944       /* try appending a wildcard and reading the directory */
 945       pstr2 = tmpstr + strlen(tmpstr);
 946       if (pstr == NULL || *(pstr+1) != 0)
 947         strcat(tmpstr, "\\");
 948       lRet = SendDlgItemMessage16(hWnd, cmb1, CB_GETCURSEL16, 0, 0);
 949       if (lRet == LB_ERR) return TRUE;
 950       lpofn->nFilterIndex = lRet + 1;
 951       TRACE("lpofn->nFilterIndex=%ld\n", lpofn->nFilterIndex);
 952       lstrcpynA(tmpstr2,
 953              FILEDLG_GetFileType(PTR_SEG_TO_LIN(lpofn->lpstrCustomFilter),
 954                                  PTR_SEG_TO_LIN(lpofn->lpstrFilter),
 955                                  lRet), sizeof(tmpstr2));
 956       SetDlgItemTextA( hWnd, edt1, tmpstr2 );
 957       if (!in_update)
 958       /* if ScanDir succeeds, we have changed the directory */
 959       if (FILEDLG_ScanDir(hWnd, tmpstr)) return TRUE;
 960       /* if not, this must be a filename */
 961       *pstr2 = 0;
 962       if (pstr != NULL)
 963         {
 964           /* strip off the pathname */
 965           *pstr = 0;
 966           SetDlgItemTextA( hWnd, edt1, pstr + 1 );
 967           lstrcpynA(tmpstr2, pstr+1, sizeof(tmpstr2) );
 968           /* Should we MessageBox() if this fails? */
 969           if (!FILEDLG_ScanDir(hWnd, tmpstr)) return TRUE;
 970           strcpy(tmpstr, tmpstr2);
 971         }
 972       else SetDlgItemTextA( hWnd, edt1, tmpstr );
 973 #if 0
 974       ShowWindow16(hWnd, SW_HIDE);   /* this should not be necessary ?! (%%%) */
 975 #endif
 976       {
 977         int lenstr2;
 978         int drive = DRIVE_GetCurrentDrive();
 979         tmpstr2[0] = 'A'+ drive;
 980         tmpstr2[1] = ':';
 981         tmpstr2[2] = '\\';
 982         lstrcpynA(tmpstr2 + 3, DRIVE_GetDosCwd(drive), 507);
 983         lenstr2=strlen(tmpstr2);
 984         if (lenstr2 > 3)
 985            tmpstr2[lenstr2++]='\\';
 986         lstrcpynA(tmpstr2+lenstr2, tmpstr, 512-lenstr2);
 987         if (lpofn->lpstrFile)
 988           lstrcpynA(PTR_SEG_TO_LIN(lpofn->lpstrFile), tmpstr2,lpofn->nMaxFile);
 989       }
 990       lpofn->nFileOffset = strrchr(tmpstr2,'\\') - tmpstr2 +1;
 991       lpofn->nFileExtension = 0;
 992       while(tmpstr2[lpofn->nFileExtension] != '.' && tmpstr2[lpofn->nFileExtension] != '\0')
 993         lpofn->nFileExtension++;
 994       if (tmpstr2[lpofn->nFileExtension] == '\0')
 995         lpofn->nFileExtension = 0;
 996       else
 997         lpofn->nFileExtension++;
 998
 999       if(in_update)
1000        {
1001          if (FILEDLG_HookCallChk(lpofn))
1002            FILEDLG_CallWindowProc(lpofn,hWnd,
1003                                   RegisterWindowMessageA( LBSELCHSTRING ),
1004                                   control, MAKELONG(lRet,CD_LBSELCHANGE));
1005
1006          in_update = FALSE;
1007          return TRUE;
1008        }
1009       if (PTR_SEG_TO_LIN(lpofn->lpstrFileTitle) != NULL)
1010         {
1011           lRet = SendDlgItemMessage16(hWnd, lst1, LB_GETCURSEL16, 0, 0);
1012           SendDlgItemMessage16(hWnd, lst1, LB_GETTEXT16, lRet,
1013                                lpofn->lpstrFileTitle );
1014         }
1015       if (FILEDLG_HookCallChk(lpofn))
1016       {
1017        lRet= (BOOL16)FILEDLG_CallWindowProc(lpofn,
1018                hWnd, RegisterWindowMessageA( FILEOKSTRING ), 0, lParam );
1019        if (lRet)
1020        {
1021          *lpofn=ofn2; /* restore old state */
1022 #if 0
1023          ShowWindow16(hWnd, SW_SHOW);               /* only if above (%%%) SW_HIDE used */
1024 #endif
1025          break;
1026        }
1027       }
1028       if ((lpofn->Flags & OFN_ALLOWMULTISELECT) && (lpofn->Flags & OFN_EXPLORER)) {
1029          if (lpofn->lpstrFile) {
1030             LPSTR str = (LPSTR)PTR_SEG_TO_LIN(lpofn->lpstrFile);
1031             LPSTR ptr = strrchr(str, '\\');
1032             str[strlen(str) + 1] = '\0';
1033             *ptr = 0;
1034          }
1035       }
1036       EndDialog(hWnd, TRUE);
1037       return TRUE;
1038     case IDCANCEL:
1039       EndDialog(hWnd, FALSE);
1040       return TRUE;
1041     }
1042   return FALSE;
1043 }
1044
1045 /***********************************************************************
1046  *           FileOpenDlgProc16   (COMMDLG.6)
1047  */
1048 LRESULT WINAPI FileOpenDlgProc16(HWND16 hWnd, UINT16 wMsg, WPARAM16 wParam,
1049                                LPARAM lParam)
1050 {
1051  LPOPENFILENAME16 lpofn =(LPOPENFILENAME16)PTR_SEG_TO_LIN(GetPropA(hWnd,OFN_PROP));
1052
1053  if (wMsg!=WM_INITDIALOG)
1054   if (FILEDLG_HookCallChk(lpofn))
1055   {
1056    LRESULT  lRet=(BOOL16)FILEDLG_CallWindowProc(lpofn,hWnd,wMsg,wParam,lParam);
1057    if (lRet)
1058     return lRet;         /* else continue message processing */
1059   }
1060   switch (wMsg)
1061     {
1062     case WM_INITDIALOG:
1063       return FILEDLG_WMInitDialog(hWnd, wParam, lParam);
1064     case WM_MEASUREITEM:
1065       return FILEDLG_WMMeasureItem(hWnd, wParam, lParam);
1066     case WM_DRAWITEM:
1067       return FILEDLG_WMDrawItem(hWnd, wParam, lParam, FALSE);
1068     case WM_COMMAND:
1069       return FILEDLG_WMCommand(hWnd, wParam, lParam);
1070 #if 0
1071     case WM_CTLCOLOR:
1072       SetBkColor((HDC16)wParam, 0x00C0C0C0);
1073       switch (HIWORD(lParam))
1074         {
1075         case CTLCOLOR_BTN:
1076           SetTextColor((HDC16)wParam, 0x00000000);
1077           return hGRAYBrush;
1078         case CTLCOLOR_STATIC:
1079           SetTextColor((HDC16)wParam, 0x00000000);
1080           return hGRAYBrush;
1081         }
1082       break;
1083 #endif
1084     }
1085   return FALSE;
1086 }
1087
1088 /***********************************************************************
1089  *           FileSaveDlgProc16   (COMMDLG.7)
1090  */
1091 LRESULT WINAPI FileSaveDlgProc16(HWND16 hWnd, UINT16 wMsg, WPARAM16 wParam,
1092                                LPARAM lParam)
1093 {
1094  LPOPENFILENAME16 lpofn =(LPOPENFILENAME16)PTR_SEG_TO_LIN(GetPropA(hWnd,OFN_PROP));
1095
1096  if (wMsg!=WM_INITDIALOG)
1097   if (FILEDLG_HookCallChk(lpofn))
1098   {
1099    LRESULT  lRet=(BOOL16)FILEDLG_CallWindowProc(lpofn,hWnd,wMsg,wParam,lParam);
1100    if (lRet)
1101     return lRet;         /* else continue message processing */
1102   }
1103   switch (wMsg) {
1104    case WM_INITDIALOG:
1105       return FILEDLG_WMInitDialog(hWnd, wParam, lParam);
1106
1107    case WM_MEASUREITEM:
1108       return FILEDLG_WMMeasureItem(hWnd, wParam, lParam);
1109
1110    case WM_DRAWITEM:
1111       return FILEDLG_WMDrawItem(hWnd, wParam, lParam, TRUE);
1112
1113    case WM_COMMAND:
1114       return FILEDLG_WMCommand(hWnd, wParam, lParam);
1115   }
1116
1117   /*
1118   case WM_CTLCOLOR:
1119    SetBkColor((HDC16)wParam, 0x00C0C0C0);
1120    switch (HIWORD(lParam))
1121    {
1122     case CTLCOLOR_BTN:
1123      SetTextColor((HDC16)wParam, 0x00000000);
1124      return hGRAYBrush;
1125     case CTLCOLOR_STATIC:
1126      SetTextColor((HDC16)wParam, 0x00000000);
1127      return hGRAYBrush;
1128    }
1129    return FALSE;
1130
1131    */
1132   return FALSE;
1133 }
1134
1135 static BOOL Commdlg_GetFileNameA( BOOL16 (CALLBACK *dofunction)(SEGPTR x),
1136                                       LPOPENFILENAMEA ofn )
1137 {
1138         BOOL16 ret;
1139         LPOPENFILENAME16 ofn16 = SEGPTR_ALLOC(sizeof(OPENFILENAME16));
1140
1141         memset(ofn16,'\0',sizeof(*ofn16));
1142         ofn16->lStructSize = sizeof(*ofn16);
1143         ofn16->hwndOwner = ofn->hwndOwner;
1144         ofn16->hInstance = MapHModuleLS(ofn->hInstance);
1145         if (ofn->lpstrFilter) {
1146                 LPSTR   s,x;
1147
1148                 /* filter is a list...  title\0ext\0......\0\0 */
1149                 s = (LPSTR)ofn->lpstrFilter;
1150                 while (*s)
1151                         s = s+strlen(s)+1;
1152                 s++;
1153                 x = (LPSTR)SEGPTR_ALLOC(s-ofn->lpstrFilter);
1154                 memcpy(x,ofn->lpstrFilter,s-ofn->lpstrFilter);
1155                 ofn16->lpstrFilter = SEGPTR_GET(x);
1156         }
1157         if (ofn->lpstrCustomFilter) {
1158                 LPSTR   s,x;
1159
1160                 /* filter is a list...  title\0ext\0......\0\0 */
1161                 s = (LPSTR)ofn->lpstrCustomFilter;
1162                 while (*s)
1163                         s = s+strlen(s)+1;
1164                 s++;
1165                 x = SEGPTR_ALLOC(s-ofn->lpstrCustomFilter);
1166                 memcpy(x,ofn->lpstrCustomFilter,s-ofn->lpstrCustomFilter);
1167                 ofn16->lpstrCustomFilter = SEGPTR_GET(x);
1168         }
1169         ofn16->nMaxCustFilter = ofn->nMaxCustFilter;
1170         ofn16->nFilterIndex = ofn->nFilterIndex;
1171         if (ofn->nMaxFile)
1172             ofn16->lpstrFile = SEGPTR_GET(SEGPTR_ALLOC(ofn->nMaxFile));
1173         ofn16->nMaxFile = ofn->nMaxFile;
1174         ofn16->nMaxFileTitle = ofn->nMaxFileTitle;
1175         if (ofn16->nMaxFileTitle)
1176             ofn16->lpstrFileTitle = SEGPTR_GET(SEGPTR_ALLOC(ofn->nMaxFileTitle));
1177         if (ofn->lpstrInitialDir)
1178             ofn16->lpstrInitialDir = SEGPTR_GET(SEGPTR_STRDUP(ofn->lpstrInitialDir));
1179         if (ofn->lpstrTitle)
1180             ofn16->lpstrTitle = SEGPTR_GET(SEGPTR_STRDUP(ofn->lpstrTitle));
1181         ofn16->Flags = ofn->Flags|OFN_WINE;
1182         ofn16->nFileOffset = ofn->nFileOffset;
1183         ofn16->nFileExtension = ofn->nFileExtension;
1184         if (ofn->lpstrDefExt)
1185             ofn16->lpstrDefExt = SEGPTR_GET(SEGPTR_STRDUP(ofn->lpstrDefExt));
1186         ofn16->lCustData = ofn->lCustData;
1187         ofn16->lpfnHook = (LPOFNHOOKPROC16)ofn->lpfnHook;
1188
1189         if (ofn->lpTemplateName)
1190             ofn16->lpTemplateName = SEGPTR_GET(SEGPTR_STRDUP(ofn->lpTemplateName));
1191
1192         ret = dofunction(SEGPTR_GET(ofn16));
1193
1194         ofn->nFileOffset = ofn16->nFileOffset;
1195         ofn->nFileExtension = ofn16->nFileExtension;
1196         if (ofn16->lpstrFilter)
1197             SEGPTR_FREE(PTR_SEG_TO_LIN(ofn16->lpstrFilter));
1198         if (ofn16->lpTemplateName)
1199             SEGPTR_FREE(PTR_SEG_TO_LIN(ofn16->lpTemplateName));
1200         if (ofn16->lpstrDefExt)
1201             SEGPTR_FREE(PTR_SEG_TO_LIN(ofn16->lpstrDefExt));
1202         if (ofn16->lpstrTitle)
1203             SEGPTR_FREE(PTR_SEG_TO_LIN(ofn16->lpstrTitle));
1204         if (ofn16->lpstrInitialDir)
1205             SEGPTR_FREE(PTR_SEG_TO_LIN(ofn16->lpstrInitialDir));
1206         if (ofn16->lpstrCustomFilter)
1207             SEGPTR_FREE(PTR_SEG_TO_LIN(ofn16->lpstrCustomFilter));
1208
1209         if (ofn16->lpstrFile)
1210           {
1211             LPCSTR      src = PTR_SEG_TO_LIN(ofn16->lpstrFile);
1212             LPSTR       dst = ofn->lpstrFile;
1213
1214             if ((ofn->Flags & OFN_ALLOWMULTISELECT) && (ofn->Flags & OFN_EXPLORER)) {
1215                /* FIXME(EPP): I tried to use:
1216                 * memcpy(ofn->lpstrFile, PTR_SEG_TO_LIN(ofn16->lpstrFile, ofn->nMaxFile)
1217                 * but it did crash with winamp 2.21, so copy string by string
1218                 */
1219                int      len;
1220                do {
1221                   strcpy(dst, src);
1222                   len = strlen(dst) + 1;        /* strlen(dst) == strlen(src) */
1223                   dst += len;
1224                   src += len;
1225                } while (len > 1);
1226             } else {
1227                strcpy(dst, src);
1228             }
1229             SEGPTR_FREE(PTR_SEG_TO_LIN(ofn16->lpstrFile));
1230           }
1231
1232         if (ofn16->lpstrFileTitle)
1233           {
1234             if (ofn->lpstrFileTitle)
1235                 strcpy(ofn->lpstrFileTitle,
1236                         PTR_SEG_TO_LIN(ofn16->lpstrFileTitle));
1237             SEGPTR_FREE(PTR_SEG_TO_LIN(ofn16->lpstrFileTitle));
1238           }
1239         SEGPTR_FREE(ofn16);
1240         return ret;
1241 }
1242
1243 static BOOL Commdlg_GetFileNameW( BOOL16 (CALLBACK *dofunction)(SEGPTR x),
1244                                       LPOPENFILENAMEW ofn )
1245 {
1246         BOOL16 ret;
1247         LPOPENFILENAME16 ofn16 = SEGPTR_ALLOC(sizeof(OPENFILENAME16));
1248
1249         memset(ofn16,'\0',sizeof(*ofn16));
1250         ofn16->lStructSize = sizeof(*ofn16);
1251         ofn16->hwndOwner = ofn->hwndOwner;
1252         ofn16->hInstance = MapHModuleLS(ofn->hInstance);
1253         if (ofn->lpstrFilter) {
1254                 LPWSTR  s;
1255                 LPSTR   x,y;
1256                 int     n;
1257
1258                 /* filter is a list...  title\0ext\0......\0\0 */
1259                 s = (LPWSTR)ofn->lpstrFilter;
1260                 while (*s)
1261                         s = s+lstrlenW(s)+1;
1262                 s++;
1263                 n = s - ofn->lpstrFilter; /* already divides by 2. ptr magic */
1264                 x = y = (LPSTR)SEGPTR_ALLOC(n);
1265                 s = (LPWSTR)ofn->lpstrFilter;
1266                 while (*s) {
1267                         lstrcpyWtoA(x,s);
1268                         x+=lstrlenA(x)+1;
1269                         s+=lstrlenW(s)+1;
1270                 }
1271                 *x=0;
1272                 ofn16->lpstrFilter = SEGPTR_GET(y);
1273 }
1274         if (ofn->lpstrCustomFilter) {
1275                 LPWSTR  s;
1276                 LPSTR   x,y;
1277                 int     n;
1278
1279                 /* filter is a list...  title\0ext\0......\0\0 */
1280                 s = (LPWSTR)ofn->lpstrCustomFilter;
1281                 while (*s)
1282                         s = s+lstrlenW(s)+1;
1283                 s++;
1284                 n = s - ofn->lpstrCustomFilter;
1285                 x = y = (LPSTR)SEGPTR_ALLOC(n);
1286                 s = (LPWSTR)ofn->lpstrCustomFilter;
1287                 while (*s) {
1288                         lstrcpyWtoA(x,s);
1289                         x+=lstrlenA(x)+1;
1290                         s+=lstrlenW(s)+1;
1291                 }
1292                 *x=0;
1293                 ofn16->lpstrCustomFilter = SEGPTR_GET(y);
1294         }
1295         ofn16->nMaxCustFilter = ofn->nMaxCustFilter;
1296         ofn16->nFilterIndex = ofn->nFilterIndex;
1297         if (ofn->nMaxFile)
1298            ofn16->lpstrFile = SEGPTR_GET(SEGPTR_ALLOC(ofn->nMaxFile));
1299         ofn16->nMaxFile = ofn->nMaxFile;
1300         ofn16->nMaxFileTitle = ofn->nMaxFileTitle;
1301         if (ofn->nMaxFileTitle)
1302                 ofn16->lpstrFileTitle = SEGPTR_GET(SEGPTR_ALLOC(ofn->nMaxFileTitle));
1303         if (ofn->lpstrInitialDir)
1304                 ofn16->lpstrInitialDir = SEGPTR_GET(SEGPTR_STRDUP_WtoA(ofn->lpstrInitialDir));
1305         if (ofn->lpstrTitle)
1306                 ofn16->lpstrTitle = SEGPTR_GET(SEGPTR_STRDUP_WtoA(ofn->lpstrTitle));
1307         ofn16->Flags = ofn->Flags|OFN_WINE|OFN_UNICODE;
1308         ofn16->nFileOffset = ofn->nFileOffset;
1309         ofn16->nFileExtension = ofn->nFileExtension;
1310         if (ofn->lpstrDefExt)
1311                 ofn16->lpstrDefExt = SEGPTR_GET(SEGPTR_STRDUP_WtoA(ofn->lpstrDefExt));
1312         ofn16->lCustData = ofn->lCustData;
1313         ofn16->lpfnHook = (LPOFNHOOKPROC16)ofn->lpfnHook;
1314         if (ofn->lpTemplateName)
1315                 ofn16->lpTemplateName = SEGPTR_GET(SEGPTR_STRDUP_WtoA(ofn->lpTemplateName));
1316         ret = dofunction(SEGPTR_GET(ofn16));
1317
1318         ofn->nFileOffset = ofn16->nFileOffset;
1319         ofn->nFileExtension = ofn16->nFileExtension;
1320         if (ofn16->lpstrFilter)
1321                 SEGPTR_FREE(PTR_SEG_TO_LIN(ofn16->lpstrFilter));
1322         if (ofn16->lpTemplateName)
1323                 SEGPTR_FREE(PTR_SEG_TO_LIN(ofn16->lpTemplateName));
1324         if (ofn16->lpstrDefExt)
1325                 SEGPTR_FREE(PTR_SEG_TO_LIN(ofn16->lpstrDefExt));
1326         if (ofn16->lpstrTitle)
1327                 SEGPTR_FREE(PTR_SEG_TO_LIN(ofn16->lpstrTitle));
1328         if (ofn16->lpstrInitialDir)
1329                 SEGPTR_FREE(PTR_SEG_TO_LIN(ofn16->lpstrInitialDir));
1330         if (ofn16->lpstrCustomFilter)
1331                 SEGPTR_FREE(PTR_SEG_TO_LIN(ofn16->lpstrCustomFilter));
1332
1333         if (ofn16->lpstrFile)
1334           {
1335             LPCSTR      src = PTR_SEG_TO_LIN(ofn16->lpstrFile);
1336             LPWSTR      dst = ofn->lpstrFile;
1337
1338             if ((ofn->Flags & OFN_ALLOWMULTISELECT) && (ofn->Flags & OFN_EXPLORER)) {
1339                int      len;
1340                do {
1341                   lstrcpyAtoW(dst, src);
1342                   dst += lstrlenW(dst) + 1;
1343                   src += (len = strlen(src) + 1);
1344                } while (len > 1);
1345             } else {
1346                lstrcpyAtoW(ofn->lpstrFile,PTR_SEG_TO_LIN(ofn16->lpstrFile));
1347             }
1348             SEGPTR_FREE(PTR_SEG_TO_LIN(ofn16->lpstrFile));
1349           }
1350
1351         if (ofn16->lpstrFileTitle) {
1352             if (ofn->lpstrFileTitle)
1353                 lstrcpyAtoW(ofn->lpstrFileTitle,
1354                         PTR_SEG_TO_LIN(ofn16->lpstrFileTitle));
1355             SEGPTR_FREE(PTR_SEG_TO_LIN(ofn16->lpstrFileTitle));
1356         }
1357         SEGPTR_FREE(ofn16);
1358         return ret;
1359 }
1360 /***********************************************************************
1361  *            GetOpenFileNameA  (COMDLG32.10)
1362  *
1363  * Creates a dialog box for the user to select a file to open.
1364  *
1365  * RETURNS
1366  *    TRUE on succes: user enters a valid file
1367  *    FALSE on cancel, error, close or filename-does-not-fit-in-buffer.
1368  *
1369  * BUGS
1370  *    unknown, calls its 16-bit equivalent.
1371  */
1372 BOOL WINAPI GetOpenFileNameA(
1373                              LPOPENFILENAMEA ofn /* address of init structure */
1374                              )
1375 {
1376     if( (TWEAK_WineLook>WIN31_LOOK) &&
1377         (!(ofn->Flags & (OFN_ENABLETEMPLATEHANDLE|OFN_ENABLETEMPLATE))))
1378     {
1379         return GetFileDialog95A(ofn, OPEN_DIALOG);
1380     }
1381     else
1382     {
1383    BOOL16 (CALLBACK * dofunction)(SEGPTR ofn16) = GetOpenFileName16;
1384    return Commdlg_GetFileNameA(dofunction,ofn);
1385 }
1386 }
1387
1388 /***********************************************************************
1389  *            GetOpenFileNameW (COMDLG32.11)
1390  *
1391  * Creates a dialog box for the user to select a file to open.
1392  *
1393  * RETURNS
1394  *    TRUE on succes: user enters a valid file
1395  *    FALSE on cancel, error, close or filename-does-not-fit-in-buffer.
1396  *
1397  * BUGS
1398  *    unknown, calls its 16-bit equivalent.
1399  */
1400 BOOL WINAPI GetOpenFileNameW(
1401                              LPOPENFILENAMEW ofn /* address of init structure */
1402                              )
1403 {
1404     if( (TWEAK_WineLook>WIN31_LOOK) &&
1405         (!(ofn->Flags & (OFN_ENABLETEMPLATEHANDLE|OFN_ENABLETEMPLATE))))
1406     {
1407         return GetFileDialog95W(ofn, OPEN_DIALOG);
1408     }
1409     else
1410     {
1411    BOOL16 (CALLBACK * dofunction)(SEGPTR ofn16) = GetOpenFileName16;
1412    return Commdlg_GetFileNameW(dofunction,ofn);
1413 }
1414 }
1415
1416 /***********************************************************************
1417  *            GetSaveFileNameA  (COMDLG32.12)
1418  *
1419  * Creates a dialog box for the user to select a file to save.
1420  *
1421  * RETURNS
1422  *    TRUE on succes: user enters a valid file
1423  *    FALSE on cancel, error, close or filename-does-not-fit-in-buffer.
1424  *
1425  * BUGS
1426  *    unknown, calls its 16-bit equivalent.
1427  */
1428 BOOL WINAPI GetSaveFileNameA(
1429                              LPOPENFILENAMEA ofn /* address of init structure */
1430                              )
1431 {
1432     if( (TWEAK_WineLook>WIN31_LOOK) &&
1433         (!(ofn->Flags & (OFN_ENABLETEMPLATEHANDLE|OFN_ENABLETEMPLATE))))
1434     {
1435         return GetFileDialog95A(ofn, SAVE_DIALOG);
1436     } else {
1437         BOOL16 (CALLBACK * dofunction)(SEGPTR ofn16) = GetSaveFileName16;
1438         return Commdlg_GetFileNameA(dofunction,ofn);
1439     }
1440 }
1441
1442 /***********************************************************************
1443  *            GetSaveFileNameW  (COMDLG32.13)
1444  *
1445  * Creates a dialog box for the user to select a file to save.
1446  *
1447  * RETURNS
1448  *    TRUE on succes: user enters a valid file
1449  *    FALSE on cancel, error, close or filename-does-not-fit-in-buffer.
1450  *
1451  * BUGS
1452  *    unknown, calls its 16-bit equivalent.
1453  */
1454 BOOL WINAPI GetSaveFileNameW(
1455                              LPOPENFILENAMEW ofn /* address of init structure */
1456                              )
1457 {
1458     if( (TWEAK_WineLook>WIN31_LOOK) &&
1459         (!(ofn->Flags & (OFN_ENABLETEMPLATEHANDLE|OFN_ENABLETEMPLATE))))
1460     {
1461         return GetFileDialog95W(ofn, SAVE_DIALOG);
1462     } else {
1463         BOOL16 (CALLBACK * dofunction)(SEGPTR ofn16) = GetSaveFileName16;
1464         return Commdlg_GetFileNameW(dofunction,ofn);
1465     }
1466 }