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