src/msw/filedlg.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/msw/filedlg.cpp
   3 // Purpose:     wxFileDialog
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     01/02/97
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart and Markus Holzem
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #ifdef __GNUG__
  21     #pragma implementation "filedlg.h"
  22 #endif
  23
  24 // For compilers that support precompilation, includes "wx.h".
  25 #include "wx/wxprec.h"
  26
  27 #ifdef __BORLANDC__
  28     #pragma hdrstop
  29 #endif
  30
  31 #if wxUSE_FILEDLG
  32
  33 #ifndef WX_PRECOMP
  34     #include "wx/utils.h"
  35     #include "wx/msgdlg.h"
  36     #include "wx/dialog.h"
  37     #include "wx/filedlg.h"
  38     #include "wx/intl.h"
  39     #include "wx/log.h"
  40     #include "wx/app.h"
  41 #endif
  42
  43 #include "wx/msw/private.h"
  44
  45 #if !defined(__WIN32__) || defined(__SALFORDC__) || defined(__WXWINE__)
  46     #include <commdlg.h>
  47 #endif
  48
  49 #include <math.h>
  50 #include <stdlib.h>
  51 #include <string.h>
  52
  53 #include "wx/tokenzr.h"
  54
  55 #ifndef OFN_EXPLORER
  56     #define OFN_EXPLORER 0x00080000
  57 #endif
  58
  59 // ----------------------------------------------------------------------------
  60 // constants
  61 // ----------------------------------------------------------------------------
  62
  63 #ifdef __WIN32__
  64 # define wxMAXPATH   4096
  65 #else
  66 # define wxMAXPATH   1024
  67 #endif
  68
  69 # define wxMAXFILE   1024
  70
  71 # define wxMAXEXT    5
  72
  73 // ============================================================================
  74 // implementation
  75 // ============================================================================
  76
  77 // ----------------------------------------------------------------------------
  78 // wxWin macros
  79 // ----------------------------------------------------------------------------
  80
  81 IMPLEMENT_CLASS(wxFileDialog, wxDialog)
  82
  83 // ----------------------------------------------------------------------------
  84 // global functions
  85 // ----------------------------------------------------------------------------
  86
  87 wxString wxFileSelector(const wxChar *title,
  88                         const wxChar *defaultDir,
  89                         const wxChar *defaultFileName,
  90                         const wxChar *defaultExtension,
  91                         const wxChar *filter,
  92                         int flags,
  93                         wxWindow *parent,
  94                         int x, int y)
  95 {
  96     // In the original implementation, defaultExtension is passed to the
  97     // lpstrDefExt member of OPENFILENAME. This extension, if non-NULL, is
  98     // appended to the filename if the user fails to type an extension. The new
  99     // implementation (taken from wxFileSelectorEx) appends the extension
 100     // automatically, by looking at the filter specification. In fact this
 101     // should be better than the native Microsoft implementation because
 102     // Windows only allows *one* default extension, whereas here we do the
 103     // right thing depending on the filter the user has chosen.
 104
 105     // If there's a default extension specified but no filter, we create a
 106     // suitable filter.
 107
 108     wxString filter2;
 109     if ( defaultExtension && !filter )
 110         filter2 = wxString(wxT("*.")) + defaultExtension;
 111     else if ( filter )
 112         filter2 = filter;
 113
 114     wxString defaultDirString;
 115     if (defaultDir)
 116         defaultDirString = defaultDir;
 117
 118     wxString defaultFilenameString;
 119     if (defaultFileName)
 120         defaultFilenameString = defaultFileName;
 121
 122     wxFileDialog fileDialog(parent, title, defaultDirString,
 123                             defaultFilenameString, filter2,
 124                             flags, wxPoint(x, y));
 125     if( wxStrlen(defaultExtension) != 0 )
 126     {
 127         int filterFind = 0,
 128             filterIndex = 0;
 129
 130         for( unsigned int i = 0; i < filter2.Len(); i++ )
 131         {
 132             if( filter2.GetChar(i) == wxT('|') )
 133             {
 134                 // save the start index of the new filter
 135                 unsigned int is = i++;
 136
 137                 // find the end of the filter
 138                 for( ; i < filter2.Len(); i++ )
 139                 {
 140                     if(filter2[i] == wxT('|'))
 141                         break;
 142                 }
 143
 144                 if( i-is-1 > 0 && is+1 < filter2.Len() )
 145                 {
 146                     if( filter2.Mid(is+1,i-is-1).Contains(defaultExtension) )
 147                     {
 148                         filterFind = filterIndex;
 149                         break;
 150                     }
 151                 }
 152
 153                 filterIndex++;
 154             }
 155         }
 156
 157         fileDialog.SetFilterIndex(filterFind);
 158     }
 159
 160     wxString filename;
 161     if ( fileDialog.ShowModal() == wxID_OK )
 162     {
 163         filename = fileDialog.GetPath();
 164     }
 165
 166     return filename;
 167 }
 168
 169
 170 wxString wxFileSelectorEx(const wxChar *title,
 171                        const wxChar *defaultDir,
 172                        const wxChar *defaultFileName,
 173                        int* defaultFilterIndex,
 174                        const wxChar *filter,
 175                        int       flags,
 176                        wxWindow* parent,
 177                        int       x,
 178                        int       y)
 179
 180 {
 181     wxFileDialog fileDialog(parent,
 182                             title ? title : wxT(""),
 183                             defaultDir ? defaultDir : wxT(""),
 184                             defaultFileName ? defaultFileName : wxT(""),
 185                             filter ? filter : wxT(""),
 186                             flags, wxPoint(x, y));
 187
 188     wxString filename;
 189     if ( fileDialog.ShowModal() == wxID_OK )
 190     {
 191         if ( defaultFilterIndex )
 192             *defaultFilterIndex = fileDialog.GetFilterIndex();
 193
 194         filename = fileDialog.GetPath();
 195     }
 196
 197     return filename;
 198 }
 199
 200 wxFileDialog::wxFileDialog(wxWindow *parent, const wxString& message,
 201         const wxString& defaultDir, const wxString& defaultFileName, const wxString& wildCard,
 202         long style, const wxPoint& WXUNUSED(pos))
 203 {
 204     m_message = message;
 205     m_dialogStyle = style;
 206     if ( ( m_dialogStyle & wxMULTIPLE ) && ( m_dialogStyle & wxSAVE ) )
 207         m_dialogStyle &= ~wxMULTIPLE;
 208     m_parent = parent;
 209     m_path = wxT("");
 210     m_fileName = defaultFileName;
 211     m_dir = defaultDir;
 212     m_wildCard = wildCard;
 213     m_filterIndex = 0;
 214 }
 215
 216 void wxFileDialog::GetPaths(wxArrayString& paths) const
 217 {
 218     paths.Empty();
 219
 220     wxString dir(m_dir);
 221     if ( m_dir.Last() != _T('\\') )
 222         dir += _T('\\');
 223
 224     size_t count = m_fileNames.GetCount();
 225     for ( size_t n = 0; n < count; n++ )
 226     {
 227         paths.Add(dir + m_fileNames[n]);
 228     }
 229 }
 230
 231 int wxFileDialog::ShowModal()
 232 {
 233     HWND hWnd = 0;
 234     if (m_parent) hWnd = (HWND) m_parent->GetHWND();
 235     if (!hWnd && wxTheApp->GetTopWindow())
 236         hWnd = (HWND) wxTheApp->GetTopWindow()->GetHWND();
 237
 238     static wxChar fileNameBuffer [ wxMAXPATH ];           // the file-name
 239     wxChar        titleBuffer    [ wxMAXFILE+1+wxMAXEXT ];  // the file-name, without path
 240
 241     *fileNameBuffer = wxT('\0');
 242     *titleBuffer    = wxT('\0');
 243
 244     long msw_flags = 0;
 245     if ( (m_dialogStyle & wxHIDE_READONLY) || (m_dialogStyle & wxSAVE) )
 246         msw_flags |= OFN_HIDEREADONLY;
 247     if ( m_dialogStyle & wxFILE_MUST_EXIST )
 248         msw_flags |= OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST;
 249
 250     if (m_dialogStyle & wxMULTIPLE )
 251     {
 252         // OFN_EXPLORER must always be specified with OFN_ALLOWMULTISELECT
 253         msw_flags |= OFN_EXPLORER | OFN_ALLOWMULTISELECT;
 254     }
 255
 256     // if wxCHANGE_DIR flag is not given we shouldn't change the CWD which the
 257     // standard dialog does by default
 258     if ( !(m_dialogStyle & wxCHANGE_DIR) )
 259     {
 260         msw_flags |= OFN_NOCHANGEDIR;
 261     }
 262 /* chris elliott for some reason this does not work usefully if no extension
 263    is given, as it test for junk instead of junk.ext
 264     if ( m_dialogStyle & wxOVERWRITE_PROMPT )
 265     {
 266         msw_flags |= OFN_OVERWRITEPROMPT;
 267     }
 268 */
 269     OPENFILENAME of;
 270     wxZeroMemory(of);
 271
 272     // the OPENFILENAME struct has been extended in newer version of
 273     // comcdlg32.dll, but as we don't use the extended fields anyhow, set
 274     // the struct size to the old value - otherwise, the programs compiled
 275     // with new headers will not work with the old libraries
 276 #if defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0500)
 277     of.lStructSize       = sizeof(OPENFILENAME) -
 278                            (sizeof(void *) + 2*sizeof(DWORD));
 279 #else // old headers
 280     of.lStructSize       = sizeof(OPENFILENAME);
 281 #endif
 282
 283     of.hwndOwner         = hWnd;
 284     of.lpstrTitle        = WXSTRINGCAST m_message;
 285     of.lpstrFileTitle    = titleBuffer;
 286     of.nMaxFileTitle     = wxMAXFILE + 1 + wxMAXEXT;    // Windows 3.0 and 3.1
 287
 288     // Convert forward slashes to backslashes (file selector doesn't like
 289     // forward slashes) and also squeeze multiple consecutive slashes into one
 290     // as it doesn't like two backslashes in a row neither
 291
 292     wxString    dir;
 293     size_t      i, len = m_dir.length();
 294     dir.reserve(len);
 295     for ( i = 0; i < len; i++ )
 296     {
 297         wxChar ch = m_dir[i];
 298         switch ( ch )
 299         {
 300             case _T('/'):
 301                 // convert to backslash
 302                 ch = _T('\\');
 303
 304                 // fall through
 305
 306             case _T('\\'):
 307                 while ( i < len - 1 )
 308                 {
 309                     wxChar chNext = m_dir[i + 1];
 310                     if ( chNext != _T('\\') && chNext != _T('/') )
 311                         break;
 312
 313                     // ignore the next one
 314                     i++;
 315                 }
 316                 // fall through
 317
 318             default:
 319                 // normal char
 320                 dir += ch;
 321         }
 322     }
 323
 324     of.lpstrInitialDir   = dir.c_str();
 325
 326     of.Flags             = msw_flags;
 327
 328
 329     //=== Like Alejandro Sierra's wildcard modification >>===================
 330     /*
 331        In wxFileSelector you can put, instead of a single wild_card,
 332        pairs of strings separated by '|'.
 333        The first string is a description, and the
 334        second is the wild card. You can put any number of pairs.
 335
 336        eg.  "description1 (*.ex1)|*.ex1|description2 (*.ex2)|*.ex2"
 337
 338        If you put a single wild card, it works as before the modification.
 339      */
 340     //=======================================================================
 341
 342     wxString theFilter;
 343     if ( wxStrlen(m_wildCard) == 0 )
 344         theFilter = wxString(wxT("*.*"));
 345     else
 346         theFilter = m_wildCard ;
 347     wxString filterBuffer;
 348
 349     if ( !wxStrchr( theFilter, wxT('|') ) ) {    // only one filter ==> default text
 350         filterBuffer.Printf(_("Files (%s)|%s"),
 351                             theFilter.c_str(), theFilter.c_str());
 352     }
 353     else {                                // more then one filter
 354         filterBuffer = theFilter;
 355
 356     }
 357
 358     filterBuffer += wxT("|");
 359     // Replace | with \0
 360     for (i = 0; i < filterBuffer.Len(); i++ ) {
 361         if ( filterBuffer.GetChar(i) == wxT('|') ) {
 362             filterBuffer[i] = wxT('\0');
 363         }
 364     }
 365
 366     of.lpstrFilter  = (LPTSTR)(const wxChar *)filterBuffer;
 367     of.nFilterIndex = m_filterIndex + 1;
 368
 369     //=== Setting defaultFileName >>=========================================
 370
 371     wxStrncpy( fileNameBuffer, (const wxChar *)m_fileName, wxMAXPATH-1 );
 372     fileNameBuffer[ wxMAXPATH-1 ] = wxT('\0');
 373
 374     of.lpstrFile = fileNameBuffer;  // holds returned filename
 375     of.nMaxFile  = wxMAXPATH;
 376
 377     //== Execute FileDialog >>=================================================
 378
 379     bool success = (m_dialogStyle & wxSAVE ? GetSaveFileName(&of)
 380                                            : GetOpenFileName(&of)) != 0;
 381
 382     DWORD errCode = CommDlgExtendedError();
 383
 384 #ifdef __WIN32__
 385     if (!success && (errCode == CDERR_STRUCTSIZE))
 386     {
 387         // The struct size has changed so try a smaller or bigger size
 388
 389         int oldStructSize = of.lStructSize;
 390         of.lStructSize       = oldStructSize - (sizeof(void *) + 2*sizeof(DWORD));
 391         success = (m_dialogStyle & wxSAVE) ? (GetSaveFileName(&of) != 0)
 392                                             : (GetOpenFileName(&of) != 0);
 393         errCode = CommDlgExtendedError();
 394
 395         if (!success && (errCode == CDERR_STRUCTSIZE))
 396         {
 397             of.lStructSize       = oldStructSize + (sizeof(void *) + 2*sizeof(DWORD));
 398             success = (m_dialogStyle & wxSAVE) ? (GetSaveFileName(&of) != 0)
 399                                             : (GetOpenFileName(&of) != 0);
 400         }
 401     }
 402 #endif // __WIN32__
 403
 404     if ( success )
 405     {
 406         m_fileNames.Empty();
 407
 408         if ( ( m_dialogStyle & wxMULTIPLE ) &&
 409 #if defined(OFN_EXPLORER)
 410              ( fileNameBuffer[of.nFileOffset-1] == wxT('\0') ) )
 411 #else
 412              ( fileNameBuffer[of.nFileOffset-1] == wxT(' ') ) )
 413 #endif // OFN_EXPLORER
 414         {
 415 #if defined(OFN_EXPLORER)
 416             m_dir = fileNameBuffer;
 417             i = of.nFileOffset;
 418             m_fileName = &fileNameBuffer[i];
 419             m_fileNames.Add(m_fileName);
 420             i += m_fileName.Len() + 1;
 421
 422             while (fileNameBuffer[i] != wxT('\0'))
 423             {
 424                 m_fileNames.Add(&fileNameBuffer[i]);
 425                 i += wxStrlen(&fileNameBuffer[i]) + 1;
 426             }
 427 #else
 428             wxStringTokenizer toke(fileNameBuffer, _T(" \t\r\n"));
 429             m_dir = toke.GetNextToken();
 430             m_fileName = toke.GetNextToken();
 431             m_fileNames.Add(m_fileName);
 432
 433             while (toke.HasMoreTokens())
 434                 m_fileNames.Add(toke.GetNextToken());
 435 #endif // OFN_EXPLORER
 436
 437             wxString dir(m_dir);
 438             if ( m_dir.Last() != _T('\\') )
 439                 dir += _T('\\');
 440
 441             m_fileNames.Sort();
 442             m_path = dir + m_fileName;
 443         }
 444         else
 445         {
 446             const wxChar* extension = NULL;
 447
 448             //=== Adding the correct extension >>=================================
 449
 450             m_filterIndex = (int)of.nFilterIndex - 1;
 451
 452             if ( !of.nFileExtension ||
 453                  (of.nFileExtension && fileNameBuffer[of.nFileExtension] == wxT('\0')) )
 454             {
 455                 // User has typed a filename without an extension:
 456
 457                 // A filename can end in a "." here ("abc."), this means it
 458                 // does not have an extension. Because later on a "." with
 459                 // the default extension is appended we remove the "." if
 460                 // filename ends with one (We don't want files called
 461                 // "abc..ext")
 462                 int idx = wxStrlen(fileNameBuffer) - 1;
 463                 if ( fileNameBuffer[idx] == wxT('.') )
 464                 {
 465                     fileNameBuffer[idx] = wxT('\0');
 466                 }
 467
 468                 int   maxFilter = (int)(of.nFilterIndex*2L-1L);
 469                 extension = filterBuffer;
 470
 471                 for( int i = 0; i < maxFilter; i++ ) {          // get extension
 472                     extension = extension + wxStrlen( extension ) +1;
 473                 }
 474
 475                 extension = wxStrrchr( extension, wxT('.') );
 476                 if (  extension                                 // != "blabla"
 477                         && !wxStrrchr( extension, wxT('*') )       // != "blabla.*"
 478                         && !wxStrrchr( extension, wxT('?') )       // != "blabla.?"
 479                         && extension[1]                           // != "blabla."
 480                         && extension[1] != wxT(' ') )              // != "blabla. "
 481                 {
 482                     // now concat extension to the fileName:
 483                     m_fileName = wxString(fileNameBuffer) + extension;
 484
 485                     int len = wxStrlen( fileNameBuffer );
 486                     wxStrncpy( fileNameBuffer + len, extension, wxMAXPATH - len );
 487                     fileNameBuffer[ wxMAXPATH -1 ] = wxT('\0');
 488                 }
 489             }
 490
 491             m_path = fileNameBuffer;
 492             m_fileName = wxFileNameFromPath(fileNameBuffer);
 493             m_fileNames.Add(m_fileName);
 494             m_dir = wxPathOnly(fileNameBuffer);
 495         }
 496         //=== Simulating the wxOVERWRITE_PROMPT >>============================
 497         //should we also test for file save style ??
 498         if ( (m_dialogStyle & wxOVERWRITE_PROMPT) &&
 499              ::wxFileExists( fileNameBuffer ) )
 500              {
 501              wxString messageText;
 502              messageText.Printf(_("File '%s' already exists.\nDo you want to replace it?"), fileNameBuffer);
 503              if ( wxMessageBox(messageText, wxT("Save File As"), wxYES_NO | wxICON_EXCLAMATION   ) != wxYES )
 504              {
 505                  success = FALSE;
 506              }
 507         }
 508     }
 509     else
 510     {
 511         // common dialog failed - why?
 512 #ifdef __WXDEBUG__
 513         DWORD dwErr = CommDlgExtendedError();
 514         if ( dwErr != 0 )
 515         {
 516             // this msg is only for developers
 517             wxLogError(wxT("Common dialog failed with error code %0lx."),
 518                        dwErr);
 519         }
 520         //else: it was just cancelled
 521 #endif
 522     }
 523
 524     return success ? wxID_OK : wxID_CANCEL;
 525
 526 }
 527
 528 // Generic file load/save dialog (for internal use only)
 529 static
 530 wxString wxDefaultFileSelector(bool load,
 531                                const wxChar *what,
 532                                const wxChar *extension,
 533                                const wxChar *default_name,
 534                                wxWindow *parent)
 535 {
 536     wxString prompt;
 537     wxString str;
 538     if (load)
 539         str = _("Load %s file");
 540     else
 541         str = _("Save %s file");
 542     prompt.Printf(str, what);
 543
 544     const wxChar *ext = extension;
 545     if (*ext == wxT('.'))
 546         ext++;
 547
 548     wxString wild;
 549     wild.Printf(wxT("*.%s"), ext);
 550
 551     return wxFileSelector(prompt, NULL, default_name, ext, wild,
 552                           load ? wxOPEN : wxSAVE, parent);
 553 }
 554
 555 // Generic file load dialog
 556 WXDLLEXPORT wxString wxLoadFileSelector(const wxChar *what,
 557                                         const wxChar *extension,
 558                                         const wxChar *default_name,
 559                                         wxWindow *parent)
 560 {
 561     return wxDefaultFileSelector(TRUE, what, extension, default_name, parent);
 562 }
 563
 564 // Generic file save dialog
 565 WXDLLEXPORT wxString wxSaveFileSelector(const wxChar *what,
 566                                         const wxChar *extension,
 567                                         const wxChar *default_name,
 568                                         wxWindow *parent)
 569 {
 570     return wxDefaultFileSelector(FALSE, what, extension, default_name, parent);
 571 }
 572
 573 #endif // wxUSE_FILEDLG
 574