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