reactos/dll/win32/comdlg32/filedlg31.c

   1 /*
   2  * COMMDLG - File Dialogs
   3  *
   4  * Copyright 1994 Martin Ayotte
   5  * Copyright 1996 Albrecht Kleine
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21 #include <ctype.h>
  22 #include <stdlib.h>
  23 #include <stdarg.h>
  24 #include <stdio.h>
  25 #include <string.h>
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winnls.h"
  29 #include "wingdi.h"
  30 #include "winuser.h"
  31 #include "wine/unicode.h"
  32 #include "wine/debug.h"
  33 #include "winreg.h"
  34 #include "winternl.h"
  35 #include "commdlg.h"
  36 #include "shlwapi.h"
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(commdlg);
  39
  40 #include "cdlg.h"
  41 #include "filedlg31.h"
  42
  43 #define BUFFILE 512
  44 #define BUFFILEALLOC 512 * sizeof(WCHAR)
  45
  46 static const WCHAR FILE_star[] = {'*','.','*', 0};
  47 static const WCHAR FILE_bslash[] = {'\\', 0};
  48 static const WCHAR FILE_specc[] = {'%','c',':', 0};
  49 static const int fldrHeight = 16;
  50 static const int fldrWidth = 20;
  51
  52 static HICON hFolder = 0;
  53 static HICON hFolder2 = 0;
  54 static HICON hFloppy = 0;
  55 static HICON hHDisk = 0;
  56 static HICON hCDRom = 0;
  57 static HICON hNet = 0;
  58
  59 /***********************************************************************
  60  *                              FD31_Init                       [internal]
  61  */
  62 BOOL FD31_Init(void)
  63 {
  64     static BOOL initialized = 0;
  65
  66     if (!initialized) {
  67         hFolder  = LoadImageA( COMDLG32_hInstance, "FOLDER", IMAGE_ICON, 16, 16, LR_SHARED );
  68         hFolder2 = LoadImageA( COMDLG32_hInstance, "FOLDER2", IMAGE_ICON, 16, 16, LR_SHARED );
  69         hFloppy  = LoadImageA( COMDLG32_hInstance, "FLOPPY", IMAGE_ICON, 16, 16, LR_SHARED );
  70         hHDisk   = LoadImageA( COMDLG32_hInstance, "HDISK", IMAGE_ICON, 16, 16, LR_SHARED );
  71         hCDRom   = LoadImageA( COMDLG32_hInstance, "CDROM", IMAGE_ICON, 16, 16, LR_SHARED );
  72         hNet     = LoadImageA( COMDLG32_hInstance, "NETWORK", IMAGE_ICON, 16, 16, LR_SHARED );
  73         if (hFolder == 0 || hFolder2 == 0 || hFloppy == 0 ||
  74             hHDisk == 0 || hCDRom == 0 || hNet == 0)
  75         {
  76             ERR("Error loading icons !\n");
  77             return FALSE;
  78         }
  79         initialized = TRUE;
  80     }
  81     return TRUE;
  82 }
  83
  84 /***********************************************************************
  85  *                              FD31_StripEditControl        [internal]
  86  * Strip pathnames off the contents of the edit control.
  87  */
  88 static void FD31_StripEditControl(HWND hwnd)
  89 {
  90     WCHAR temp[BUFFILE], *cp;
  91
  92     GetDlgItemTextW( hwnd, edt1, temp, sizeof(temp)/sizeof(WCHAR));
  93     cp = strrchrW(temp, '\\');
  94     if (cp != NULL) {
  95         strcpyW(temp, cp+1);
  96     }
  97     cp = strrchrW(temp, ':');
  98     if (cp != NULL) {
  99         strcpyW(temp, cp+1);
 100     }
 101     /* FIXME: shouldn't we do something with the result here? ;-) */
 102 }
 103
 104 /***********************************************************************
 105  *                              FD31_CallWindowProc          [internal]
 106  *
 107  *      Call the appropriate hook
 108  */
 109 BOOL FD31_CallWindowProc(const FD31_DATA *lfs, UINT wMsg, WPARAM wParam,
 110                          LPARAM lParam)
 111 {
 112     return lfs->callbacks->CWP(lfs, wMsg, wParam, lParam);
 113 }
 114
 115 /***********************************************************************
 116  *                              FD31_ScanDir                 [internal]
 117  */
 118 static BOOL FD31_ScanDir(HWND hWnd, LPCWSTR newPath)
 119 {
 120     WCHAR               buffer[BUFFILE];
 121     HWND                hdlg, hdlgDir;
 122     LRESULT             lRet = TRUE;
 123     HCURSOR             hCursorWait, oldCursor;
 124
 125     TRACE("Trying to change to %s\n", debugstr_w(newPath));
 126     if  ( newPath[0] && !SetCurrentDirectoryW( newPath ))
 127         return FALSE;
 128     lstrcpynW(buffer, newPath, sizeof(buffer)/sizeof(WCHAR));
 129
 130     /* get the list of spec files */
 131     GetDlgItemTextW(hWnd, edt1, buffer, sizeof(buffer)/sizeof(WCHAR));
 132
 133     hCursorWait = LoadCursorA(0, (LPSTR)IDC_WAIT);
 134     oldCursor = SetCursor(hCursorWait);
 135
 136     /* list of files */
 137     if ((hdlg = GetDlgItem(hWnd, lst1)) != 0) {
 138         WCHAR*  scptr; /* ptr on semi-colon */
 139         WCHAR*  filter = buffer;
 140
 141         TRACE("Using filter %s\n", debugstr_w(filter));
 142         SendMessageW(hdlg, LB_RESETCONTENT, 0, 0);
 143         while (filter) {
 144             scptr = strchrW(filter, ';');
 145             if (scptr)  *scptr = 0;
 146             while (*filter == ' ') filter++;
 147             TRACE("Using file spec %s\n", debugstr_w(filter));
 148             if (SendMessageW(hdlg, LB_DIR, 0, (LPARAM)filter) == LB_ERR)
 149                 return FALSE;
 150             if (scptr) *scptr = ';';
 151                 filter = (scptr) ? (scptr + 1) : 0;
 152          }
 153     }
 154
 155     /* list of directories */
 156     strcpyW(buffer, FILE_star);
 157
 158     if ((hdlgDir = GetDlgItem(hWnd, lst2)) != 0) {
 159         lRet = DlgDirListW(hWnd, buffer, lst2, stc1, DDL_EXCLUSIVE | DDL_DIRECTORY);
 160     }
 161     SetCursor(oldCursor);
 162     return lRet;
 163 }
 164
 165 /***********************************************************************
 166  *                              FD31_GetFileType                [internal]
 167  */
 168
 169 static LPCWSTR FD31_GetFileType(LPCWSTR cfptr, LPCWSTR fptr, const WORD index)
 170 {
 171   int n, i;
 172   i = 0;
 173   if (cfptr)
 174     for ( ;(n = lstrlenW(cfptr)) != 0; i++)
 175       {
 176         cfptr += n + 1;
 177         if (i == index)
 178           return cfptr;
 179         cfptr += lstrlenW(cfptr) + 1;
 180       }
 181   if (fptr)
 182     for ( ;(n = lstrlenW(fptr)) != 0; i++)
 183       {
 184         fptr += n + 1;
 185         if (i == index)
 186           return fptr;
 187         fptr += lstrlenW(fptr) + 1;
 188     }
 189   return FILE_star; /* FIXME */
 190 }
 191
 192 /***********************************************************************
 193  *                              FD31_WMDrawItem              [internal]
 194  */
 195 LONG FD31_WMDrawItem(HWND hWnd, WPARAM wParam, LPARAM lParam,
 196        int savedlg, const DRAWITEMSTRUCT *lpdis)
 197 {
 198     WCHAR *str;
 199     HICON hIcon;
 200     COLORREF oldText = 0, oldBk = 0;
 201
 202     if (lpdis->CtlType == ODT_LISTBOX && lpdis->CtlID == lst1)
 203     {
 204         if (!(str = HeapAlloc(GetProcessHeap(), 0, BUFFILEALLOC))) return FALSE;
 205         SendMessageW(lpdis->hwndItem, LB_GETTEXT, lpdis->itemID,
 206                       (LPARAM)str);
 207
 208         if ((lpdis->itemState & ODS_SELECTED) && !savedlg)
 209         {
 210             oldBk = SetBkColor( lpdis->hDC, GetSysColor( COLOR_HIGHLIGHT ) );
 211             oldText = SetTextColor( lpdis->hDC, GetSysColor(COLOR_HIGHLIGHTTEXT));
 212         }
 213         if (savedlg)
 214             SetTextColor(lpdis->hDC,GetSysColor(COLOR_GRAYTEXT) );
 215
 216         ExtTextOutW(lpdis->hDC, lpdis->rcItem.left + 1,
 217                   lpdis->rcItem.top + 1, ETO_OPAQUE | ETO_CLIPPED,
 218                   &(lpdis->rcItem), str, lstrlenW(str), NULL);
 219
 220         if (lpdis->itemState & ODS_SELECTED)
 221             DrawFocusRect( lpdis->hDC, &(lpdis->rcItem) );
 222
 223         if ((lpdis->itemState & ODS_SELECTED) && !savedlg)
 224         {
 225             SetBkColor( lpdis->hDC, oldBk );
 226             SetTextColor( lpdis->hDC, oldText );
 227         }
 228         HeapFree(GetProcessHeap(), 0, str);
 229         return TRUE;
 230     }
 231
 232     if (lpdis->CtlType == ODT_LISTBOX && lpdis->CtlID == lst2)
 233     {
 234         if (!(str = HeapAlloc(GetProcessHeap(), 0, BUFFILEALLOC)))
 235             return FALSE;
 236         SendMessageW(lpdis->hwndItem, LB_GETTEXT, lpdis->itemID,
 237                       (LPARAM)str);
 238
 239         if (lpdis->itemState & ODS_SELECTED)
 240         {
 241             oldBk = SetBkColor( lpdis->hDC, GetSysColor( COLOR_HIGHLIGHT ) );
 242             oldText = SetTextColor( lpdis->hDC, GetSysColor(COLOR_HIGHLIGHTTEXT));
 243         }
 244         ExtTextOutW(lpdis->hDC, lpdis->rcItem.left + fldrWidth,
 245                   lpdis->rcItem.top + 1, ETO_OPAQUE | ETO_CLIPPED,
 246                   &(lpdis->rcItem), str, lstrlenW(str), NULL);
 247
 248         if (lpdis->itemState & ODS_SELECTED)
 249             DrawFocusRect( lpdis->hDC, &(lpdis->rcItem) );
 250
 251         if (lpdis->itemState & ODS_SELECTED)
 252         {
 253             SetBkColor( lpdis->hDC, oldBk );
 254             SetTextColor( lpdis->hDC, oldText );
 255         }
 256         DrawIcon(lpdis->hDC, lpdis->rcItem.left, lpdis->rcItem.top, hFolder);
 257         HeapFree(GetProcessHeap(), 0, str);
 258         return TRUE;
 259     }
 260     if (lpdis->CtlType == ODT_COMBOBOX && lpdis->CtlID == cmb2)
 261     {
 262         char root[] = "a:";
 263         if (!(str = HeapAlloc(GetProcessHeap(), 0, BUFFILEALLOC)))
 264             return FALSE;
 265         SendMessageW(lpdis->hwndItem, CB_GETLBTEXT, lpdis->itemID,
 266                       (LPARAM)str);
 267         root[0] += str[2] - 'a';
 268         switch(GetDriveTypeA(root))
 269         {
 270         case DRIVE_REMOVABLE: hIcon = hFloppy; break;
 271         case DRIVE_CDROM:     hIcon = hCDRom; break;
 272         case DRIVE_REMOTE:    hIcon = hNet; break;
 273         case DRIVE_FIXED:
 274         default:           hIcon = hHDisk; break;
 275         }
 276         if (lpdis->itemState & ODS_SELECTED)
 277         {
 278             oldBk = SetBkColor( lpdis->hDC, GetSysColor( COLOR_HIGHLIGHT ) );
 279             oldText = SetTextColor( lpdis->hDC, GetSysColor(COLOR_HIGHLIGHTTEXT));
 280         }
 281         ExtTextOutW(lpdis->hDC, lpdis->rcItem.left + fldrWidth,
 282                   lpdis->rcItem.top + 1, ETO_OPAQUE | ETO_CLIPPED,
 283                   &(lpdis->rcItem), str, lstrlenW(str), NULL);
 284
 285         if (lpdis->itemState & ODS_SELECTED)
 286         {
 287             SetBkColor( lpdis->hDC, oldBk );
 288             SetTextColor( lpdis->hDC, oldText );
 289         }
 290         DrawIcon(lpdis->hDC, lpdis->rcItem.left, lpdis->rcItem.top, hIcon);
 291         HeapFree(GetProcessHeap(), 0, str);
 292         return TRUE;
 293     }
 294     return FALSE;
 295 }
 296
 297 /***********************************************************************
 298  *                              FD31_UpdateResult            [internal]
 299  *      update the displayed file name (with path)
 300  */
 301 static void FD31_UpdateResult(const FD31_DATA *lfs, const WCHAR *tmpstr)
 302 {
 303     int lenstr2;
 304     LPOPENFILENAMEW ofnW = lfs->ofnW;
 305     WCHAR tmpstr2[BUFFILE];
 306     WCHAR *p;
 307
 308     TRACE("%s\n", debugstr_w(tmpstr));
 309     if(ofnW->Flags & OFN_NOVALIDATE)
 310         tmpstr2[0] = '\0';
 311     else
 312         GetCurrentDirectoryW(BUFFILE, tmpstr2);
 313     lenstr2 = strlenW(tmpstr2);
 314     if (lenstr2 > 3)
 315         tmpstr2[lenstr2++]='\\';
 316     lstrcpynW(tmpstr2+lenstr2, tmpstr, BUFFILE-lenstr2);
 317     if (ofnW->lpstrFile)
 318         lstrcpynW(ofnW->lpstrFile, tmpstr2, ofnW->nMaxFile);
 319
 320     /* set filename offset */
 321     p = PathFindFileNameW(ofnW->lpstrFile);
 322     ofnW->nFileOffset = (p - ofnW->lpstrFile);
 323
 324     /* set extension offset */
 325     p = PathFindExtensionW(ofnW->lpstrFile);
 326     ofnW->nFileExtension = (*p) ? (p - ofnW->lpstrFile) + 1 : 0;
 327
 328     TRACE("file %s, file offset %d, ext offset %d\n",
 329           debugstr_w(ofnW->lpstrFile), ofnW->nFileOffset, ofnW->nFileExtension);
 330
 331     /* update the real client structures if any */
 332     lfs->callbacks->UpdateResult(lfs);
 333 }
 334
 335 /***********************************************************************
 336  *                              FD31_UpdateFileTitle         [internal]
 337  *      update the displayed file name (without path)
 338  */
 339 static void FD31_UpdateFileTitle(const FD31_DATA *lfs)
 340 {
 341   LONG lRet;
 342   LPOPENFILENAMEW ofnW = lfs->ofnW;
 343   if (ofnW->lpstrFileTitle != NULL)
 344   {
 345     lRet = SendDlgItemMessageW(lfs->hwnd, lst1, LB_GETCURSEL, 0, 0);
 346     SendDlgItemMessageW(lfs->hwnd, lst1, LB_GETTEXT, lRet,
 347                              (LPARAM)ofnW->lpstrFileTitle );
 348     lfs->callbacks->UpdateFileTitle(lfs);
 349   }
 350 }
 351
 352 /***********************************************************************
 353  *                              FD31_DirListDblClick         [internal]
 354  */
 355 static LRESULT FD31_DirListDblClick( const FD31_DATA *lfs )
 356 {
 357   LONG lRet;
 358   HWND hWnd = lfs->hwnd;
 359   LPWSTR pstr;
 360   WCHAR tmpstr[BUFFILE];
 361
 362   /* get the raw string (with brackets) */
 363   lRet = SendDlgItemMessageW(hWnd, lst2, LB_GETCURSEL, 0, 0);
 364   if (lRet == LB_ERR) return TRUE;
 365   pstr = HeapAlloc(GetProcessHeap(), 0, BUFFILEALLOC);
 366   SendDlgItemMessageW(hWnd, lst2, LB_GETTEXT, lRet,
 367                      (LPARAM)pstr);
 368   strcpyW( tmpstr, pstr );
 369   HeapFree(GetProcessHeap(), 0, pstr);
 370   /* get the selected directory in tmpstr */
 371   if (tmpstr[0] == '[')
 372     {
 373       tmpstr[lstrlenW(tmpstr) - 1] = 0;
 374       strcpyW(tmpstr,tmpstr+1);
 375     }
 376   strcatW(tmpstr, FILE_bslash);
 377
 378   FD31_ScanDir(hWnd, tmpstr);
 379   /* notify the app */
 380   if (lfs->hook)
 381     {
 382       if (FD31_CallWindowProc(lfs, lfs->lbselchstring, lst2,
 383               MAKELONG(lRet,CD_LBSELCHANGE)))
 384         return TRUE;
 385     }
 386   return TRUE;
 387 }
 388
 389 /***********************************************************************
 390  *                              FD31_FileListSelect         [internal]
 391  *    called when a new item is picked in the file list
 392  */
 393 static LRESULT FD31_FileListSelect( const FD31_DATA *lfs )
 394 {
 395     LONG lRet;
 396     HWND hWnd = lfs->hwnd;
 397     LPWSTR pstr;
 398
 399     lRet = lfs->callbacks->SendLbGetCurSel(lfs);
 400     if (lRet == LB_ERR)
 401         return TRUE;
 402
 403     /* set the edit control to the choosen file */
 404     if ((pstr = HeapAlloc(GetProcessHeap(), 0, BUFFILEALLOC)))
 405     {
 406         SendDlgItemMessageW(hWnd, lst1, LB_GETTEXT, lRet,
 407                        (LPARAM)pstr);
 408         SetDlgItemTextW( hWnd, edt1, pstr );
 409         HeapFree(GetProcessHeap(), 0, pstr);
 410     }
 411     if (lfs->hook)
 412     {
 413         FD31_CallWindowProc(lfs, lfs->lbselchstring, lst1,
 414                            MAKELONG(lRet,CD_LBSELCHANGE));
 415     }
 416     /* FIXME: for OFN_ALLOWMULTISELECT we need CD_LBSELSUB, CD_SELADD,
 417            CD_LBSELNOITEMS */
 418     return TRUE;
 419 }
 420
 421 /***********************************************************************
 422  *                              FD31_TestPath      [internal]
 423  *      before accepting the file name, test if it includes wild cards
 424  *      tries to scan the directory and returns TRUE if no error.
 425  */
 426 static LRESULT FD31_TestPath( const FD31_DATA *lfs, LPWSTR path )
 427 {
 428     HWND hWnd = lfs->hwnd;
 429     LPWSTR pBeginFileName, pstr2;
 430     WCHAR tmpstr2[BUFFILE];
 431
 432     pBeginFileName = strrchrW(path, '\\');
 433     if (pBeginFileName == NULL)
 434         pBeginFileName = strrchrW(path, ':');
 435
 436     if (strchrW(path,'*') != NULL || strchrW(path,'?') != NULL)
 437     {
 438         /* edit control contains wildcards */
 439         if (pBeginFileName != NULL)
 440         {
 441             lstrcpynW(tmpstr2, pBeginFileName + 1, BUFFILE);
 442             *(pBeginFileName + 1) = 0;
 443         }
 444         else
 445         {
 446             strcpyW(tmpstr2, path);
 447             if(!(lfs->ofnW->Flags & OFN_NOVALIDATE))
 448                 *path = 0;
 449         }
 450
 451         TRACE("path=%s, tmpstr2=%s\n", debugstr_w(path), debugstr_w(tmpstr2));
 452         SetDlgItemTextW( hWnd, edt1, tmpstr2 );
 453         FD31_ScanDir(hWnd, path);
 454         return (lfs->ofnW->Flags & OFN_NOVALIDATE) ? TRUE : FALSE;
 455     }
 456
 457     /* no wildcards, we might have a directory or a filename */
 458     /* try appending a wildcard and reading the directory */
 459
 460     pstr2 = path + lstrlenW(path);
 461     if (pBeginFileName == NULL || *(pBeginFileName + 1) != 0)
 462         strcatW(path, FILE_bslash);
 463
 464     /* if ScanDir succeeds, we have changed the directory */
 465     if (FD31_ScanDir(hWnd, path))
 466         return FALSE; /* and path is not a valid file name */
 467
 468     /* if not, this must be a filename */
 469
 470     *pstr2 = 0; /* remove the wildcard added before */
 471
 472     if (pBeginFileName != NULL)
 473     {
 474         /* strip off the pathname */
 475         *pBeginFileName = 0;
 476         SetDlgItemTextW( hWnd, edt1, pBeginFileName + 1 );
 477
 478         lstrcpynW(tmpstr2, pBeginFileName + 1, sizeof(tmpstr2)/sizeof(WCHAR) );
 479         /* Should we MessageBox() if this fails? */
 480         if (!FD31_ScanDir(hWnd, path))
 481         {
 482             return FALSE;
 483         }
 484         strcpyW(path, tmpstr2);
 485     }
 486     else
 487         SetDlgItemTextW( hWnd, edt1, path );
 488     return TRUE;
 489 }
 490
 491 /***********************************************************************
 492  *                              FD31_Validate               [internal]
 493  *   called on: click Ok button, Enter in edit, DoubleClick in file list
 494  */
 495 static LRESULT FD31_Validate( const FD31_DATA *lfs, LPCWSTR path, UINT control, INT itemIndex,
 496                                  BOOL internalUse )
 497 {
 498     LONG lRet;
 499     HWND hWnd = lfs->hwnd;
 500     OPENFILENAMEW ofnsav;
 501     LPOPENFILENAMEW ofnW = lfs->ofnW;
 502     WCHAR filename[BUFFILE];
 503
 504     ofnsav = *ofnW; /* for later restoring */
 505
 506     /* get current file name */
 507     if (path)
 508         lstrcpynW(filename, path, sizeof(filename)/sizeof(WCHAR));
 509     else
 510         GetDlgItemTextW( hWnd, edt1, filename, sizeof(filename)/sizeof(WCHAR));
 511
 512     TRACE("got filename = %s\n", debugstr_w(filename));
 513     /* if we did not click in file list to get there */
 514     if (control != lst1)
 515     {
 516         if (!FD31_TestPath( lfs, filename) )
 517            return FALSE;
 518     }
 519     FD31_UpdateResult(lfs, filename);
 520
 521     if (internalUse)
 522     { /* called internally after a change in a combo */
 523         if (lfs->hook)
 524         {
 525              FD31_CallWindowProc(lfs, lfs->lbselchstring, control,
 526                              MAKELONG(itemIndex,CD_LBSELCHANGE));
 527         }
 528         return TRUE;
 529     }
 530
 531     FD31_UpdateFileTitle(lfs);
 532     if (lfs->hook)
 533     {
 534         lRet = (BOOL)FD31_CallWindowProc(lfs, lfs->fileokstring,
 535                   0, lfs->lParam );
 536         if (lRet)
 537         {
 538             *ofnW = ofnsav; /* restore old state */
 539             return FALSE;
 540         }
 541     }
 542     if ((ofnW->Flags & OFN_ALLOWMULTISELECT) && (ofnW->Flags & OFN_EXPLORER))
 543     {
 544         if (ofnW->lpstrFile)
 545         {
 546             LPWSTR str = (LPWSTR)ofnW->lpstrFile;
 547             LPWSTR ptr = strrchrW(str, '\\');
 548             str[lstrlenW(str) + 1] = '\0';
 549             *ptr = 0;
 550         }
 551     }
 552     return TRUE;
 553 }
 554
 555 /***********************************************************************
 556  *                              FD31_DiskChange             [internal]
 557  *    called when a new item is picked in the disk selection combo
 558  */
 559 static LRESULT FD31_DiskChange( const FD31_DATA *lfs )
 560 {
 561     LONG lRet;
 562     HWND hWnd = lfs->hwnd;
 563     LPWSTR pstr;
 564     WCHAR diskname[BUFFILE];
 565
 566     FD31_StripEditControl(hWnd);
 567     lRet = SendDlgItemMessageW(hWnd, cmb2, CB_GETCURSEL, 0, 0L);
 568     if (lRet == LB_ERR)
 569         return 0;
 570     pstr = HeapAlloc(GetProcessHeap(), 0, BUFFILEALLOC);
 571     SendDlgItemMessageW(hWnd, cmb2, CB_GETLBTEXT, lRet,
 572                          (LPARAM)pstr);
 573     wsprintfW(diskname, FILE_specc, pstr[2]);
 574     HeapFree(GetProcessHeap(), 0, pstr);
 575
 576     return FD31_Validate( lfs, diskname, cmb2, lRet, TRUE );
 577 }
 578
 579 /***********************************************************************
 580  *                              FD31_FileTypeChange         [internal]
 581  *    called when a new item is picked in the file type combo
 582  */
 583 static LRESULT FD31_FileTypeChange( const FD31_DATA *lfs )
 584 {
 585     LONG lRet;
 586     LPWSTR pstr;
 587
 588     lRet = SendDlgItemMessageW(lfs->hwnd, cmb1, CB_GETCURSEL, 0, 0);
 589     if (lRet == LB_ERR)
 590         return TRUE;
 591     pstr = (LPWSTR)SendDlgItemMessageW(lfs->hwnd, cmb1, CB_GETITEMDATA, lRet, 0);
 592     TRACE("Selected filter : %s\n", debugstr_w(pstr));
 593     SetDlgItemTextW( lfs->hwnd, edt1, pstr );
 594
 595     return FD31_Validate( lfs, NULL, cmb1, lRet, TRUE );
 596 }
 597
 598 /***********************************************************************
 599  *                              FD31_WMCommand               [internal]
 600  */
 601 LRESULT FD31_WMCommand(HWND hWnd, LPARAM lParam, UINT notification,
 602        UINT control, const FD31_DATA *lfs )
 603 {
 604     switch (control)
 605     {
 606         case lst1: /* file list */
 607         FD31_StripEditControl(hWnd);
 608         if (notification == LBN_DBLCLK)
 609         {
 610             return SendMessageW(hWnd, WM_COMMAND, IDOK, 0);
 611         }
 612         else if (notification == LBN_SELCHANGE)
 613             return FD31_FileListSelect( lfs );
 614         break;
 615
 616         case lst2: /* directory list */
 617         FD31_StripEditControl(hWnd);
 618         if (notification == LBN_DBLCLK)
 619             return FD31_DirListDblClick( lfs );
 620         break;
 621
 622         case cmb1: /* file type drop list */
 623         if (notification == CBN_SELCHANGE)
 624             return FD31_FileTypeChange( lfs );
 625         break;
 626
 627         case chx1:
 628         break;
 629
 630         case pshHelp:
 631         break;
 632
 633         case cmb2: /* disk dropdown combo */
 634         if (notification == CBN_SELCHANGE)
 635             return FD31_DiskChange( lfs );
 636         break;
 637
 638         case IDOK:
 639         TRACE("OK pressed\n");
 640         if (FD31_Validate( lfs, NULL, control, 0, FALSE ))
 641             EndDialog(hWnd, TRUE);
 642         return TRUE;
 643
 644         case IDCANCEL:
 645         EndDialog(hWnd, FALSE);
 646         return TRUE;
 647
 648         case IDABORT: /* can be sent by the hook procedure */
 649         EndDialog(hWnd, TRUE);
 650         return TRUE;
 651     }
 652     return FALSE;
 653 }
 654
 655 /************************************************************************
 656  *                              FD31_MapStringPairsToW       [internal]
 657  *      map string pairs to Unicode
 658  */
 659 static LPWSTR FD31_MapStringPairsToW(LPCSTR strA, UINT size)
 660 {
 661     LPCSTR s;
 662     LPWSTR x;
 663     unsigned int n, len;
 664
 665     s = strA;
 666     while (*s)
 667         s = s+strlen(s)+1;
 668     s++;
 669     n = s + 1 - strA; /* Don't forget the other \0 */
 670     if (n < size) n = size;
 671
 672     len = MultiByteToWideChar( CP_ACP, 0, strA, n, NULL, 0 );
 673     x = HeapAlloc(GetProcessHeap(),0, len * sizeof(WCHAR));
 674     MultiByteToWideChar( CP_ACP, 0, strA, n, x, len );
 675     return x;
 676 }
 677
 678
 679 /************************************************************************
 680  *                              FD31_DupToW                  [internal]
 681  *      duplicates an Ansi string to unicode, with a buffer size
 682  */
 683 static LPWSTR FD31_DupToW(LPCSTR str, DWORD size)
 684 {
 685     LPWSTR strW = NULL;
 686     if (str && (size > 0))
 687     {
 688         strW = HeapAlloc(GetProcessHeap(), 0, size * sizeof(WCHAR));
 689         if (strW) MultiByteToWideChar( CP_ACP, 0, str, -1, strW, size );
 690     }
 691     return strW;
 692 }
 693
 694 /************************************************************************
 695  *                              FD31_MapOfnStructA          [internal]
 696  *      map a 32 bits Ansi structure to an Unicode one
 697  */
 698 void FD31_MapOfnStructA(const OPENFILENAMEA *ofnA, LPOPENFILENAMEW ofnW, BOOL open)
 699 {
 700     UNICODE_STRING usBuffer;
 701
 702     ofnW->lStructSize = sizeof(OPENFILENAMEW);
 703     ofnW->hwndOwner = ofnA->hwndOwner;
 704     ofnW->hInstance = ofnA->hInstance;
 705     if (ofnA->lpstrFilter)
 706         ofnW->lpstrFilter = FD31_MapStringPairsToW(ofnA->lpstrFilter, 0);
 707
 708     if ((ofnA->lpstrCustomFilter) && (*(ofnA->lpstrCustomFilter)))
 709         ofnW->lpstrCustomFilter = FD31_MapStringPairsToW(ofnA->lpstrCustomFilter, ofnA->nMaxCustFilter);
 710     ofnW->nMaxCustFilter = ofnA->nMaxCustFilter;
 711     ofnW->nFilterIndex = ofnA->nFilterIndex;
 712     ofnW->nMaxFile = ofnA->nMaxFile;
 713     ofnW->lpstrFile = FD31_DupToW(ofnA->lpstrFile, ofnW->nMaxFile);
 714     ofnW->nMaxFileTitle = ofnA->nMaxFileTitle;
 715     ofnW->lpstrFileTitle = FD31_DupToW(ofnA->lpstrFileTitle, ofnW->nMaxFileTitle);
 716     if (ofnA->lpstrInitialDir)
 717     {
 718         RtlCreateUnicodeStringFromAsciiz (&usBuffer,ofnA->lpstrInitialDir);
 719         ofnW->lpstrInitialDir = usBuffer.Buffer;
 720     }
 721     if (ofnA->lpstrTitle) {
 722         RtlCreateUnicodeStringFromAsciiz (&usBuffer, ofnA->lpstrTitle);
 723         ofnW->lpstrTitle = usBuffer.Buffer;
 724     } else {
 725         WCHAR buf[16];
 726         LPWSTR title_tmp;
 727         int len;
 728         LoadStringW(COMDLG32_hInstance, open ? IDS_OPEN_FILE : IDS_SAVE_AS,
 729                     buf, sizeof(buf)/sizeof(WCHAR));
 730         len = lstrlenW(buf)+1;
 731         title_tmp = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
 732         memcpy(title_tmp, buf, len * sizeof(WCHAR));
 733         ofnW->lpstrTitle = title_tmp;
 734     }
 735     ofnW->Flags = ofnA->Flags;
 736     ofnW->nFileOffset = ofnA->nFileOffset;
 737     ofnW->nFileExtension = ofnA->nFileExtension;
 738     ofnW->lpstrDefExt = FD31_DupToW(ofnA->lpstrDefExt, 3);
 739     if ((ofnA->Flags & OFN_ENABLETEMPLATE) && (ofnA->lpTemplateName))
 740     {
 741         if (HIWORD(ofnA->lpTemplateName))
 742         {
 743             RtlCreateUnicodeStringFromAsciiz (&usBuffer,ofnA->lpTemplateName);
 744             ofnW->lpTemplateName = usBuffer.Buffer;
 745         }
 746         else /* numbered resource */
 747             ofnW->lpTemplateName = (LPCWSTR) ofnA->lpTemplateName;
 748     }
 749 }
 750
 751
 752 /************************************************************************
 753  *                              FD31_FreeOfnW          [internal]
 754  *      Undo all allocations done by FD31_MapOfnStructA
 755  */
 756 void FD31_FreeOfnW(OPENFILENAMEW *ofnW)
 757 {
 758    HeapFree(GetProcessHeap(), 0, (LPWSTR) ofnW->lpstrFilter);
 759    HeapFree(GetProcessHeap(), 0, ofnW->lpstrCustomFilter);
 760    HeapFree(GetProcessHeap(), 0, ofnW->lpstrFile);
 761    HeapFree(GetProcessHeap(), 0, ofnW->lpstrFileTitle);
 762    HeapFree(GetProcessHeap(), 0, (LPWSTR) ofnW->lpstrInitialDir);
 763    HeapFree(GetProcessHeap(), 0, (LPWSTR) ofnW->lpstrTitle);
 764    if (HIWORD(ofnW->lpTemplateName))
 765        HeapFree(GetProcessHeap(), 0, (LPWSTR) ofnW->lpTemplateName);
 766 }
 767
 768 /************************************************************************
 769  *                              FD31_DestroyPrivate            [internal]
 770  *      destroys the private object
 771  */
 772 void FD31_DestroyPrivate(PFD31_DATA lfs)
 773 {
 774     HWND hwnd;
 775     if (!lfs) return;
 776     hwnd = lfs->hwnd;
 777     TRACE("destroying private allocation %p\n", lfs);
 778     lfs->callbacks->Destroy(lfs);
 779     HeapFree(GetProcessHeap(), 0, lfs);
 780     RemovePropA(hwnd, FD31_OFN_PROP);
 781 }
 782
 783 /************************************************************************
 784  *                              FD31_AllocPrivate            [internal]
 785  *      allocate a private object to hold 32 bits Unicode
 786  *      structure that will be used throughout the calls, while
 787  *      keeping available the original structures and a few variables
 788  *      On entry : type = dialog procedure type (16,32A,32W)
 789  *                 dlgType = dialog type (open or save)
 790  */
 791 PFD31_DATA FD31_AllocPrivate(LPARAM lParam, UINT dlgType,
 792                              PFD31_CALLBACKS callbacks, DWORD data)
 793 {
 794     PFD31_DATA lfs = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(FD31_DATA));
 795
 796     TRACE("alloc private buf %p\n", lfs);
 797     if (!lfs) return NULL;
 798     lfs->hook = FALSE;
 799     lfs->lParam = lParam;
 800     lfs->open = (dlgType == OPEN_DIALOG);
 801     lfs->callbacks = callbacks;
 802     if (! lfs->callbacks->Init(lParam, lfs, data))
 803     {
 804         FD31_DestroyPrivate(lfs);
 805         return NULL;
 806     }
 807     lfs->lbselchstring = RegisterWindowMessageA(LBSELCHSTRINGA);
 808     lfs->fileokstring = RegisterWindowMessageA(FILEOKSTRINGA);
 809
 810     return lfs;
 811 }
 812
 813 /***********************************************************************
 814  *                              FD31_WMInitDialog            [internal]
 815  */
 816
 817 LONG FD31_WMInitDialog(HWND hWnd, WPARAM wParam, LPARAM lParam)
 818 {
 819   int i, n;
 820   WCHAR tmpstr[BUFFILE];
 821   LPWSTR pstr, old_pstr;
 822   LPOPENFILENAMEW ofn;
 823   PFD31_DATA lfs = (PFD31_DATA) lParam;
 824
 825   if (!lfs) return FALSE;
 826   SetPropA(hWnd, FD31_OFN_PROP, (HANDLE)lfs);
 827   lfs->hwnd = hWnd;
 828   ofn = lfs->ofnW;
 829
 830   TRACE("flags=%x initialdir=%s\n", ofn->Flags, debugstr_w(ofn->lpstrInitialDir));
 831
 832   SetWindowTextW( hWnd, ofn->lpstrTitle );
 833   /* read custom filter information */
 834   if (ofn->lpstrCustomFilter)
 835     {
 836       pstr = ofn->lpstrCustomFilter;
 837       n = 0;
 838       TRACE("lpstrCustomFilter = %p\n", pstr);
 839       while(*pstr)
 840         {
 841           old_pstr = pstr;
 842           i = SendDlgItemMessageW(hWnd, cmb1, CB_ADDSTRING, 0,
 843                                    (LPARAM)(ofn->lpstrCustomFilter) + n );
 844           n += lstrlenW(pstr) + 1;
 845           pstr += lstrlenW(pstr) + 1;
 846           TRACE("add str=%s associated to %s\n",
 847                 debugstr_w(old_pstr), debugstr_w(pstr));
 848           SendDlgItemMessageW(hWnd, cmb1, CB_SETITEMDATA, i, (LPARAM)pstr);
 849           n += lstrlenW(pstr) + 1;
 850           pstr += lstrlenW(pstr) + 1;
 851         }
 852     }
 853   /* read filter information */
 854   if (ofn->lpstrFilter) {
 855         pstr = (LPWSTR) ofn->lpstrFilter;
 856         n = 0;
 857         while(*pstr) {
 858           old_pstr = pstr;
 859           i = SendDlgItemMessageW(hWnd, cmb1, CB_ADDSTRING, 0,
 860                                        (LPARAM)(ofn->lpstrFilter + n) );
 861           n += lstrlenW(pstr) + 1;
 862           pstr += lstrlenW(pstr) + 1;
 863           TRACE("add str=%s associated to %s\n",
 864                 debugstr_w(old_pstr), debugstr_w(pstr));
 865           SendDlgItemMessageW(hWnd, cmb1, CB_SETITEMDATA, i, (LPARAM)pstr);
 866           n += lstrlenW(pstr) + 1;
 867           pstr += lstrlenW(pstr) + 1;
 868         }
 869   }
 870   /* set default filter */
 871   if (ofn->nFilterIndex == 0 && ofn->lpstrCustomFilter == NULL)
 872         ofn->nFilterIndex = 1;
 873   SendDlgItemMessageW(hWnd, cmb1, CB_SETCURSEL, ofn->nFilterIndex - 1, 0);
 874   lstrcpynW(tmpstr, FD31_GetFileType(ofn->lpstrCustomFilter,
 875              ofn->lpstrFilter, ofn->nFilterIndex - 1),BUFFILE);
 876   TRACE("nFilterIndex = %d, SetText of edt1 to %s\n",
 877                         ofn->nFilterIndex, debugstr_w(tmpstr));
 878   SetDlgItemTextW( hWnd, edt1, tmpstr );
 879   /* get drive list */
 880   *tmpstr = 0;
 881   DlgDirListComboBoxW(hWnd, tmpstr, cmb2, 0, DDL_DRIVES | DDL_EXCLUSIVE);
 882   /* read initial directory */
 883   /* FIXME: Note that this is now very version-specific (See MSDN description of
 884    * the OPENFILENAME structure).  For example under 2000/XP any path in the
 885    * lpstrFile overrides the lpstrInitialDir, but not under 95/98/ME
 886    */
 887   if (ofn->lpstrInitialDir != NULL)
 888     {
 889       int len;
 890       lstrcpynW(tmpstr, ofn->lpstrInitialDir, 511);
 891       len = lstrlenW(tmpstr);
 892       if (len > 0 && tmpstr[len-1] != '\\'  && tmpstr[len-1] != ':') {
 893         tmpstr[len]='\\';
 894         tmpstr[len+1]='\0';
 895       }
 896     }
 897   else
 898     *tmpstr = 0;
 899   if (!FD31_ScanDir(hWnd, tmpstr)) {
 900     *tmpstr = 0;
 901     if (!FD31_ScanDir(hWnd, tmpstr))
 902       WARN("Couldn't read initial directory %s!\n", debugstr_w(tmpstr));
 903   }
 904   /* select current drive in combo 2, omit missing drives */
 905   {
 906       char dir[MAX_PATH];
 907       char str[4] = "a:\\";
 908       GetCurrentDirectoryA( sizeof(dir), dir );
 909       for(i = 0, n = -1; i < 26; i++)
 910       {
 911           str[0] = 'a' + i;
 912           if (GetDriveTypeA(str) > DRIVE_NO_ROOT_DIR) n++;
 913           if (toupper(str[0]) == toupper(dir[0])) break;
 914       }
 915   }
 916   SendDlgItemMessageW(hWnd, cmb2, CB_SETCURSEL, n, 0);
 917   if (!(ofn->Flags & OFN_SHOWHELP))
 918     ShowWindow(GetDlgItem(hWnd, pshHelp), SW_HIDE);
 919   if (ofn->Flags & OFN_HIDEREADONLY)
 920     ShowWindow(GetDlgItem(hWnd, chx1), SW_HIDE);
 921   if (lfs->hook)
 922       return (BOOL) FD31_CallWindowProc(lfs, WM_INITDIALOG, wParam, lfs->lParam);
 923   return TRUE;
 924 }
 925
 926 int FD31_GetFldrHeight(void)
 927 {
 928   return fldrHeight;
 929 }