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
 263     if ( m_dialogStyle & wxOVERWRITE_PROMPT )
 264     {
 265         msw_flags |= OFN_OVERWRITEPROMPT;
 266     }
 267
 268     OPENFILENAME of;
 269     wxZeroMemory(of);
 270
 271     // the OPENFILENAME struct has been extended in newer version of
 272     // comcdlg32.dll, but as we don't use the extended fields anyhow, set
 273     // the struct size to the old value - otherwise, the programs compiled
 274     // with new headers will not work with the old libraries
 275 #if defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0500)
 276     of.lStructSize       = sizeof(OPENFILENAME) -
 277                            (sizeof(void *) + 2*sizeof(DWORD));
 278 #else // old headers
 279     of.lStructSize       = sizeof(OPENFILENAME);
 280 #endif
 281
 282     of.hwndOwner         = hWnd;
 283     of.lpstrTitle        = WXSTRINGCAST m_message;
 284     of.lpstrFileTitle    = titleBuffer;
 285     of.nMaxFileTitle     = wxMAXFILE + 1 + wxMAXEXT;    // Windows 3.0 and 3.1
 286
 287     // Convert forward slashes to backslashes (file selector doesn't like
 288     // forward slashes) and also squeeze multiple consecutive slashes into one
 289     // as it doesn't like two backslashes in a row neither
 290
 291     wxString    dir;
 292     size_t      i, len = m_dir.length();
 293     dir.reserve(len);
 294     for ( i = 0; i < len; i++ )
 295     {
 296         wxChar ch = m_dir[i];
 297         switch ( ch )
 298         {
 299             case _T('/'):
 300                 // convert to backslash
 301                 ch = _T('\\');
 302
 303                 // fall through
 304
 305             case _T('\\'):
 306                 while ( i < len - 1 )
 307                 {
 308                     wxChar chNext = m_dir[i + 1];
 309                     if ( chNext != _T('\\') && chNext != _T('/') )
 310                         break;
 311
 312                     // ignore the next one
 313                     i++;
 314                 }
 315                 // fall through
 316
 317             default:
 318                 // normal char
 319                 dir += ch;
 320         }
 321     }
 322
 323     of.lpstrInitialDir   = dir.c_str();
 324
 325     of.Flags             = msw_flags;
 326
 327
 328     //=== Like Alejandro Sierra's wildcard modification >>===================
 329     /*
 330        In wxFileSelector you can put, instead of a single wild_card,
 331        pairs of strings separated by '|'.
 332        The first string is a description, and the
 333        second is the wild card. You can put any number of pairs.
 334
 335        eg.  "description1 (*.ex1)|*.ex1|description2 (*.ex2)|*.ex2"
 336
 337        If you put a single wild card, it works as before the modification.
 338      */
 339     //=======================================================================
 340
 341     wxString theFilter;
 342     if ( wxStrlen(m_wildCard) == 0 )
 343         theFilter = wxString(wxT("*.*"));
 344     else
 345         theFilter = m_wildCard ;
 346     wxString filterBuffer;
 347
 348     if ( !wxStrchr( theFilter, wxT('|') ) ) {    // only one filter ==> default text
 349         filterBuffer.Printf(_("Files (%s)|%s"),
 350                             theFilter.c_str(), theFilter.c_str());
 351     }
 352     else {                                // more then one filter
 353         filterBuffer = theFilter;
 354
 355     }
 356
 357     filterBuffer += wxT("|");
 358     // Replace | with \0
 359     for (i = 0; i < filterBuffer.Len(); i++ ) {
 360         if ( filterBuffer.GetChar(i) == wxT('|') ) {
 361             filterBuffer[i] = wxT('\0');
 362         }
 363     }
 364
 365     of.lpstrFilter  = (LPTSTR)(const wxChar *)filterBuffer;
 366     of.nFilterIndex = m_filterIndex + 1;
 367
 368     //=== Setting defaultFileName >>=========================================
 369
 370     wxStrncpy( fileNameBuffer, (const wxChar *)m_fileName, wxMAXPATH-1 );
 371     fileNameBuffer[ wxMAXPATH-1 ] = wxT('\0');
 372
 373     of.lpstrFile = fileNameBuffer;  // holds returned filename
 374     of.nMaxFile  = wxMAXPATH;
 375
 376     //== Execute FileDialog >>=================================================
 377
 378     bool success = (m_dialogStyle & wxSAVE ? GetSaveFileName(&of)
 379                                            : GetOpenFileName(&of)) != 0;
 380
 381     DWORD errCode = CommDlgExtendedError();
 382
 383 #ifdef __WIN32__
 384     if (!success && (errCode == CDERR_STRUCTSIZE))
 385     {
 386         // The struct size has changed so try a smaller or bigger size
 387
 388         int oldStructSize = of.lStructSize;
 389         of.lStructSize       = oldStructSize - (sizeof(void *) + 2*sizeof(DWORD));
 390         success = (m_dialogStyle & wxSAVE) ? (GetSaveFileName(&of) != 0)
 391                                             : (GetOpenFileName(&of) != 0);
 392         errCode = CommDlgExtendedError();
 393
 394         if (!success && (errCode == CDERR_STRUCTSIZE))
 395         {
 396             of.lStructSize       = oldStructSize + (sizeof(void *) + 2*sizeof(DWORD));
 397             success = (m_dialogStyle & wxSAVE) ? (GetSaveFileName(&of) != 0)
 398                                             : (GetOpenFileName(&of) != 0);
 399         }
 400     }
 401 #endif // __WIN32__
 402
 403     if ( success )
 404     {
 405         m_fileNames.Empty();
 406
 407         if ( ( m_dialogStyle & wxMULTIPLE ) &&
 408 #if defined(OFN_EXPLORER)
 409              ( fileNameBuffer[of.nFileOffset-1] == wxT('\0') ) )
 410 #else
 411              ( fileNameBuffer[of.nFileOffset-1] == wxT(' ') ) )
 412 #endif // OFN_EXPLORER
 413         {
 414 #if defined(OFN_EXPLORER)
 415             m_dir = fileNameBuffer;
 416             i = of.nFileOffset;
 417             m_fileName = &fileNameBuffer[i];
 418             m_fileNames.Add(m_fileName);
 419             i += m_fileName.Len() + 1;
 420
 421             while (fileNameBuffer[i] != wxT('\0'))
 422             {
 423                 m_fileNames.Add(&fileNameBuffer[i]);
 424                 i += wxStrlen(&fileNameBuffer[i]) + 1;
 425             }
 426 #else
 427             wxStringTokenizer toke(fileNameBuffer, _T(" \t\r\n"));
 428             m_dir = toke.GetNextToken();
 429             m_fileName = toke.GetNextToken();
 430             m_fileNames.Add(m_fileName);
 431
 432             while (toke.HasMoreTokens())
 433                 m_fileNames.Add(toke.GetNextToken());
 434 #endif // OFN_EXPLORER
 435
 436             wxString dir(m_dir);
 437             if ( m_dir.Last() != _T('\\') )
 438                 dir += _T('\\');
 439
 440             m_fileNames.Sort();
 441             m_path = dir + m_fileName;
 442         }
 443         else
 444         {
 445             const wxChar* extension = NULL;
 446
 447             //=== Adding the correct extension >>=================================
 448
 449             m_filterIndex = (int)of.nFilterIndex - 1;
 450
 451             if ( !of.nFileExtension ||
 452                  (of.nFileExtension && fileNameBuffer[of.nFileExtension] == wxT('\0')) )
 453             {
 454                 // User has typed a filename without an extension:
 455
 456                 // A filename can end in a "." here ("abc."), this means it
 457                 // does not have an extension. Because later on a "." with
 458                 // the default extension is appended we remove the "." if
 459                 // filename ends with one (We don't want files called
 460                 // "abc..ext")
 461                 int idx = wxStrlen(fileNameBuffer) - 1;
 462                 if ( fileNameBuffer[idx] == wxT('.') )
 463                 {
 464                     fileNameBuffer[idx] = wxT('\0');
 465                 }
 466
 467                 int   maxFilter = (int)(of.nFilterIndex*2L-1L);
 468                 extension = filterBuffer;
 469
 470                 for( int i = 0; i < maxFilter; i++ ) {          // get extension
 471                     extension = extension + wxStrlen( extension ) +1;
 472                 }
 473
 474                 extension = wxStrrchr( extension, wxT('.') );
 475                 if (  extension                                 // != "blabla"
 476                         && !wxStrrchr( extension, wxT('*') )       // != "blabla.*"
 477                         && !wxStrrchr( extension, wxT('?') )       // != "blabla.?"
 478                         && extension[1]                           // != "blabla."
 479                         && extension[1] != wxT(' ') )              // != "blabla. "
 480                 {
 481                     // now concat extension to the fileName:
 482                     m_fileName = wxString(fileNameBuffer) + extension;
 483
 484                     int len = wxStrlen( fileNameBuffer );
 485                     wxStrncpy( fileNameBuffer + len, extension, wxMAXPATH - len );
 486                     fileNameBuffer[ wxMAXPATH -1 ] = wxT('\0');
 487                 }
 488             }
 489
 490             m_path = fileNameBuffer;
 491             m_fileName = wxFileNameFromPath(fileNameBuffer);
 492             m_fileNames.Add(m_fileName);
 493             m_dir = wxPathOnly(fileNameBuffer);
 494         }
 495     }
 496     else
 497     {
 498         // common dialog failed - why?
 499 #ifdef __WXDEBUG__
 500         DWORD dwErr = CommDlgExtendedError();
 501         if ( dwErr != 0 )
 502         {
 503             // this msg is only for developers
 504             wxLogError(wxT("Common dialog failed with error code %0lx."),
 505                        dwErr);
 506         }
 507         //else: it was just cancelled
 508 #endif
 509     }
 510
 511     return success ? wxID_OK : wxID_CANCEL;
 512
 513 }
 514
 515 // Generic file load/save dialog (for internal use only)
 516 static
 517 wxString wxDefaultFileSelector(bool load,
 518                                const wxChar *what,
 519                                const wxChar *extension,
 520                                const wxChar *default_name,
 521                                wxWindow *parent)
 522 {
 523     wxString prompt;
 524     wxString str;
 525     if (load)
 526         str = _("Load %s file");
 527     else
 528         str = _("Save %s file");
 529     prompt.Printf(str, what);
 530
 531     const wxChar *ext = extension;
 532     if (*ext == wxT('.'))
 533         ext++;
 534
 535     wxString wild;
 536     wild.Printf(wxT("*.%s"), ext);
 537
 538     return wxFileSelector(prompt, NULL, default_name, ext, wild,
 539                           load ? wxOPEN : wxSAVE, parent);
 540 }
 541
 542 // Generic file load dialog
 543 WXDLLEXPORT wxString wxLoadFileSelector(const wxChar *what,
 544                                         const wxChar *extension,
 545                                         const wxChar *default_name,
 546                                         wxWindow *parent)
 547 {
 548     return wxDefaultFileSelector(TRUE, what, extension, default_name, parent);
 549 }
 550
 551 // Generic file save dialog
 552 WXDLLEXPORT wxString wxSaveFileSelector(const wxChar *what,
 553                                         const wxChar *extension,
 554                                         const wxChar *default_name,
 555                                         wxWindow *parent)
 556 {
 557     return wxDefaultFileSelector(FALSE, what, extension, default_name, parent);
 558 }
 559
 560 #endif // wxUSE_FILEDLG
 561