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 // ----------------------------------------------------------------------------
  56 // constants
  57 // ----------------------------------------------------------------------------
  58
  59 #ifdef __WIN32__
  60 # define wxMAXPATH   4096
  61 #else
  62 # define wxMAXPATH   1024
  63 #endif
  64
  65 # define wxMAXFILE   1024
  66
  67 # define wxMAXEXT    5
  68
  69 // ============================================================================
  70 // implementation
  71 // ============================================================================
  72
  73 // ----------------------------------------------------------------------------
  74 // wxWin macros
  75 // ----------------------------------------------------------------------------
  76
  77 IMPLEMENT_CLASS(wxFileDialog, wxDialog)
  78
  79 // ----------------------------------------------------------------------------
  80 // global functions
  81 // ----------------------------------------------------------------------------
  82
  83 wxString wxFileSelector(const wxChar *title,
  84                         const wxChar *defaultDir,
  85                         const wxChar *defaultFileName,
  86                         const wxChar *defaultExtension,
  87                         const wxChar *filter,
  88                         int flags,
  89                         wxWindow *parent,
  90                         int x, int y)
  91 {
  92     // In the original implementation, defaultExtension is passed to the
  93     // lpstrDefExt member of OPENFILENAME. This extension, if non-NULL, is
  94     // appended to the filename if the user fails to type an extension. The new
  95     // implementation (taken from wxFileSelectorEx) appends the extension
  96     // automatically, by looking at the filter specification. In fact this
  97     // should be better than the native Microsoft implementation because
  98     // Windows only allows *one* default extension, whereas here we do the
  99     // right thing depending on the filter the user has chosen.
 100
 101     // If there's a default extension specified but no filter, we create a
 102     // suitable filter.
 103
 104     wxString filter2;
 105     if ( defaultExtension && !filter )
 106         filter2 = wxString(wxT("*.")) + defaultExtension;
 107     else if ( filter )
 108         filter2 = filter;
 109
 110     wxString defaultDirString;
 111     if (defaultDir)
 112         defaultDirString = defaultDir;
 113
 114     wxString defaultFilenameString;
 115     if (defaultFileName)
 116         defaultFilenameString = defaultFileName;
 117
 118     wxFileDialog fileDialog(parent, title, defaultDirString,
 119                             defaultFilenameString, filter2,
 120                             flags, wxPoint(x, y));
 121     if( wxStrlen(defaultExtension) != 0 )
 122     {
 123         int filterFind = 0,
 124             filterIndex = 0;
 125
 126         for( unsigned int i = 0; i < filter2.Len(); i++ )
 127         {
 128             if( filter2.GetChar(i) == wxT('|') )
 129             {
 130                 // save the start index of the new filter
 131                 unsigned int is = i++;
 132
 133                 // find the end of the filter
 134                 for( ; i < filter2.Len(); i++ )
 135                 {
 136                     if(filter2[i] == wxT('|'))
 137                         break;
 138                 }
 139
 140                 if( i-is-1 > 0 && is+1 < filter2.Len() )
 141                 {
 142                     if( filter2.Mid(is+1,i-is-1).Contains(defaultExtension) )
 143                     {
 144                         filterFind = filterIndex;
 145                         break;
 146                     }
 147                 }
 148
 149                 filterIndex++;
 150             }
 151         }
 152
 153         fileDialog.SetFilterIndex(filterFind);
 154     }
 155
 156     wxString filename;
 157     if ( fileDialog.ShowModal() == wxID_OK )
 158     {
 159         filename = fileDialog.GetPath();
 160     }
 161
 162     return filename;
 163 }
 164
 165
 166 wxString wxFileSelectorEx(const wxChar *title,
 167                        const wxChar *defaultDir,
 168                        const wxChar *defaultFileName,
 169                        int* defaultFilterIndex,
 170                        const wxChar *filter,
 171                        int       flags,
 172                        wxWindow* parent,
 173                        int       x,
 174                        int       y)
 175
 176 {
 177     wxFileDialog fileDialog(parent,
 178                             title ? title : wxT(""),
 179                             defaultDir ? defaultDir : wxT(""),
 180                             defaultFileName ? defaultFileName : wxT(""),
 181                             filter ? filter : wxT(""),
 182                             flags, wxPoint(x, y));
 183
 184     wxString filename;
 185     if ( fileDialog.ShowModal() == wxID_OK )
 186     {
 187         if ( defaultFilterIndex )
 188             *defaultFilterIndex = fileDialog.GetFilterIndex();
 189
 190         filename = fileDialog.GetPath();
 191     }
 192
 193     return filename;
 194 }
 195
 196 wxFileDialog::wxFileDialog(wxWindow *parent, const wxString& message,
 197         const wxString& defaultDir, const wxString& defaultFileName, const wxString& wildCard,
 198         long style, const wxPoint& WXUNUSED(pos))
 199 {
 200     m_message = message;
 201     m_dialogStyle = style;
 202     if ( ( m_dialogStyle & wxMULTIPLE ) && ( m_dialogStyle & wxSAVE ) )
 203         m_dialogStyle &= ~wxMULTIPLE;
 204     m_parent = parent;
 205     m_path = wxT("");
 206     m_fileName = defaultFileName;
 207     m_dir = defaultDir;
 208     m_wildCard = wildCard;
 209     m_filterIndex = 0;
 210 }
 211
 212 void wxFileDialog::GetPaths(wxArrayString& paths) const
 213 {
 214     paths.Empty();
 215
 216     wxString dir(m_dir);
 217     if ( m_dir.Last() != _T('\\') )
 218         dir += _T('\\');
 219
 220     size_t count = m_fileNames.GetCount();
 221     for ( size_t n = 0; n < count; n++ )
 222     {
 223         paths.Add(dir + m_fileNames[n]);
 224     }
 225 }
 226
 227 int wxFileDialog::ShowModal()
 228 {
 229     HWND hWnd = 0;
 230     if (m_parent) hWnd = (HWND) m_parent->GetHWND();
 231     if (!hWnd && wxTheApp->GetTopWindow())
 232         hWnd = (HWND) wxTheApp->GetTopWindow()->GetHWND();
 233
 234     static wxChar fileNameBuffer [ wxMAXPATH ];           // the file-name
 235     wxChar        titleBuffer    [ wxMAXFILE+1+wxMAXEXT ];  // the file-name, without path
 236
 237     *fileNameBuffer = wxT('\0');
 238     *titleBuffer    = wxT('\0');
 239
 240     long msw_flags = 0;
 241     if ( (m_dialogStyle & wxHIDE_READONLY) || (m_dialogStyle & wxSAVE) )
 242         msw_flags |= OFN_HIDEREADONLY;
 243     if ( m_dialogStyle & wxFILE_MUST_EXIST )
 244         msw_flags |= OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST;
 245     if (m_dialogStyle & wxMULTIPLE )
 246         msw_flags |=
 247 #if defined(OFN_EXPLORER)
 248         OFN_EXPLORER |
 249 #endif // OFN_EXPLORER
 250         OFN_ALLOWMULTISELECT;
 251
 252     OPENFILENAME of;
 253     wxZeroMemory(of);
 254
 255     // the OPENFILENAME struct has been extended in newer version of
 256     // comcdlg32.dll, but as we don't use the extended fields anyhow, set
 257     // the struct size to the old value - otherwise, the programs compiled
 258     // with new headers will not work with the old libraries
 259 #if defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0500)
 260     of.lStructSize       = sizeof(OPENFILENAME) -
 261                            (sizeof(void *) + 2*sizeof(DWORD));
 262 #else // old headers
 263     of.lStructSize       = sizeof(OPENFILENAME);
 264 #endif
 265
 266     of.hwndOwner         = hWnd;
 267     of.lpstrTitle        = WXSTRINGCAST m_message;
 268     of.lpstrFileTitle    = titleBuffer;
 269     of.nMaxFileTitle     = wxMAXFILE + 1 + wxMAXEXT;    // Windows 3.0 and 3.1
 270
 271     // Convert forward slashes to backslashes (file selector doesn't like
 272     // forward slashes)
 273     size_t i = 0;
 274     size_t len = m_dir.Length();
 275     for (i = 0; i < len; i++)
 276         if (m_dir[i] == wxT('/'))
 277             m_dir[i] = wxT('\\');
 278
 279     of.lpstrInitialDir   = m_dir.c_str();
 280
 281     of.Flags             = msw_flags;
 282
 283
 284     //=== Like Alejandro Sierra's wildcard modification >>===================
 285     /*
 286        In wxFileSelector you can put, instead of a single wild_card,
 287        pairs of strings separated by '|'.
 288        The first string is a description, and the
 289        second is the wild card. You can put any number of pairs.
 290
 291        eg.  "description1 (*.ex1)|*.ex1|description2 (*.ex2)|*.ex2"
 292
 293        If you put a single wild card, it works as before the modification.
 294      */
 295     //=======================================================================
 296
 297     wxString theFilter;
 298     if ( wxStrlen(m_wildCard) == 0 )
 299         theFilter = wxString(wxT("*.*"));
 300     else
 301         theFilter = m_wildCard ;
 302     wxString filterBuffer;
 303
 304     if ( !wxStrchr( theFilter, wxT('|') ) ) {    // only one filter ==> default text
 305         filterBuffer.Printf(_("Files (%s)|%s"),
 306                             theFilter.c_str(), theFilter.c_str());
 307     }
 308     else {                                // more then one filter
 309         filterBuffer = theFilter;
 310
 311     }
 312
 313     filterBuffer += wxT("|");
 314     // Replace | with \0
 315     for (i = 0; i < filterBuffer.Len(); i++ ) {
 316         if ( filterBuffer.GetChar(i) == wxT('|') ) {
 317             filterBuffer[i] = wxT('\0');
 318         }
 319     }
 320
 321     of.lpstrFilter  = (LPTSTR)(const wxChar *)filterBuffer;
 322     of.nFilterIndex = m_filterIndex + 1;
 323
 324     //=== Setting defaultFileName >>=========================================
 325
 326     wxStrncpy( fileNameBuffer, (const wxChar *)m_fileName, wxMAXPATH-1 );
 327     fileNameBuffer[ wxMAXPATH-1 ] = wxT('\0');
 328
 329     of.lpstrFile = fileNameBuffer;  // holds returned filename
 330     of.nMaxFile  = wxMAXPATH;
 331
 332     //== Execute FileDialog >>=================================================
 333
 334     bool success = (m_dialogStyle & wxSAVE ? GetSaveFileName(&of)
 335                                            : GetOpenFileName(&of)) != 0;
 336
 337     DWORD errCode = CommDlgExtendedError();
 338
 339 #ifdef __WIN32__
 340     if (!success && (errCode == CDERR_STRUCTSIZE))
 341     {
 342         // The struct size has changed so try a smaller or bigger size
 343
 344         int oldStructSize = of.lStructSize;
 345         of.lStructSize       = oldStructSize - (sizeof(void *) + 2*sizeof(DWORD));
 346         success = (m_dialogStyle & wxSAVE) ? (GetSaveFileName(&of) != 0)
 347                                             : (GetOpenFileName(&of) != 0);
 348         errCode = CommDlgExtendedError();
 349
 350         if (!success && (errCode == CDERR_STRUCTSIZE))
 351         {
 352             of.lStructSize       = oldStructSize + (sizeof(void *) + 2*sizeof(DWORD));
 353             success = (m_dialogStyle & wxSAVE) ? (GetSaveFileName(&of) != 0)
 354                                             : (GetOpenFileName(&of) != 0);
 355         }
 356     }
 357 #endif
 358
 359     if ( success )
 360     {
 361         m_fileNames.Empty();
 362
 363         if ( ( m_dialogStyle & wxMULTIPLE ) &&
 364 #if defined(OFN_EXPLORER)
 365              ( fileNameBuffer[of.nFileOffset-1] == wxT('\0') ) )
 366 #else
 367              ( fileNameBuffer[of.nFileOffset-1] == wxT(' ') ) )
 368 #endif // OFN_EXPLORER
 369         {
 370 #if defined(OFN_EXPLORER)
 371             m_dir = fileNameBuffer;
 372             i = of.nFileOffset;
 373             m_fileName = &fileNameBuffer[i];
 374             m_fileNames.Add(m_fileName);
 375             i += m_fileName.Len() + 1;
 376
 377             while (fileNameBuffer[i] != wxT('\0'))
 378             {
 379                 m_fileNames.Add(&fileNameBuffer[i]);
 380                 i += wxStrlen(&fileNameBuffer[i]) + 1;
 381             }
 382 #else
 383             wxStringTokenizer toke(fileNameBuffer, " \t\r\n");
 384             m_dir = toke.GetNextToken();
 385             m_fileName = toke.GetNextToken();
 386             m_fileNames.Add(m_fileName);
 387
 388             while (toke.HasMoreTokens())
 389                 m_fileNames.Add(toke.GetNextToken());
 390 #endif // OFN_EXPLORER
 391
 392             wxString dir(m_dir);
 393             if ( m_dir.Last() != _T('\\') )
 394                 dir += _T('\\');
 395
 396             m_fileNames.Sort();
 397             m_path = dir + m_fileName;
 398         }
 399         else
 400         {
 401             const wxChar* extension = NULL;
 402
 403             //=== Adding the correct extension >>=================================
 404
 405             m_filterIndex = (int)of.nFilterIndex - 1;
 406
 407             if ( !of.nFileExtension || (of.nFileExtension && fileNameBuffer[ of.nFileExtension-1] != wxT('.')) )
 408             {                                    // user has typed an filename
 409                 // without an extension:
 410
 411                 int   maxFilter = (int)(of.nFilterIndex*2L-1L);
 412                 extension = filterBuffer;
 413
 414                 for( int i = 0; i < maxFilter; i++ ) {          // get extension
 415                     extension = extension + wxStrlen( extension ) +1;
 416                 }
 417
 418                 extension = wxStrrchr( extension, wxT('.') );
 419                 if (  extension                                 // != "blabla"
 420                         && !wxStrrchr( extension, wxT('*') )       // != "blabla.*"
 421                         && !wxStrrchr( extension, wxT('?') )       // != "blabla.?"
 422                         && extension[1]                           // != "blabla."
 423                         && extension[1] != wxT(' ') )              // != "blabla. "
 424                 {
 425                     // now concat extension to the fileName:
 426                     m_fileName = wxString(fileNameBuffer) + extension;
 427
 428                     int len = wxStrlen( fileNameBuffer );
 429                     wxStrncpy( fileNameBuffer + len, extension, wxMAXPATH - len );
 430                     fileNameBuffer[ wxMAXPATH -1 ] = wxT('\0');
 431                 }
 432             }
 433
 434             m_path = fileNameBuffer;
 435             m_fileName = wxFileNameFromPath(fileNameBuffer);
 436             m_fileNames.Add(m_fileName);
 437             m_dir = wxPathOnly(fileNameBuffer);
 438         }
 439
 440
 441         //=== Simulating the wxOVERWRITE_PROMPT >>============================
 442
 443         if ( (m_dialogStyle & wxOVERWRITE_PROMPT) &&
 444              ::wxFileExists( fileNameBuffer ) )
 445         {
 446             wxString messageText;
 447             messageText.Printf(_("Replace file '%s'?"), fileNameBuffer);
 448
 449             if ( wxMessageBox(messageText, m_message, wxYES_NO ) != wxYES )
 450             {
 451                 success = FALSE;
 452             }
 453         }
 454
 455     }
 456     else
 457     {
 458         // common dialog failed - why?
 459 #ifdef __WXDEBUG__
 460         DWORD dwErr = CommDlgExtendedError();
 461         if ( dwErr != 0 )
 462         {
 463             // this msg is only for developers
 464             wxLogError(wxT("Common dialog failed with error code %0lx."),
 465                        dwErr);
 466         }
 467         //else: it was just cancelled
 468 #endif
 469     }
 470
 471     return success ? wxID_OK : wxID_CANCEL;
 472
 473 }
 474
 475 // Generic file load/save dialog (for internal use only)
 476 static
 477 wxString wxDefaultFileSelector(bool load,
 478                                const wxChar *what,
 479                                const wxChar *extension,
 480                                const wxChar *default_name,
 481                                wxWindow *parent)
 482 {
 483   wxString prompt;
 484   wxString str;
 485   if (load) str = _("Load %s file");
 486   else str = _("Save %s file");
 487   prompt.Printf(str, what);
 488
 489   const wxChar *ext = extension;
 490   if (*ext == wxT('.'))
 491       ext++;
 492
 493   wxString wild;
 494   wild.Printf(wxT("*.%s"), ext);
 495
 496   return wxFileSelector (prompt, NULL, default_name, ext, wild, 0, parent);
 497 }
 498
 499 // Generic file load dialog
 500 WXDLLEXPORT wxString wxLoadFileSelector(const wxChar *what,
 501                                         const wxChar *extension,
 502                                         const wxChar *default_name,
 503                                         wxWindow *parent)
 504 {
 505     return wxDefaultFileSelector(TRUE, what, extension, default_name, parent);
 506 }
 507
 508 // Generic file save dialog
 509 WXDLLEXPORT wxString wxSaveFileSelector(const wxChar *what,
 510                                         const wxChar *extension,
 511                                         const wxChar *default_name,
 512                                         wxWindow *parent)
 513 {
 514     return wxDefaultFileSelector(FALSE, what, extension, default_name, parent);
 515 }
 516
 517 #endif // wxUSE_FILEDLG
 518