src/common/filename.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/common/filename.cpp
   3 // Purpose:     wxFileName - encapsulates a file path
   4 // Author:      Robert Roebling, Vadim Zeitlin
   5 // Modified by:
   6 // Created:     28.12.2000
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 2000 Robert Roebling
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 /*
  13    Here are brief descriptions of the filename formats supported by this class:
  14
  15    wxPATH_UNIX: standard Unix format, used under Darwin as well, absolute file
  16                 names have the form:
  17                 /dir1/dir2/.../dirN/filename, "." and ".." stand for the
  18                 current and parent directory respectively, "~" is parsed as the
  19                 user HOME and "~username" as the HOME of that user
  20
  21    wxPATH_DOS:  DOS/Windows format, absolute file names have the form:
  22                 drive:\dir1\dir2\...\dirN\filename.ext where drive is a single
  23                 letter. "." and ".." as for Unix but no "~".
  24
  25                 There are also UNC names of the form \\share\fullpath
  26
  27    wxPATH_MAC:  Mac OS 8/9 and Mac OS X under CodeWarrior 7 format, absolute file
  28                 names have the form
  29                     volume:dir1:...:dirN:filename
  30                 and the relative file names are either
  31                     :dir1:...:dirN:filename
  32                 or just
  33                     filename
  34                 (although :filename works as well).
  35                 Since the volume is just part of the file path, it is not
  36                 treated like a separate entity as it is done under DOS and
  37                 VMS, it is just treated as another dir.
  38
  39    wxPATH_VMS:  VMS native format, absolute file names have the form
  40                     <device>:[dir1.dir2.dir3]file.txt
  41                 or
  42                     <device>:[000000.dir1.dir2.dir3]file.txt
  43
  44                 the <device> is the physical device (i.e. disk). 000000 is the
  45                 root directory on the device which can be omitted.
  46
  47                 Note that VMS uses different separators unlike Unix:
  48                  : always after the device. If the path does not contain : than
  49                    the default (the device of the current directory) is assumed.
  50                  [ start of directory specification
  51                  . separator between directory and subdirectory
  52                  ] between directory and file
  53  */
  54
  55 // ============================================================================
  56 // declarations
  57 // ============================================================================
  58
  59 // ----------------------------------------------------------------------------
  60 // headers
  61 // ----------------------------------------------------------------------------
  62
  63 // For compilers that support precompilation, includes "wx.h".
  64 #include "wx/wxprec.h"
  65
  66 #ifdef __BORLANDC__
  67 #pragma hdrstop
  68 #endif
  69
  70 #ifndef WX_PRECOMP
  71     #ifdef __WXMSW__
  72         #include "wx/msw/wrapwin.h" // For GetShort/LongPathName
  73     #endif
  74     #include "wx/dynarray.h"
  75     #include "wx/intl.h"
  76     #include "wx/log.h"
  77     #include "wx/utils.h"
  78 #endif
  79
  80 #include "wx/filename.h"
  81 #include "wx/private/filename.h"
  82 #include "wx/tokenzr.h"
  83 #include "wx/config.h"          // for wxExpandEnvVars
  84 #include "wx/dynlib.h"
  85
  86 #if defined(__WIN32__) && defined(__MINGW32__)
  87     #include "wx/msw/gccpriv.h"
  88 #endif
  89
  90 #ifdef __WXWINCE__
  91 #include "wx/msw/private.h"
  92 #endif
  93
  94 #if defined(__WXMAC__)
  95   #include  "wx/mac/private.h"  // includes mac headers
  96 #endif
  97
  98 // utime() is POSIX so should normally be available on all Unices
  99 #ifdef __UNIX_LIKE__
 100 #include <sys/types.h>
 101 #include <utime.h>
 102 #include <sys/stat.h>
 103 #include <unistd.h>
 104 #endif
 105
 106 #ifdef __DJGPP__
 107 #include <unistd.h>
 108 #endif
 109
 110 #ifdef __MWERKS__
 111 #ifdef __MACH__
 112 #include <sys/types.h>
 113 #include <utime.h>
 114 #include <sys/stat.h>
 115 #include <unistd.h>
 116 #else
 117 #include <stat.h>
 118 #include <unistd.h>
 119 #include <unix.h>
 120 #endif
 121 #endif
 122
 123 #ifdef __WATCOMC__
 124 #include <io.h>
 125 #include <sys/utime.h>
 126 #include <sys/stat.h>
 127 #endif
 128
 129 #ifdef __VISAGECPP__
 130 #ifndef MAX_PATH
 131 #define MAX_PATH 256
 132 #endif
 133 #endif
 134
 135 #ifdef __EMX__
 136 #include <os2.h>
 137 #define MAX_PATH _MAX_PATH
 138 #endif
 139
 140
 141 wxULongLong wxInvalidSize = (unsigned)-1;
 142
 143
 144 // ----------------------------------------------------------------------------
 145 // private classes
 146 // ----------------------------------------------------------------------------
 147
 148 // small helper class which opens and closes the file - we use it just to get
 149 // a file handle for the given file name to pass it to some Win32 API function
 150 #if defined(__WIN32__) && !defined(__WXMICROWIN__)
 151
 152 class wxFileHandle
 153 {
 154 public:
 155     enum OpenMode
 156     {
 157         Read,
 158         Write
 159     };
 160
 161     wxFileHandle(const wxString& filename, OpenMode mode)
 162     {
 163         m_hFile = ::CreateFile
 164                     (
 165                      filename,                      // name
 166                      mode == Read ? GENERIC_READ    // access mask
 167                                   : GENERIC_WRITE,
 168                      FILE_SHARE_READ |              // sharing mode
 169                      FILE_SHARE_WRITE,              // (allow everything)
 170                      NULL,                          // no secutity attr
 171                      OPEN_EXISTING,                 // creation disposition
 172                      0,                             // no flags
 173                      NULL                           // no template file
 174                     );
 175
 176         if ( m_hFile == INVALID_HANDLE_VALUE )
 177         {
 178             wxLogSysError(_("Failed to open '%s' for %s"),
 179                           filename.c_str(),
 180                           mode == Read ? _("reading") : _("writing"));
 181         }
 182     }
 183
 184     ~wxFileHandle()
 185     {
 186         if ( m_hFile != INVALID_HANDLE_VALUE )
 187         {
 188             if ( !::CloseHandle(m_hFile) )
 189             {
 190                 wxLogSysError(_("Failed to close file handle"));
 191             }
 192         }
 193     }
 194
 195     // return true only if the file could be opened successfully
 196     bool IsOk() const { return m_hFile != INVALID_HANDLE_VALUE; }
 197
 198     // get the handle
 199     operator HANDLE() const { return m_hFile; }
 200
 201 private:
 202     HANDLE m_hFile;
 203 };
 204
 205 #endif // __WIN32__
 206
 207 // ----------------------------------------------------------------------------
 208 // private functions
 209 // ----------------------------------------------------------------------------
 210
 211 #if wxUSE_DATETIME && defined(__WIN32__) && !defined(__WXMICROWIN__)
 212
 213 // convert between wxDateTime and FILETIME which is a 64-bit value representing
 214 // the number of 100-nanosecond intervals since January 1, 1601.
 215
 216 static void ConvertFileTimeToWx(wxDateTime *dt, const FILETIME &ft)
 217 {
 218     FILETIME ftcopy = ft;
 219     FILETIME ftLocal;
 220     if ( !::FileTimeToLocalFileTime(&ftcopy, &ftLocal) )
 221     {
 222         wxLogLastError(_T("FileTimeToLocalFileTime"));
 223     }
 224
 225     SYSTEMTIME st;
 226     if ( !::FileTimeToSystemTime(&ftLocal, &st) )
 227     {
 228         wxLogLastError(_T("FileTimeToSystemTime"));
 229     }
 230
 231     dt->Set(st.wDay, wxDateTime::Month(st.wMonth - 1), st.wYear,
 232             st.wHour, st.wMinute, st.wSecond, st.wMilliseconds);
 233 }
 234
 235 static void ConvertWxToFileTime(FILETIME *ft, const wxDateTime& dt)
 236 {
 237     SYSTEMTIME st;
 238     st.wDay = dt.GetDay();
 239     st.wMonth = (WORD)(dt.GetMonth() + 1);
 240     st.wYear = (WORD)dt.GetYear();
 241     st.wHour = dt.GetHour();
 242     st.wMinute = dt.GetMinute();
 243     st.wSecond = dt.GetSecond();
 244     st.wMilliseconds = dt.GetMillisecond();
 245
 246     FILETIME ftLocal;
 247     if ( !::SystemTimeToFileTime(&st, &ftLocal) )
 248     {
 249         wxLogLastError(_T("SystemTimeToFileTime"));
 250     }
 251
 252     if ( !::LocalFileTimeToFileTime(&ftLocal, ft) )
 253     {
 254         wxLogLastError(_T("LocalFileTimeToFileTime"));
 255     }
 256 }
 257
 258 #endif // wxUSE_DATETIME && __WIN32__
 259
 260 // return a string with the volume par
 261 static wxString wxGetVolumeString(const wxString& volume, wxPathFormat format)
 262 {
 263     wxString path;
 264
 265     if ( !volume.empty() )
 266     {
 267         format = wxFileName::GetFormat(format);
 268
 269         // Special Windows UNC paths hack, part 2: undo what we did in
 270         // SplitPath() and make an UNC path if we have a drive which is not a
 271         // single letter (hopefully the network shares can't be one letter only
 272         // although I didn't find any authoritative docs on this)
 273         if ( format == wxPATH_DOS && volume.length() > 1 )
 274         {
 275             path << wxFILE_SEP_PATH_DOS << wxFILE_SEP_PATH_DOS << volume;
 276         }
 277         else if  ( format == wxPATH_DOS || format == wxPATH_VMS )
 278         {
 279             path << volume << wxFileName::GetVolumeSeparator(format);
 280         }
 281         // else ignore
 282     }
 283
 284     return path;
 285 }
 286
 287 // ============================================================================
 288 // implementation
 289 // ============================================================================
 290
 291 // ----------------------------------------------------------------------------
 292 // wxFileName construction
 293 // ----------------------------------------------------------------------------
 294
 295 void wxFileName::Assign( const wxFileName &filepath )
 296 {
 297     m_volume = filepath.GetVolume();
 298     m_dirs = filepath.GetDirs();
 299     m_name = filepath.GetName();
 300     m_ext = filepath.GetExt();
 301     m_relative = filepath.m_relative;
 302     m_hasExt = filepath.m_hasExt;
 303 }
 304
 305 void wxFileName::Assign(const wxString& volume,
 306                         const wxString& path,
 307                         const wxString& name,
 308                         const wxString& ext,
 309                         bool hasExt,
 310                         wxPathFormat format )
 311 {
 312     SetPath( path, format );
 313
 314     m_volume = volume;
 315     m_ext = ext;
 316     m_name = name;
 317
 318     m_hasExt = hasExt;
 319 }
 320
 321 void wxFileName::SetPath( const wxString& pathOrig, wxPathFormat format )
 322 {
 323     m_dirs.Clear();
 324
 325     if ( pathOrig.empty() )
 326     {
 327         // no path at all
 328         m_relative = true;
 329
 330         return;
 331     }
 332
 333     format = GetFormat( format );
 334
 335     // 0) deal with possible volume part first
 336     wxString volume,
 337              path;
 338     SplitVolume(pathOrig, &volume, &path, format);
 339     if ( !volume.empty() )
 340     {
 341         m_relative = false;
 342
 343         SetVolume(volume);
 344     }
 345
 346     // 1) Determine if the path is relative or absolute.
 347     wxChar leadingChar = path[0u];
 348
 349     switch (format)
 350     {
 351         case wxPATH_MAC:
 352             m_relative = leadingChar == wxT(':');
 353
 354             // We then remove a leading ":". The reason is in our
 355             // storage form for relative paths:
 356             // ":dir:file.txt" actually means "./dir/file.txt" in
 357             // DOS notation and should get stored as
 358             // (relative) (dir) (file.txt)
 359             // "::dir:file.txt" actually means "../dir/file.txt"
 360             // stored as (relative) (..) (dir) (file.txt)
 361             // This is important only for the Mac as an empty dir
 362             // actually means <UP>, whereas under DOS, double
 363             // slashes can be ignored: "\\\\" is the same as "\\".
 364             if (m_relative)
 365                 path.erase( 0, 1 );
 366             break;
 367
 368         case wxPATH_VMS:
 369             // TODO: what is the relative path format here?
 370             m_relative = false;
 371             break;
 372
 373         default:
 374             wxFAIL_MSG( _T("Unknown path format") );
 375             // !! Fall through !!
 376
 377         case wxPATH_UNIX:
 378             // the paths of the form "~" or "~username" are absolute
 379             m_relative = leadingChar != wxT('/') && leadingChar != _T('~');
 380             break;
 381
 382         case wxPATH_DOS:
 383             m_relative = !IsPathSeparator(leadingChar, format);
 384             break;
 385
 386     }
 387
 388     // 2) Break up the path into its members. If the original path
 389     //    was just "/" or "\\", m_dirs will be empty. We know from
 390     //    the m_relative field, if this means "nothing" or "root dir".
 391
 392     wxStringTokenizer tn( path, GetPathSeparators(format) );
 393
 394     while ( tn.HasMoreTokens() )
 395     {
 396         wxString token = tn.GetNextToken();
 397
 398         // Remove empty token under DOS and Unix, interpret them
 399         // as .. under Mac.
 400         if (token.empty())
 401         {
 402             if (format == wxPATH_MAC)
 403                 m_dirs.Add( wxT("..") );
 404             // else ignore
 405         }
 406         else
 407         {
 408            m_dirs.Add( token );
 409         }
 410     }
 411 }
 412
 413 void wxFileName::Assign(const wxString& fullpath,
 414                         wxPathFormat format)
 415 {
 416     wxString volume, path, name, ext;
 417     bool hasExt;
 418     SplitPath(fullpath, &volume, &path, &name, &ext, &hasExt, format);
 419
 420     Assign(volume, path, name, ext, hasExt, format);
 421 }
 422
 423 void wxFileName::Assign(const wxString& fullpathOrig,
 424                         const wxString& fullname,
 425                         wxPathFormat format)
 426 {
 427     // always recognize fullpath as directory, even if it doesn't end with a
 428     // slash
 429     wxString fullpath = fullpathOrig;
 430     if ( !wxEndsWithPathSeparator(fullpath) )
 431     {
 432         fullpath += GetPathSeparator(format);
 433     }
 434
 435     wxString volume, path, name, ext;
 436     bool hasExt;
 437
 438     // do some consistency checks in debug mode: the name should be really just
 439     // the filename and the path should be really just a path
 440 #ifdef __WXDEBUG__
 441     wxString volDummy, pathDummy, nameDummy, extDummy;
 442
 443     SplitPath(fullname, &volDummy, &pathDummy, &name, &ext, &hasExt, format);
 444
 445     wxASSERT_MSG( volDummy.empty() && pathDummy.empty(),
 446                   _T("the file name shouldn't contain the path") );
 447
 448     SplitPath(fullpath, &volume, &path, &nameDummy, &extDummy, format);
 449
 450     wxASSERT_MSG( nameDummy.empty() && extDummy.empty(),
 451                   _T("the path shouldn't contain file name nor extension") );
 452
 453 #else // !__WXDEBUG__
 454     SplitPath(fullname, NULL /* no volume */, NULL /* no path */,
 455                         &name, &ext, &hasExt, format);
 456     SplitPath(fullpath, &volume, &path, NULL, NULL, format);
 457 #endif // __WXDEBUG__/!__WXDEBUG__
 458
 459     Assign(volume, path, name, ext, hasExt, format);
 460 }
 461
 462 void wxFileName::Assign(const wxString& pathOrig,
 463                         const wxString& name,
 464                         const wxString& ext,
 465                         wxPathFormat format)
 466 {
 467     wxString volume,
 468              path;
 469     SplitVolume(pathOrig, &volume, &path, format);
 470
 471     Assign(volume, path, name, ext, format);
 472 }
 473
 474 void wxFileName::AssignDir(const wxString& dir, wxPathFormat format)
 475 {
 476     Assign(dir, wxEmptyString, format);
 477 }
 478
 479 void wxFileName::Clear()
 480 {
 481     m_dirs.Clear();
 482
 483     m_volume =
 484     m_name =
 485     m_ext = wxEmptyString;
 486
 487     // we don't have any absolute path for now
 488     m_relative = true;
 489
 490     // nor any extension
 491     m_hasExt = false;
 492 }
 493
 494 /* static */
 495 wxFileName wxFileName::FileName(const wxString& file, wxPathFormat format)
 496 {
 497     return wxFileName(file, format);
 498 }
 499
 500 /* static */
 501 wxFileName wxFileName::DirName(const wxString& dir, wxPathFormat format)
 502 {
 503     wxFileName fn;
 504     fn.AssignDir(dir, format);
 505     return fn;
 506 }
 507
 508 // ----------------------------------------------------------------------------
 509 // existence tests
 510 // ----------------------------------------------------------------------------
 511
 512 bool wxFileName::FileExists() const
 513 {
 514     return wxFileName::FileExists( GetFullPath() );
 515 }
 516
 517 bool wxFileName::FileExists( const wxString &file )
 518 {
 519     return ::wxFileExists( file );
 520 }
 521
 522 bool wxFileName::DirExists() const
 523 {
 524     return wxFileName::DirExists( GetPath() );
 525 }
 526
 527 bool wxFileName::DirExists( const wxString &dir )
 528 {
 529     return ::wxDirExists( dir );
 530 }
 531
 532 // ----------------------------------------------------------------------------
 533 // CWD and HOME stuff
 534 // ----------------------------------------------------------------------------
 535
 536 void wxFileName::AssignCwd(const wxString& volume)
 537 {
 538     AssignDir(wxFileName::GetCwd(volume));
 539 }
 540
 541 /* static */
 542 wxString wxFileName::GetCwd(const wxString& volume)
 543 {
 544     // if we have the volume, we must get the current directory on this drive
 545     // and to do this we have to chdir to this volume - at least under Windows,
 546     // I don't know how to get the current drive on another volume elsewhere
 547     // (TODO)
 548     wxString cwdOld;
 549     if ( !volume.empty() )
 550     {
 551         cwdOld = wxGetCwd();
 552         SetCwd(volume + GetVolumeSeparator());
 553     }
 554
 555     wxString cwd = ::wxGetCwd();
 556
 557     if ( !volume.empty() )
 558     {
 559         SetCwd(cwdOld);
 560     }
 561
 562     return cwd;
 563 }
 564
 565 bool wxFileName::SetCwd()
 566 {
 567     return wxFileName::SetCwd( GetPath() );
 568 }
 569
 570 bool wxFileName::SetCwd( const wxString &cwd )
 571 {
 572     return ::wxSetWorkingDirectory( cwd );
 573 }
 574
 575 void wxFileName::AssignHomeDir()
 576 {
 577     AssignDir(wxFileName::GetHomeDir());
 578 }
 579
 580 wxString wxFileName::GetHomeDir()
 581 {
 582     return ::wxGetHomeDir();
 583 }
 584
 585
 586 // ----------------------------------------------------------------------------
 587 // CreateTempFileName
 588 // ----------------------------------------------------------------------------
 589
 590 #if wxUSE_FILE || wxUSE_FFILE
 591
 592
 593 #if !defined wx_fdopen && defined HAVE_FDOPEN
 594     #define wx_fdopen fdopen
 595 #endif
 596
 597 // NB: GetTempFileName() under Windows creates the file, so using
 598 //     O_EXCL there would fail
 599 #ifdef __WINDOWS__
 600     #define wxOPEN_EXCL 0
 601 #else
 602     #define wxOPEN_EXCL O_EXCL
 603 #endif
 604
 605
 606 #ifdef wxOpenOSFHandle
 607 #define WX_HAVE_DELETE_ON_CLOSE
 608 // On Windows create a file with the FILE_FLAGS_DELETE_ON_CLOSE flags.
 609 //
 610 static int wxOpenWithDeleteOnClose(const wxString& filename)
 611 {
 612     DWORD access = GENERIC_READ | GENERIC_WRITE;
 613
 614     DWORD disposition = OPEN_ALWAYS;
 615
 616     DWORD attributes = FILE_ATTRIBUTE_TEMPORARY |
 617                        FILE_FLAG_DELETE_ON_CLOSE;
 618
 619     HANDLE h = ::CreateFile(filename, access, 0, NULL,
 620                             disposition, attributes, NULL);
 621
 622     return wxOpenOSFHandle(h, 0);
 623 }
 624 #endif // wxOpenOSFHandle
 625
 626
 627 // Helper to open the file
 628 //
 629 static int wxTempOpen(const wxString& path, bool *deleteOnClose)
 630 {
 631 #ifdef WX_HAVE_DELETE_ON_CLOSE
 632     if (*deleteOnClose)
 633         return wxOpenWithDeleteOnClose(path);
 634 #endif
 635
 636     *deleteOnClose = false;
 637
 638     return wxOpen(path, wxO_BINARY | O_RDWR | O_CREAT | wxOPEN_EXCL, 0600);
 639 }
 640
 641
 642 #if wxUSE_FFILE
 643 // Helper to open the file and attach it to the wxFFile
 644 //
 645 static bool wxTempOpen(wxFFile *file, const wxString& path, bool *deleteOnClose)
 646 {
 647 #ifndef wx_fdopen
 648     *deleteOnClose = false;
 649     return file->Open(path, _T("w+b"));
 650 #else // wx_fdopen
 651     int fd = wxTempOpen(path, deleteOnClose);
 652     if (fd != -1)
 653         return false;
 654     file->Attach(wx_fdopen(fd, "w+b"));
 655     return file->IsOpened();
 656 #endif // wx_fdopen
 657 }
 658 #endif // wxUSE_FFILE
 659
 660
 661 #if !wxUSE_FILE
 662     #define WXFILEARGS(x, y) y
 663 #elif !wxUSE_FFILE
 664     #define WXFILEARGS(x, y) x
 665 #else
 666     #define WXFILEARGS(x, y) x, y
 667 #endif
 668
 669
 670 // Implementation of wxFileName::CreateTempFileName().
 671 //
 672 static wxString wxCreateTempImpl(
 673         const wxString& prefix,
 674         WXFILEARGS(wxFile *fileTemp, wxFFile *ffileTemp),
 675         bool *deleteOnClose = NULL)
 676 {
 677 #if wxUSE_FILE && wxUSE_FFILE
 678     wxASSERT(fileTemp == NULL || ffileTemp == NULL);
 679 #endif
 680     wxString path, dir, name;
 681     bool wantDeleteOnClose = false;
 682
 683     if (deleteOnClose)
 684     {
 685         // set the result to false initially
 686         wantDeleteOnClose = *deleteOnClose;
 687         *deleteOnClose = false;
 688     }
 689     else
 690     {
 691         // easier if it alwasys points to something
 692         deleteOnClose = &wantDeleteOnClose;
 693     }
 694
 695     // use the directory specified by the prefix
 696     wxFileName::SplitPath(prefix, &dir, &name, NULL /* extension */);
 697
 698     if (dir.empty())
 699     {
 700         dir = wxGetenv(_T("TMPDIR"));
 701         if (dir.empty())
 702         {
 703             dir = wxGetenv(_T("TMP"));
 704             if (dir.empty())
 705             {
 706                 dir = wxGetenv(_T("TEMP"));
 707             }
 708         }
 709     }
 710
 711 #if defined(__WXWINCE__)
 712     if (dir.empty())
 713     {
 714         // FIXME. Create \temp dir?
 715         if (wxFileName::DirExists(wxT("\\temp")))
 716             dir = wxT("\\temp");
 717     }
 718     path = dir + wxT("\\") + name;
 719     int i = 1;
 720     while (wxFileName::FileExists(path))
 721     {
 722         path = dir + wxT("\\") + name ;
 723         path << i;
 724         i ++;
 725     }
 726
 727 #elif defined(__WINDOWS__) && !defined(__WXMICROWIN__)
 728
 729     if ( dir.empty() )
 730     {
 731         if ( !::GetTempPath(MAX_PATH, wxStringBuffer(dir, MAX_PATH + 1)) )
 732         {
 733             wxLogLastError(_T("GetTempPath"));
 734         }
 735
 736         if ( dir.empty() )
 737         {
 738             // GetTempFileName() fails if we pass it an empty string
 739             dir = _T('.');
 740         }
 741     }
 742     else // we have a dir to create the file in
 743     {
 744         // ensure we use only the back slashes as GetTempFileName(), unlike all
 745         // the other APIs, is picky and doesn't accept the forward ones
 746         dir.Replace(_T("/"), _T("\\"));
 747     }
 748
 749     if ( !::GetTempFileName(dir, name, 0, wxStringBuffer(path, MAX_PATH + 1)) )
 750     {
 751         wxLogLastError(_T("GetTempFileName"));
 752
 753         path.clear();
 754     }
 755
 756 #else // !Windows
 757     if ( dir.empty() )
 758     {
 759         // default
 760 #if defined(__DOS__) || defined(__OS2__)
 761         dir = _T(".");
 762 #elif defined(__WXMAC__)
 763         dir = wxMacFindFolder(short(kOnSystemDisk), kTemporaryFolderType, kCreateFolder);
 764 #else
 765         dir = _T("/tmp");
 766 #endif
 767     }
 768
 769     path = dir;
 770
 771     if ( !wxEndsWithPathSeparator(dir) &&
 772             (name.empty() || !wxIsPathSeparator(name[0u])) )
 773     {
 774         path += wxFILE_SEP_PATH;
 775     }
 776
 777     path += name;
 778
 779 #if defined(HAVE_MKSTEMP)
 780     // scratch space for mkstemp()
 781     path += _T("XXXXXX");
 782
 783     // we need to copy the path to the buffer in which mkstemp() can modify it
 784     wxCharBuffer buf( wxConvFile.cWX2MB( path ) );
 785
 786     // cast is safe because the string length doesn't change
 787     int fdTemp = mkstemp( (char*)(const char*) buf );
 788     if ( fdTemp == -1 )
 789     {
 790         // this might be not necessary as mkstemp() on most systems should have
 791         // already done it but it doesn't hurt neither...
 792         path.clear();
 793     }
 794     else // mkstemp() succeeded
 795     {
 796         path = wxConvFile.cMB2WX( (const char*) buf );
 797
 798     #if wxUSE_FILE
 799         // avoid leaking the fd
 800         if ( fileTemp )
 801         {
 802             fileTemp->Attach(fdTemp);
 803         }
 804         else
 805     #endif
 806
 807     #if wxUSE_FFILE
 808         if ( ffileTemp )
 809         {
 810         #ifdef wx_fdopen
 811             ffileTemp->Attach(wx_fdopen(fdTemp, "r+b"));
 812         #else
 813             ffileTemp->Open(path, _T("r+b"));
 814             close(fdTemp);
 815         #endif
 816         }
 817         else
 818     #endif
 819
 820         {
 821             close(fdTemp);
 822         }
 823     }
 824 #else // !HAVE_MKSTEMP
 825
 826 #ifdef HAVE_MKTEMP
 827     // same as above
 828     path += _T("XXXXXX");
 829
 830     wxCharBuffer buf = wxConvFile.cWX2MB( path );
 831     if ( !mktemp( (char*)(const char*) buf ) )
 832     {
 833         path.clear();
 834     }
 835     else
 836     {
 837         path = wxConvFile.cMB2WX( (const char*) buf );
 838     }
 839 #else // !HAVE_MKTEMP (includes __DOS__)
 840     // generate the unique file name ourselves
 841     #if !defined(__DOS__) && !defined(__PALMOS__) && (!defined(__MWERKS__) || defined(__DARWIN__) )
 842     path << (unsigned int)getpid();
 843     #endif
 844
 845     wxString pathTry;
 846
 847     static const size_t numTries = 1000;
 848     for ( size_t n = 0; n < numTries; n++ )
 849     {
 850         // 3 hex digits is enough for numTries == 1000 < 4096
 851         pathTry = path + wxString::Format(_T("%.03x"), (unsigned int) n);
 852         if ( !wxFileName::FileExists(pathTry) )
 853         {
 854             break;
 855         }
 856
 857         pathTry.clear();
 858     }
 859
 860     path = pathTry;
 861 #endif // HAVE_MKTEMP/!HAVE_MKTEMP
 862
 863 #endif // HAVE_MKSTEMP/!HAVE_MKSTEMP
 864
 865 #endif // Windows/!Windows
 866
 867     if ( path.empty() )
 868     {
 869         wxLogSysError(_("Failed to create a temporary file name"));
 870     }
 871     else
 872     {
 873         bool ok = true;
 874
 875         // open the file - of course, there is a race condition here, this is
 876         // why we always prefer using mkstemp()...
 877     #if wxUSE_FILE
 878         if ( fileTemp && !fileTemp->IsOpened() )
 879         {
 880             *deleteOnClose = wantDeleteOnClose;
 881             int fd = wxTempOpen(path, deleteOnClose);
 882             if (fd != -1)
 883                 fileTemp->Attach(fd);
 884             else
 885                 ok = false;
 886         }
 887     #endif
 888
 889     #if wxUSE_FFILE
 890         if ( ffileTemp && !ffileTemp->IsOpened() )
 891         {
 892             *deleteOnClose = wantDeleteOnClose;
 893             ok = wxTempOpen(ffileTemp, path, deleteOnClose);
 894         }
 895     #endif
 896
 897         if ( !ok )
 898         {
 899             // FIXME: If !ok here should we loop and try again with another
 900             //        file name?  That is the standard recourse if open(O_EXCL)
 901             //        fails, though of course it should be protected against
 902             //        possible infinite looping too.
 903
 904             wxLogError(_("Failed to open temporary file."));
 905
 906             path.clear();
 907         }
 908     }
 909
 910     return path;
 911 }
 912
 913
 914 static bool wxCreateTempImpl(
 915         const wxString& prefix,
 916         WXFILEARGS(wxFile *fileTemp, wxFFile *ffileTemp),
 917         wxString *name)
 918 {
 919     bool deleteOnClose = true;
 920
 921     *name = wxCreateTempImpl(prefix,
 922                              WXFILEARGS(fileTemp, ffileTemp),
 923                              &deleteOnClose);
 924
 925     bool ok = !name->empty();
 926
 927     if (deleteOnClose)
 928         name->clear();
 929 #ifdef __UNIX__
 930     else if (ok && wxRemoveFile(*name))
 931         name->clear();
 932 #endif
 933
 934     return ok;
 935 }
 936
 937
 938 static void wxAssignTempImpl(
 939         wxFileName *fn,
 940         const wxString& prefix,
 941         WXFILEARGS(wxFile *fileTemp, wxFFile *ffileTemp))
 942 {
 943     wxString tempname;
 944     tempname = wxCreateTempImpl(prefix, WXFILEARGS(fileTemp, ffileTemp));
 945
 946     if ( tempname.empty() )
 947     {
 948         // error, failed to get temp file name
 949         fn->Clear();
 950     }
 951     else // ok
 952     {
 953         fn->Assign(tempname);
 954     }
 955 }
 956
 957
 958 void wxFileName::AssignTempFileName(const wxString& prefix)
 959 {
 960     wxAssignTempImpl(this, prefix, WXFILEARGS(NULL, NULL));
 961 }
 962
 963 /* static */
 964 wxString wxFileName::CreateTempFileName(const wxString& prefix)
 965 {
 966     return wxCreateTempImpl(prefix, WXFILEARGS(NULL, NULL));
 967 }
 968
 969 #endif // wxUSE_FILE || wxUSE_FFILE
 970
 971
 972 #if wxUSE_FILE
 973
 974 wxString wxCreateTempFileName(const wxString& prefix,
 975                               wxFile *fileTemp,
 976                               bool *deleteOnClose)
 977 {
 978     return wxCreateTempImpl(prefix, WXFILEARGS(fileTemp, NULL), deleteOnClose);
 979 }
 980
 981 bool wxCreateTempFile(const wxString& prefix,
 982                       wxFile *fileTemp,
 983                       wxString *name)
 984 {
 985     return wxCreateTempImpl(prefix, WXFILEARGS(fileTemp, NULL), name);
 986 }
 987
 988 void wxFileName::AssignTempFileName(const wxString& prefix, wxFile *fileTemp)
 989 {
 990     wxAssignTempImpl(this, prefix, WXFILEARGS(fileTemp, NULL));
 991 }
 992
 993 /* static */
 994 wxString
 995 wxFileName::CreateTempFileName(const wxString& prefix, wxFile *fileTemp)
 996 {
 997     return wxCreateTempFileName(prefix, fileTemp);
 998 }
 999
1000 #endif // wxUSE_FILE
1001
1002
1003 #if wxUSE_FFILE
1004
1005 wxString wxCreateTempFileName(const wxString& prefix,
1006                               wxFFile *fileTemp,
1007                               bool *deleteOnClose)
1008 {
1009     return wxCreateTempImpl(prefix, WXFILEARGS(NULL, fileTemp), deleteOnClose);
1010 }
1011
1012 bool wxCreateTempFile(const wxString& prefix,
1013                       wxFFile *fileTemp,
1014                       wxString *name)
1015 {
1016     return wxCreateTempImpl(prefix, WXFILEARGS(NULL, fileTemp), name);
1017
1018 }
1019
1020 void wxFileName::AssignTempFileName(const wxString& prefix, wxFFile *fileTemp)
1021 {
1022     wxAssignTempImpl(this, prefix, WXFILEARGS(NULL, fileTemp));
1023 }
1024
1025 /* static */
1026 wxString
1027 wxFileName::CreateTempFileName(const wxString& prefix, wxFFile *fileTemp)
1028 {
1029     return wxCreateTempFileName(prefix, fileTemp);
1030 }
1031
1032 #endif // wxUSE_FFILE
1033
1034
1035 // ----------------------------------------------------------------------------
1036 // directory operations
1037 // ----------------------------------------------------------------------------
1038
1039 bool wxFileName::Mkdir( int perm, int flags )
1040 {
1041     return wxFileName::Mkdir(GetPath(), perm, flags);
1042 }
1043
1044 bool wxFileName::Mkdir( const wxString& dir, int perm, int flags )
1045 {
1046     if ( flags & wxPATH_MKDIR_FULL )
1047     {
1048         // split the path in components
1049         wxFileName filename;
1050         filename.AssignDir(dir);
1051
1052         wxString currPath;
1053         if ( filename.HasVolume())
1054         {
1055             currPath << wxGetVolumeString(filename.GetVolume(), wxPATH_NATIVE);
1056         }
1057
1058         wxArrayString dirs = filename.GetDirs();
1059         size_t count = dirs.GetCount();
1060         for ( size_t i = 0; i < count; i++ )
1061         {
1062             if ( i > 0 ||
1063 #if defined(__WXMAC__) && !defined(__DARWIN__)
1064             // relative pathnames are exactely the other way round under mac...
1065                 !filename.IsAbsolute()
1066 #else
1067                 filename.IsAbsolute()
1068 #endif
1069             )
1070                 currPath += wxFILE_SEP_PATH;
1071             currPath += dirs[i];
1072
1073             if (!DirExists(currPath))
1074             {
1075                 if (!wxMkdir(currPath, perm))
1076                 {
1077                     // no need to try creating further directories
1078                     return false;
1079                 }
1080             }
1081         }
1082
1083         return true;
1084
1085     }
1086
1087     return ::wxMkdir( dir, perm );
1088 }
1089
1090 bool wxFileName::Rmdir()
1091 {
1092     return wxFileName::Rmdir( GetPath() );
1093 }
1094
1095 bool wxFileName::Rmdir( const wxString &dir )
1096 {
1097     return ::wxRmdir( dir );
1098 }
1099
1100 // ----------------------------------------------------------------------------
1101 // path normalization
1102 // ----------------------------------------------------------------------------
1103
1104 bool wxFileName::Normalize(int flags,
1105                            const wxString& cwd,
1106                            wxPathFormat format)
1107 {
1108     // deal with env vars renaming first as this may seriously change the path
1109     if ( flags & wxPATH_NORM_ENV_VARS )
1110     {
1111         wxString pathOrig = GetFullPath(format);
1112         wxString path = wxExpandEnvVars(pathOrig);
1113         if ( path != pathOrig )
1114         {
1115             Assign(path);
1116         }
1117     }
1118
1119
1120     // the existing path components
1121     wxArrayString dirs = GetDirs();
1122
1123     // the path to prepend in front to make the path absolute
1124     wxFileName curDir;
1125
1126     format = GetFormat(format);
1127
1128     // make the path absolute
1129     if ( (flags & wxPATH_NORM_ABSOLUTE) && !IsAbsolute(format) )
1130     {
1131         if ( cwd.empty() )
1132         {
1133             curDir.AssignCwd(GetVolume());
1134         }
1135         else // cwd provided
1136         {
1137             curDir.AssignDir(cwd);
1138         }
1139
1140         // the path may be not absolute because it doesn't have the volume name
1141         // but in this case we shouldn't modify the directory components of it
1142         // but just set the current volume
1143         if ( !HasVolume() && curDir.HasVolume() )
1144         {
1145             SetVolume(curDir.GetVolume());
1146
1147             if ( !m_relative )
1148             {
1149                 // yes, it was the case - we don't need curDir then
1150                 curDir.Clear();
1151             }
1152         }
1153     }
1154
1155     // handle ~ stuff under Unix only
1156     if ( (format == wxPATH_UNIX) && (flags & wxPATH_NORM_TILDE) )
1157     {
1158         if ( !dirs.IsEmpty() )
1159         {
1160             wxString dir = dirs[0u];
1161             if ( !dir.empty() && dir[0u] == _T('~') )
1162             {
1163                 curDir.AssignDir(wxGetUserHome(dir.c_str() + 1));
1164
1165                 dirs.RemoveAt(0u);
1166             }
1167         }
1168     }
1169
1170     // transform relative path into abs one
1171     if ( curDir.IsOk() )
1172     {
1173         wxArrayString dirsNew = curDir.GetDirs();
1174         size_t count = dirs.GetCount();
1175         for ( size_t n = 0; n < count; n++ )
1176         {
1177             dirsNew.Add(dirs[n]);
1178         }
1179
1180         dirs = dirsNew;
1181     }
1182
1183     // now deal with ".", ".." and the rest
1184     m_dirs.Empty();
1185     size_t count = dirs.GetCount();
1186     for ( size_t n = 0; n < count; n++ )
1187     {
1188         wxString dir = dirs[n];
1189
1190         if ( flags & wxPATH_NORM_DOTS )
1191         {
1192             if ( dir == wxT(".") )
1193             {
1194                 // just ignore
1195                 continue;
1196             }
1197
1198             if ( dir == wxT("..") )
1199             {
1200                 if ( m_dirs.IsEmpty() )
1201                 {
1202                     wxLogError(_("The path '%s' contains too many \"..\"!"),
1203                                GetFullPath().c_str());
1204                     return false;
1205                 }
1206
1207                 m_dirs.RemoveAt(m_dirs.GetCount() - 1);
1208                 continue;
1209             }
1210         }
1211
1212         if ( (flags & wxPATH_NORM_CASE) && !IsCaseSensitive(format) )
1213         {
1214             dir.MakeLower();
1215         }
1216
1217         m_dirs.Add(dir);
1218     }
1219
1220 #if defined(__WIN32__) && !defined(__WXWINCE__) && wxUSE_OLE
1221     if ( (flags & wxPATH_NORM_SHORTCUT) )
1222     {
1223         wxString filename;
1224         if (GetShortcutTarget(GetFullPath(format), filename))
1225         {
1226             // Repeat this since we may now have a new path
1227             if ( (flags & wxPATH_NORM_CASE) && !IsCaseSensitive(format) )
1228             {
1229                 filename.MakeLower();
1230             }
1231             m_relative = false;
1232             Assign(filename);
1233         }
1234     }
1235 #endif
1236
1237     if ( (flags & wxPATH_NORM_CASE) && !IsCaseSensitive(format) )
1238     {
1239         // VZ: expand env vars here too?
1240
1241         m_volume.MakeLower();
1242         m_name.MakeLower();
1243         m_ext.MakeLower();
1244     }
1245
1246     // we do have the path now
1247     //
1248     // NB: need to do this before (maybe) calling Assign() below
1249     m_relative = false;
1250
1251 #if defined(__WIN32__)
1252     if ( (flags & wxPATH_NORM_LONG) && (format == wxPATH_DOS) )
1253     {
1254         Assign(GetLongPath());
1255     }
1256 #endif // Win32
1257
1258     return true;
1259 }
1260
1261 // ----------------------------------------------------------------------------
1262 // get the shortcut target
1263 // ----------------------------------------------------------------------------
1264
1265 // WinCE (3) doesn't have CLSID_ShellLink, IID_IShellLink definitions.
1266 // The .lnk file is a plain text file so it should be easy to
1267 // make it work. Hint from Google Groups:
1268 // "If you open up a lnk file, you'll see a
1269 // number, followed by a pound sign (#), followed by more text. The
1270 // number is the number of characters that follows the pound sign. The
1271 // characters after the pound sign are the command line (which _can_
1272 // include arguments) to be executed. Any path (e.g. \windows\program
1273 // files\myapp.exe) that includes spaces needs to be enclosed in
1274 // quotation marks."
1275
1276 #if defined(__WIN32__) && !defined(__WXWINCE__) && wxUSE_OLE
1277 // The following lines are necessary under WinCE
1278 // #include "wx/msw/private.h"
1279 // #include <ole2.h>
1280 #include <shlobj.h>
1281 #if defined(__WXWINCE__)
1282 #include <shlguid.h>
1283 #endif
1284
1285 bool wxFileName::GetShortcutTarget(const wxString& shortcutPath,
1286                                    wxString& targetFilename,
1287                                    wxString* arguments)
1288 {
1289     wxString path, file, ext;
1290     wxSplitPath(shortcutPath, & path, & file, & ext);
1291
1292     HRESULT hres;
1293     IShellLink* psl;
1294     bool success = false;
1295
1296     // Assume it's not a shortcut if it doesn't end with lnk
1297     if (ext.CmpNoCase(wxT("lnk"))!=0)
1298         return false;
1299
1300     // create a ShellLink object
1301     hres = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
1302                             IID_IShellLink, (LPVOID*) &psl);
1303
1304     if (SUCCEEDED(hres))
1305     {
1306         IPersistFile* ppf;
1307         hres = psl->QueryInterface( IID_IPersistFile, (LPVOID *) &ppf);
1308         if (SUCCEEDED(hres))
1309         {
1310             WCHAR wsz[MAX_PATH];
1311
1312             MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, shortcutPath.mb_str(), -1, wsz,
1313                                 MAX_PATH);
1314
1315             hres = ppf->Load(wsz, 0);
1316             ppf->Release();
1317
1318             if (SUCCEEDED(hres))
1319             {
1320                 wxChar buf[2048];
1321                 // Wrong prototype in early versions
1322 #if defined(__MINGW32__) && !wxCHECK_W32API_VERSION(2, 2)
1323                 psl->GetPath((CHAR*) buf, 2048, NULL, SLGP_UNCPRIORITY);
1324 #else
1325                 psl->GetPath(buf, 2048, NULL, SLGP_UNCPRIORITY);
1326 #endif
1327                 targetFilename = wxString(buf);
1328                 success = (shortcutPath != targetFilename);
1329
1330                 psl->GetArguments(buf, 2048);
1331                 wxString args(buf);
1332                 if (!args.empty() && arguments)
1333                 {
1334                     *arguments = args;
1335                 }
1336             }
1337         }
1338
1339         psl->Release();
1340     }
1341     return success;
1342 }
1343
1344 #endif // __WIN32__ && !__WXWINCE__
1345
1346
1347 // ----------------------------------------------------------------------------
1348 // absolute/relative paths
1349 // ----------------------------------------------------------------------------
1350
1351 bool wxFileName::IsAbsolute(wxPathFormat format) const
1352 {
1353     // if our path doesn't start with a path separator, it's not an absolute
1354     // path
1355     if ( m_relative )
1356         return false;
1357
1358     if ( !GetVolumeSeparator(format).empty() )
1359     {
1360         // this format has volumes and an absolute path must have one, it's not
1361         // enough to have the full path to bean absolute file under Windows
1362         if ( GetVolume().empty() )
1363             return false;
1364     }
1365
1366     return true;
1367 }
1368
1369 bool wxFileName::MakeRelativeTo(const wxString& pathBase, wxPathFormat format)
1370 {
1371     wxFileName fnBase = wxFileName::DirName(pathBase, format);
1372
1373     // get cwd only once - small time saving
1374     wxString cwd = wxGetCwd();
1375     Normalize(wxPATH_NORM_ALL & ~wxPATH_NORM_CASE, cwd, format);
1376     fnBase.Normalize(wxPATH_NORM_ALL & ~wxPATH_NORM_CASE, cwd, format);
1377
1378     bool withCase = IsCaseSensitive(format);
1379
1380     // we can't do anything if the files live on different volumes
1381     if ( !GetVolume().IsSameAs(fnBase.GetVolume(), withCase) )
1382     {
1383         // nothing done
1384         return false;
1385     }
1386
1387     // same drive, so we don't need our volume
1388     m_volume.clear();
1389
1390     // remove common directories starting at the top
1391     while ( !m_dirs.IsEmpty() && !fnBase.m_dirs.IsEmpty() &&
1392                 m_dirs[0u].IsSameAs(fnBase.m_dirs[0u], withCase) )
1393     {
1394         m_dirs.RemoveAt(0);
1395         fnBase.m_dirs.RemoveAt(0);
1396     }
1397
1398     // add as many ".." as needed
1399     size_t count = fnBase.m_dirs.GetCount();
1400     for ( size_t i = 0; i < count; i++ )
1401     {
1402         m_dirs.Insert(wxT(".."), 0u);
1403     }
1404
1405     if ( format == wxPATH_UNIX || format == wxPATH_DOS )
1406     {
1407         // a directory made relative with respect to itself is '.' under Unix
1408         // and DOS, by definition (but we don't have to insert "./" for the
1409         // files)
1410         if ( m_dirs.IsEmpty() && IsDir() )
1411         {
1412             m_dirs.Add(_T('.'));
1413         }
1414     }
1415
1416     m_relative = true;
1417
1418     // we were modified
1419     return true;
1420 }
1421
1422 // ----------------------------------------------------------------------------
1423 // filename kind tests
1424 // ----------------------------------------------------------------------------
1425
1426 bool wxFileName::SameAs(const wxFileName& filepath, wxPathFormat format) const
1427 {
1428     wxFileName fn1 = *this,
1429                fn2 = filepath;
1430
1431     // get cwd only once - small time saving
1432     wxString cwd = wxGetCwd();
1433     fn1.Normalize(wxPATH_NORM_ALL | wxPATH_NORM_CASE, cwd, format);
1434     fn2.Normalize(wxPATH_NORM_ALL | wxPATH_NORM_CASE, cwd, format);
1435
1436     if ( fn1.GetFullPath() == fn2.GetFullPath() )
1437         return true;
1438
1439     // TODO: compare inodes for Unix, this works even when filenames are
1440     //       different but files are the same (symlinks) (VZ)
1441
1442     return false;
1443 }
1444
1445 /* static */
1446 bool wxFileName::IsCaseSensitive( wxPathFormat format )
1447 {
1448     // only Unix filenames are truely case-sensitive
1449     return GetFormat(format) == wxPATH_UNIX;
1450 }
1451
1452 /* static */
1453 wxString wxFileName::GetForbiddenChars(wxPathFormat format)
1454 {
1455     // Inits to forbidden characters that are common to (almost) all platforms.
1456     wxString strForbiddenChars = wxT("*?");
1457
1458     // If asserts, wxPathFormat has been changed. In case of a new path format
1459     // addition, the following code might have to be updated.
1460     wxCOMPILE_TIME_ASSERT(wxPATH_MAX == 5, wxPathFormatChanged);
1461     switch ( GetFormat(format) )
1462     {
1463         default :
1464             wxFAIL_MSG( wxT("Unknown path format") );
1465             // !! Fall through !!
1466
1467         case wxPATH_UNIX:
1468             break;
1469
1470         case wxPATH_MAC:
1471             // On a Mac even names with * and ? are allowed (Tested with OS
1472             // 9.2.1 and OS X 10.2.5)
1473             strForbiddenChars = wxEmptyString;
1474             break;
1475
1476         case wxPATH_DOS:
1477             strForbiddenChars += wxT("\\/:\"<>|");
1478             break;
1479
1480         case wxPATH_VMS:
1481             break;
1482     }
1483
1484     return strForbiddenChars;
1485 }
1486
1487 /* static */
1488 wxString wxFileName::GetVolumeSeparator(wxPathFormat WXUNUSED_IN_WINCE(format))
1489 {
1490 #ifdef __WXWINCE__
1491     return wxEmptyString;
1492 #else
1493     wxString sepVol;
1494
1495     if ( (GetFormat(format) == wxPATH_DOS) ||
1496          (GetFormat(format) == wxPATH_VMS) )
1497     {
1498         sepVol = wxFILE_SEP_DSK;
1499     }
1500     //else: leave empty
1501
1502     return sepVol;
1503 #endif
1504 }
1505
1506 /* static */
1507 wxString wxFileName::GetPathSeparators(wxPathFormat format)
1508 {
1509     wxString seps;
1510     switch ( GetFormat(format) )
1511     {
1512         case wxPATH_DOS:
1513             // accept both as native APIs do but put the native one first as
1514             // this is the one we use in GetFullPath()
1515             seps << wxFILE_SEP_PATH_DOS << wxFILE_SEP_PATH_UNIX;
1516             break;
1517
1518         default:
1519             wxFAIL_MSG( _T("Unknown wxPATH_XXX style") );
1520             // fall through
1521
1522         case wxPATH_UNIX:
1523             seps = wxFILE_SEP_PATH_UNIX;
1524             break;
1525
1526         case wxPATH_MAC:
1527             seps = wxFILE_SEP_PATH_MAC;
1528             break;
1529
1530         case wxPATH_VMS:
1531             seps = wxFILE_SEP_PATH_VMS;
1532             break;
1533     }
1534
1535     return seps;
1536 }
1537
1538 /* static */
1539 wxString wxFileName::GetPathTerminators(wxPathFormat format)
1540 {
1541     format = GetFormat(format);
1542
1543     // under VMS the end of the path is ']', not the path separator used to
1544     // separate the components
1545     return format == wxPATH_VMS ? wxString(_T(']')) : GetPathSeparators(format);
1546 }
1547
1548 /* static */
1549 bool wxFileName::IsPathSeparator(wxChar ch, wxPathFormat format)
1550 {
1551     // wxString::Find() doesn't work as expected with NUL - it will always find
1552     // it, so test for it separately
1553     return ch != _T('\0') && GetPathSeparators(format).Find(ch) != wxNOT_FOUND;
1554 }
1555
1556 // ----------------------------------------------------------------------------
1557 // path components manipulation
1558 // ----------------------------------------------------------------------------
1559
1560 /* static */ bool wxFileName::IsValidDirComponent(const wxString& dir)
1561 {
1562     if ( dir.empty() )
1563     {
1564         wxFAIL_MSG( _T("empty directory passed to wxFileName::InsertDir()") );
1565
1566         return false;
1567     }
1568
1569     const size_t len = dir.length();
1570     for ( size_t n = 0; n < len; n++ )
1571     {
1572         if ( dir[n] == GetVolumeSeparator() || IsPathSeparator(dir[n]) )
1573         {
1574             wxFAIL_MSG( _T("invalid directory component in wxFileName") );
1575
1576             return false;
1577         }
1578     }
1579
1580     return true;
1581 }
1582
1583 void wxFileName::AppendDir( const wxString& dir )
1584 {
1585     if ( IsValidDirComponent(dir) )
1586         m_dirs.Add( dir );
1587 }
1588
1589 void wxFileName::PrependDir( const wxString& dir )
1590 {
1591     InsertDir(0, dir);
1592 }
1593
1594 void wxFileName::InsertDir(size_t before, const wxString& dir)
1595 {
1596     if ( IsValidDirComponent(dir) )
1597         m_dirs.Insert(dir, before);
1598 }
1599
1600 void wxFileName::RemoveDir(size_t pos)
1601 {
1602     m_dirs.RemoveAt(pos);
1603 }
1604
1605 // ----------------------------------------------------------------------------
1606 // accessors
1607 // ----------------------------------------------------------------------------
1608
1609 void wxFileName::SetFullName(const wxString& fullname)
1610 {
1611     SplitPath(fullname, NULL /* no volume */, NULL /* no path */,
1612                         &m_name, &m_ext, &m_hasExt);
1613 }
1614
1615 wxString wxFileName::GetFullName() const
1616 {
1617     wxString fullname = m_name;
1618     if ( m_hasExt )
1619     {
1620         fullname << wxFILE_SEP_EXT << m_ext;
1621     }
1622
1623     return fullname;
1624 }
1625
1626 wxString wxFileName::GetPath( int flags, wxPathFormat format ) const
1627 {
1628     format = GetFormat( format );
1629
1630     wxString fullpath;
1631
1632     // return the volume with the path as well if requested
1633     if ( flags & wxPATH_GET_VOLUME )
1634     {
1635         fullpath += wxGetVolumeString(GetVolume(), format);
1636     }
1637
1638     // the leading character
1639     switch ( format )
1640     {
1641         case wxPATH_MAC:
1642             if ( m_relative )
1643                 fullpath += wxFILE_SEP_PATH_MAC;
1644             break;
1645
1646         case wxPATH_DOS:
1647             if ( !m_relative )
1648                 fullpath += wxFILE_SEP_PATH_DOS;
1649             break;
1650
1651         default:
1652             wxFAIL_MSG( wxT("Unknown path format") );
1653             // fall through
1654
1655         case wxPATH_UNIX:
1656             if ( !m_relative )
1657             {
1658                 // normally the absolute file names start with a slash
1659                 // with one exception: the ones like "~/foo.bar" don't
1660                 // have it
1661                 if ( m_dirs.IsEmpty() || m_dirs[0u] != _T('~') )
1662                 {
1663                     fullpath += wxFILE_SEP_PATH_UNIX;
1664                 }
1665             }
1666             break;
1667
1668         case wxPATH_VMS:
1669             // no leading character here but use this place to unset
1670             // wxPATH_GET_SEPARATOR flag: under VMS it doesn't make sense
1671             // as, if I understand correctly, there should never be a dot
1672             // before the closing bracket
1673             flags &= ~wxPATH_GET_SEPARATOR;
1674     }
1675
1676     if ( m_dirs.empty() )
1677     {
1678         // there is nothing more
1679         return fullpath;
1680     }
1681
1682     // then concatenate all the path components using the path separator
1683     if ( format == wxPATH_VMS )
1684     {
1685         fullpath += wxT('[');
1686     }
1687
1688     const size_t dirCount = m_dirs.GetCount();
1689     for ( size_t i = 0; i < dirCount; i++ )
1690     {
1691         switch (format)
1692         {
1693             case wxPATH_MAC:
1694                 if ( m_dirs[i] == wxT(".") )
1695                 {
1696                     // skip appending ':', this shouldn't be done in this
1697                     // case as "::" is interpreted as ".." under Unix
1698                     continue;
1699                 }
1700
1701                 // convert back from ".." to nothing
1702                 if ( !m_dirs[i].IsSameAs(wxT("..")) )
1703                      fullpath += m_dirs[i];
1704                 break;
1705
1706             default:
1707                 wxFAIL_MSG( wxT("Unexpected path format") );
1708                 // still fall through
1709
1710             case wxPATH_DOS:
1711             case wxPATH_UNIX:
1712                 fullpath += m_dirs[i];
1713                 break;
1714
1715             case wxPATH_VMS:
1716                 // TODO: What to do with ".." under VMS
1717
1718                 // convert back from ".." to nothing
1719                 if ( !m_dirs[i].IsSameAs(wxT("..")) )
1720                     fullpath += m_dirs[i];
1721                 break;
1722         }
1723
1724         if ( (flags & wxPATH_GET_SEPARATOR) || (i != dirCount - 1) )
1725             fullpath += GetPathSeparator(format);
1726     }
1727
1728     if ( format == wxPATH_VMS )
1729     {
1730         fullpath += wxT(']');
1731     }
1732
1733     return fullpath;
1734 }
1735
1736 wxString wxFileName::GetFullPath( wxPathFormat format ) const
1737 {
1738     // we already have a function to get the path
1739     wxString fullpath = GetPath(wxPATH_GET_VOLUME | wxPATH_GET_SEPARATOR,
1740                                 format);
1741
1742     // now just add the file name and extension to it
1743     fullpath += GetFullName();
1744
1745     return fullpath;
1746 }
1747
1748 // Return the short form of the path (returns identity on non-Windows platforms)
1749 wxString wxFileName::GetShortPath() const
1750 {
1751     wxString path(GetFullPath());
1752
1753 #if defined(__WXMSW__) && defined(__WIN32__) && !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
1754     DWORD sz = ::GetShortPathName(path, NULL, 0);
1755     if ( sz != 0 )
1756     {
1757         wxString pathOut;
1758         if ( ::GetShortPathName
1759                (
1760                 path,
1761                 wxStringBuffer(pathOut, sz),
1762                 sz
1763                ) != 0 )
1764         {
1765             return pathOut;
1766         }
1767     }
1768 #endif // Windows
1769
1770     return path;
1771 }
1772
1773 // Return the long form of the path (returns identity on non-Windows platforms)
1774 wxString wxFileName::GetLongPath() const
1775 {
1776     wxString pathOut,
1777              path = GetFullPath();
1778
1779 #if defined(__WIN32__) && !defined(__WXMICROWIN__)
1780
1781 #if wxUSE_DYNAMIC_LOADER
1782     typedef DWORD (WINAPI *GET_LONG_PATH_NAME)(const wxChar *, wxChar *, DWORD);
1783
1784     // this is MT-safe as in the worst case we're going to resolve the function
1785     // twice -- but as the result is the same in both threads, it's ok
1786     static GET_LONG_PATH_NAME s_pfnGetLongPathName = NULL;
1787     if ( !s_pfnGetLongPathName )
1788     {
1789         static bool s_triedToLoad = false;
1790
1791         if ( !s_triedToLoad )
1792         {
1793             s_triedToLoad = true;
1794
1795             wxDynamicLibrary dllKernel(_T("kernel32"));
1796
1797             const wxChar* GetLongPathName = _T("GetLongPathName")
1798 #if wxUSE_UNICODE
1799                               _T("W");
1800 #else // ANSI
1801                               _T("A");
1802 #endif // Unicode/ANSI
1803
1804             if ( dllKernel.HasSymbol(GetLongPathName) )
1805             {
1806                 s_pfnGetLongPathName = (GET_LONG_PATH_NAME)
1807                     dllKernel.GetSymbol(GetLongPathName);
1808             }
1809
1810             // note that kernel32.dll can be unloaded, it stays in memory
1811             // anyhow as all Win32 programs link to it and so it's safe to call
1812             // GetLongPathName() even after unloading it
1813         }
1814     }
1815
1816     if ( s_pfnGetLongPathName )
1817     {
1818         DWORD dwSize = (*s_pfnGetLongPathName)(path, NULL, 0);
1819         if ( dwSize > 0 )
1820         {
1821             if ( (*s_pfnGetLongPathName)
1822                  (
1823                   path,
1824                   wxStringBuffer(pathOut, dwSize),
1825                   dwSize
1826                  ) != 0 )
1827             {
1828                 return pathOut;
1829             }
1830         }
1831     }
1832 #endif // wxUSE_DYNAMIC_LOADER
1833
1834     // The OS didn't support GetLongPathName, or some other error.
1835     // We need to call FindFirstFile on each component in turn.
1836
1837     WIN32_FIND_DATA findFileData;
1838     HANDLE hFind;
1839
1840     if ( HasVolume() )
1841         pathOut = GetVolume() +
1842                   GetVolumeSeparator(wxPATH_DOS) +
1843                   GetPathSeparator(wxPATH_DOS);
1844     else
1845         pathOut = wxEmptyString;
1846
1847     wxArrayString dirs = GetDirs();
1848     dirs.Add(GetFullName());
1849
1850     wxString tmpPath;
1851
1852     size_t count = dirs.GetCount();
1853     for ( size_t i = 0; i < count; i++ )
1854     {
1855         // We're using pathOut to collect the long-name path, but using a
1856         // temporary for appending the last path component which may be
1857         // short-name
1858         tmpPath = pathOut + dirs[i];
1859
1860         if ( tmpPath.empty() )
1861             continue;
1862
1863         // can't see this being necessary? MF
1864         if ( tmpPath.Last() == GetVolumeSeparator(wxPATH_DOS) )
1865         {
1866             // Can't pass a drive and root dir to FindFirstFile,
1867             // so continue to next dir
1868             tmpPath += wxFILE_SEP_PATH;
1869             pathOut = tmpPath;
1870             continue;
1871         }
1872
1873         hFind = ::FindFirstFile(tmpPath, &findFileData);
1874         if (hFind == INVALID_HANDLE_VALUE)
1875         {
1876             // Error: most likely reason is that path doesn't exist, so
1877             // append any unprocessed parts and return
1878             for ( i += 1; i < count; i++ )
1879                 tmpPath += wxFILE_SEP_PATH + dirs[i];
1880
1881             return tmpPath;
1882         }
1883
1884         pathOut += findFileData.cFileName;
1885         if ( (i < (count-1)) )
1886             pathOut += wxFILE_SEP_PATH;
1887
1888         ::FindClose(hFind);
1889     }
1890 #else // !Win32
1891     pathOut = path;
1892 #endif // Win32/!Win32
1893
1894     return pathOut;
1895 }
1896
1897 wxPathFormat wxFileName::GetFormat( wxPathFormat format )
1898 {
1899     if (format == wxPATH_NATIVE)
1900     {
1901 #if defined(__WXMSW__) || defined(__OS2__) || defined(__DOS__)
1902         format = wxPATH_DOS;
1903 #elif defined(__WXMAC__) && !defined(__DARWIN__)
1904         format = wxPATH_MAC;
1905 #elif defined(__VMS)
1906         format = wxPATH_VMS;
1907 #else
1908         format = wxPATH_UNIX;
1909 #endif
1910     }
1911     return format;
1912 }
1913
1914 // ----------------------------------------------------------------------------
1915 // path splitting function
1916 // ----------------------------------------------------------------------------
1917
1918 /* static */
1919 void
1920 wxFileName::SplitVolume(const wxString& fullpathWithVolume,
1921                         wxString *pstrVolume,
1922                         wxString *pstrPath,
1923                         wxPathFormat format)
1924 {
1925     format = GetFormat(format);
1926
1927     wxString fullpath = fullpathWithVolume;
1928
1929     // special Windows UNC paths hack: transform \\share\path into share:path
1930     if ( format == wxPATH_DOS )
1931     {
1932         if ( fullpath.length() >= 4 &&
1933                 fullpath[0u] == wxFILE_SEP_PATH_DOS &&
1934                     fullpath[1u] == wxFILE_SEP_PATH_DOS )
1935         {
1936             fullpath.erase(0, 2);
1937
1938             size_t posFirstSlash =
1939                 fullpath.find_first_of(GetPathTerminators(format));
1940             if ( posFirstSlash != wxString::npos )
1941             {
1942                 fullpath[posFirstSlash] = wxFILE_SEP_DSK;
1943
1944                 // UNC paths are always absolute, right? (FIXME)
1945                 fullpath.insert(posFirstSlash + 1, 1, wxFILE_SEP_PATH_DOS);
1946             }
1947         }
1948     }
1949
1950     // We separate the volume here
1951     if ( format == wxPATH_DOS || format == wxPATH_VMS )
1952     {
1953         wxString sepVol = GetVolumeSeparator(format);
1954
1955         size_t posFirstColon = fullpath.find_first_of(sepVol);
1956         if ( posFirstColon != wxString::npos )
1957         {
1958             if ( pstrVolume )
1959             {
1960                 *pstrVolume = fullpath.Left(posFirstColon);
1961             }
1962
1963             // remove the volume name and the separator from the full path
1964             fullpath.erase(0, posFirstColon + sepVol.length());
1965         }
1966     }
1967
1968     if ( pstrPath )
1969         *pstrPath = fullpath;
1970 }
1971
1972 /* static */
1973 void wxFileName::SplitPath(const wxString& fullpathWithVolume,
1974                            wxString *pstrVolume,
1975                            wxString *pstrPath,
1976                            wxString *pstrName,
1977                            wxString *pstrExt,
1978                            bool *hasExt,
1979                            wxPathFormat format)
1980 {
1981     format = GetFormat(format);
1982
1983     wxString fullpath;
1984     SplitVolume(fullpathWithVolume, pstrVolume, &fullpath, format);
1985
1986     // find the positions of the last dot and last path separator in the path
1987     size_t posLastDot = fullpath.find_last_of(wxFILE_SEP_EXT);
1988     size_t posLastSlash = fullpath.find_last_of(GetPathTerminators(format));
1989
1990     // check whether this dot occurs at the very beginning of a path component
1991     if ( (posLastDot != wxString::npos) &&
1992          (posLastDot == 0 ||
1993             IsPathSeparator(fullpath[posLastDot - 1]) ||
1994             (format == wxPATH_VMS && fullpath[posLastDot - 1] == _T(']'))) )
1995     {
1996         // dot may be (and commonly -- at least under Unix -- is) the first
1997         // character of the filename, don't treat the entire filename as
1998         // extension in this case
1999         posLastDot = wxString::npos;
2000     }
2001
2002     // if we do have a dot and a slash, check that the dot is in the name part
2003     if ( (posLastDot != wxString::npos) &&
2004          (posLastSlash != wxString::npos) &&
2005          (posLastDot < posLastSlash) )
2006     {
2007         // the dot is part of the path, not the start of the extension
2008         posLastDot = wxString::npos;
2009     }
2010
2011     // now fill in the variables provided by user
2012     if ( pstrPath )
2013     {
2014         if ( posLastSlash == wxString::npos )
2015         {
2016             // no path at all
2017             pstrPath->Empty();
2018         }
2019         else
2020         {
2021             // take everything up to the path separator but take care to make
2022             // the path equal to something like '/', not empty, for the files
2023             // immediately under root directory
2024             size_t len = posLastSlash;
2025
2026             // this rule does not apply to mac since we do not start with colons (sep)
2027             // except for relative paths
2028             if ( !len && format != wxPATH_MAC)
2029                 len++;
2030
2031             *pstrPath = fullpath.Left(len);
2032
2033             // special VMS hack: remove the initial bracket
2034             if ( format == wxPATH_VMS )
2035             {
2036                 if ( (*pstrPath)[0u] == _T('[') )
2037                     pstrPath->erase(0, 1);
2038             }
2039         }
2040     }
2041
2042     if ( pstrName )
2043     {
2044         // take all characters starting from the one after the last slash and
2045         // up to, but excluding, the last dot
2046         size_t nStart = posLastSlash == wxString::npos ? 0 : posLastSlash + 1;
2047         size_t count;
2048         if ( posLastDot == wxString::npos )
2049         {
2050             // take all until the end
2051             count = wxString::npos;
2052         }
2053         else if ( posLastSlash == wxString::npos )
2054         {
2055             count = posLastDot;
2056         }
2057         else // have both dot and slash
2058         {
2059             count = posLastDot - posLastSlash - 1;
2060         }
2061
2062         *pstrName = fullpath.Mid(nStart, count);
2063     }
2064
2065     // finally deal with the extension here: we have an added complication that
2066     // extension may be empty (but present) as in "foo." where trailing dot
2067     // indicates the empty extension at the end -- and hence we must remember
2068     // that we have it independently of pstrExt
2069     if ( posLastDot == wxString::npos )
2070     {
2071         // no extension
2072         if ( pstrExt )
2073             pstrExt->clear();
2074         if ( hasExt )
2075             *hasExt = false;
2076     }
2077     else
2078     {
2079         // take everything after the dot
2080         if ( pstrExt )
2081             *pstrExt = fullpath.Mid(posLastDot + 1);
2082         if ( hasExt )
2083             *hasExt = true;
2084     }
2085 }
2086
2087 /* static */
2088 void wxFileName::SplitPath(const wxString& fullpath,
2089                            wxString *path,
2090                            wxString *name,
2091                            wxString *ext,
2092                            wxPathFormat format)
2093 {
2094     wxString volume;
2095     SplitPath(fullpath, &volume, path, name, ext, format);
2096
2097     if ( path )
2098     {
2099         path->Prepend(wxGetVolumeString(volume, format));
2100     }
2101 }
2102
2103 // ----------------------------------------------------------------------------
2104 // time functions
2105 // ----------------------------------------------------------------------------
2106
2107 #if wxUSE_DATETIME
2108
2109 bool wxFileName::SetTimes(const wxDateTime *dtAccess,
2110                           const wxDateTime *dtMod,
2111                           const wxDateTime *dtCreate)
2112 {
2113 #if defined(__WIN32__)
2114     if ( IsDir() )
2115     {
2116         // VZ: please let me know how to do this if you can
2117         wxFAIL_MSG( _T("SetTimes() not implemented for the directories") );
2118     }
2119     else // file
2120     {
2121         wxFileHandle fh(GetFullPath(), wxFileHandle::Write);
2122         if ( fh.IsOk() )
2123         {
2124             FILETIME ftAccess, ftCreate, ftWrite;
2125
2126             if ( dtCreate )
2127                 ConvertWxToFileTime(&ftCreate, *dtCreate);
2128             if ( dtAccess )
2129                 ConvertWxToFileTime(&ftAccess, *dtAccess);
2130             if ( dtMod )
2131                 ConvertWxToFileTime(&ftWrite, *dtMod);
2132
2133             if ( ::SetFileTime(fh,
2134                                dtCreate ? &ftCreate : NULL,
2135                                dtAccess ? &ftAccess : NULL,
2136                                dtMod ? &ftWrite : NULL) )
2137             {
2138                 return true;
2139             }
2140         }
2141     }
2142 #elif defined(__UNIX_LIKE__) || (defined(__DOS__) && defined(__WATCOMC__))
2143     wxUnusedVar(dtCreate);
2144
2145     if ( !dtAccess && !dtMod )
2146     {
2147         // can't modify the creation time anyhow, don't try
2148         return true;
2149     }
2150
2151     // if dtAccess or dtMod is not specified, use the other one (which must be
2152     // non NULL because of the test above) for both times
2153     utimbuf utm;
2154     utm.actime = dtAccess ? dtAccess->GetTicks() : dtMod->GetTicks();
2155     utm.modtime = dtMod ? dtMod->GetTicks() : dtAccess->GetTicks();
2156     if ( utime(GetFullPath().fn_str(), &utm) == 0 )
2157     {
2158         return true;
2159     }
2160 #else // other platform
2161     wxUnusedVar(dtAccess);
2162     wxUnusedVar(dtMod);
2163     wxUnusedVar(dtCreate);
2164 #endif // platforms
2165
2166     wxLogSysError(_("Failed to modify file times for '%s'"),
2167                   GetFullPath().c_str());
2168
2169     return false;
2170 }
2171
2172 bool wxFileName::Touch()
2173 {
2174 #if defined(__UNIX_LIKE__)
2175     // under Unix touching file is simple: just pass NULL to utime()
2176     if ( utime(GetFullPath().fn_str(), NULL) == 0 )
2177     {
2178         return true;
2179     }
2180
2181     wxLogSysError(_("Failed to touch the file '%s'"), GetFullPath().c_str());
2182
2183     return false;
2184 #else // other platform
2185     wxDateTime dtNow = wxDateTime::Now();
2186
2187     return SetTimes(&dtNow, &dtNow, NULL /* don't change create time */);
2188 #endif // platforms
2189 }
2190
2191 bool wxFileName::GetTimes(wxDateTime *dtAccess,
2192                           wxDateTime *dtMod,
2193                           wxDateTime *dtCreate) const
2194 {
2195 #if defined(__WIN32__)
2196     // we must use different methods for the files and directories under
2197     // Windows as CreateFile(GENERIC_READ) doesn't work for the directories and
2198     // CreateFile(FILE_FLAG_BACKUP_SEMANTICS) works -- but only under NT and
2199     // not 9x
2200     bool ok;
2201     FILETIME ftAccess, ftCreate, ftWrite;
2202     if ( IsDir() )
2203     {
2204         // implemented in msw/dir.cpp
2205         extern bool wxGetDirectoryTimes(const wxString& dirname,
2206                                         FILETIME *, FILETIME *, FILETIME *);
2207
2208         // we should pass the path without the trailing separator to
2209         // wxGetDirectoryTimes()
2210         ok = wxGetDirectoryTimes(GetPath(wxPATH_GET_VOLUME),
2211                                  &ftAccess, &ftCreate, &ftWrite);
2212     }
2213     else // file
2214     {
2215         wxFileHandle fh(GetFullPath(), wxFileHandle::Read);
2216         if ( fh.IsOk() )
2217         {
2218             ok = ::GetFileTime(fh,
2219                                dtCreate ? &ftCreate : NULL,
2220                                dtAccess ? &ftAccess : NULL,
2221                                dtMod ? &ftWrite : NULL) != 0;
2222         }
2223         else
2224         {
2225             ok = false;
2226         }
2227     }
2228
2229     if ( ok )
2230     {
2231         if ( dtCreate )
2232             ConvertFileTimeToWx(dtCreate, ftCreate);
2233         if ( dtAccess )
2234             ConvertFileTimeToWx(dtAccess, ftAccess);
2235         if ( dtMod )
2236             ConvertFileTimeToWx(dtMod, ftWrite);
2237
2238         return true;
2239     }
2240 #elif defined(__UNIX_LIKE__) || defined(__WXMAC__) || defined(__OS2__) || (defined(__DOS__) && defined(__WATCOMC__))
2241     wxStructStat stBuf;
2242     if ( wxStat( GetFullPath().c_str(), &stBuf) == 0 )
2243     {
2244         if ( dtAccess )
2245             dtAccess->Set(stBuf.st_atime);
2246         if ( dtMod )
2247             dtMod->Set(stBuf.st_mtime);
2248         if ( dtCreate )
2249             dtCreate->Set(stBuf.st_ctime);
2250
2251         return true;
2252     }
2253 #else // other platform
2254     wxUnusedVar(dtAccess);
2255     wxUnusedVar(dtMod);
2256     wxUnusedVar(dtCreate);
2257 #endif // platforms
2258
2259     wxLogSysError(_("Failed to retrieve file times for '%s'"),
2260                   GetFullPath().c_str());
2261
2262     return false;
2263 }
2264
2265 #endif // wxUSE_DATETIME
2266
2267
2268 // ----------------------------------------------------------------------------
2269 // file size functions
2270 // ----------------------------------------------------------------------------
2271
2272 /* static */
2273 wxULongLong wxFileName::GetSize(const wxString &filename)
2274 {
2275     if (!wxFileExists(filename))
2276         return wxInvalidSize;
2277
2278 #if defined(__WXPALMOS__)
2279     // TODO
2280     return wxInvalidSize;
2281 #elif defined(__WIN32__)
2282     wxFileHandle f(filename, wxFileHandle::Read);
2283     if (!f.IsOk())
2284         return wxInvalidSize;
2285
2286     DWORD lpFileSizeHigh;
2287     DWORD ret = GetFileSize(f, &lpFileSizeHigh);
2288     if (ret == INVALID_FILE_SIZE)
2289         return wxInvalidSize;
2290
2291     // compose the low-order and high-order byte sizes
2292     return wxULongLong(ret | (lpFileSizeHigh << sizeof(WORD)*2));
2293
2294 #else           // ! __WIN32__
2295
2296     wxStructStat st;
2297 #ifndef wxNEED_WX_UNISTD_H
2298     if (wxStat( filename.fn_str() , &st) != 0)
2299 #else
2300     if (wxStat( filename, &st) != 0)
2301 #endif
2302         return wxInvalidSize;
2303     return wxULongLong(st.st_size);
2304 #endif
2305 }
2306
2307 /* static */
2308 wxString wxFileName::GetHumanReadableSize(const wxULongLong &bs,
2309                                           const wxString &nullsize,
2310                                           int precision)
2311 {
2312     static const double KILOBYTESIZE = 1024.0;
2313     static const double MEGABYTESIZE = 1024.0*KILOBYTESIZE;
2314     static const double GIGABYTESIZE = 1024.0*MEGABYTESIZE;
2315     static const double TERABYTESIZE = 1024.0*GIGABYTESIZE;
2316
2317     if (bs == 0 || bs == wxInvalidSize)
2318         return nullsize;
2319
2320     double bytesize = bs.ToDouble();
2321     if (bytesize < KILOBYTESIZE)
2322         return wxString::Format(_("%s B"), bs.ToString().c_str());
2323     if (bytesize < MEGABYTESIZE)
2324         return wxString::Format(_("%.*f kB"), precision, bytesize/KILOBYTESIZE);
2325     if (bytesize < GIGABYTESIZE)
2326         return wxString::Format(_("%.*f MB"), precision, bytesize/MEGABYTESIZE);
2327     if (bytesize < TERABYTESIZE)
2328         return wxString::Format(_("%.*f GB"), precision, bytesize/GIGABYTESIZE);
2329
2330     return wxString::Format(_("%.*f TB"), precision, bytesize/TERABYTESIZE);
2331 }
2332
2333 wxULongLong wxFileName::GetSize() const
2334 {
2335     return GetSize(GetFullPath());
2336 }
2337
2338 wxString wxFileName::GetHumanReadableSize(const wxString &failmsg, int precision) const
2339 {
2340     return GetHumanReadableSize(GetSize(), failmsg, precision);
2341 }
2342
2343
2344 // ----------------------------------------------------------------------------
2345 // Mac-specific functions
2346 // ----------------------------------------------------------------------------
2347
2348 #ifdef __WXMAC__
2349
2350 const short kMacExtensionMaxLength = 16 ;
2351 class MacDefaultExtensionRecord
2352 {
2353 public :
2354   MacDefaultExtensionRecord()
2355   {
2356     m_ext[0] = 0 ;
2357     m_type = m_creator = 0 ;
2358   }
2359   MacDefaultExtensionRecord( const MacDefaultExtensionRecord& from )
2360   {
2361     wxStrcpy( m_ext , from.m_ext ) ;
2362     m_type = from.m_type ;
2363     m_creator = from.m_creator ;
2364   }
2365   MacDefaultExtensionRecord( const wxChar * extension , OSType type , OSType creator )
2366   {
2367     wxStrncpy( m_ext , extension , kMacExtensionMaxLength ) ;
2368     m_ext[kMacExtensionMaxLength] = 0 ;
2369     m_type = type ;
2370     m_creator = creator ;
2371   }
2372   wxChar m_ext[kMacExtensionMaxLength] ;
2373   OSType m_type ;
2374   OSType m_creator ;
2375 }  ;
2376
2377 WX_DECLARE_OBJARRAY(MacDefaultExtensionRecord, MacDefaultExtensionArray) ;
2378
2379 bool gMacDefaultExtensionsInited = false ;
2380
2381 #include "wx/arrimpl.cpp"
2382
2383 WX_DEFINE_EXPORTED_OBJARRAY(MacDefaultExtensionArray) ;
2384
2385 MacDefaultExtensionArray gMacDefaultExtensions ;
2386
2387 // load the default extensions
2388 MacDefaultExtensionRecord gDefaults[] =
2389 {
2390     MacDefaultExtensionRecord( wxT("txt") , 'TEXT' , 'ttxt' ) ,
2391     MacDefaultExtensionRecord( wxT("tif") , 'TIFF' , '****' ) ,
2392     MacDefaultExtensionRecord( wxT("jpg") , 'JPEG' , '****' ) ,
2393 } ;
2394
2395 static void MacEnsureDefaultExtensionsLoaded()
2396 {
2397     if ( !gMacDefaultExtensionsInited )
2398     {
2399         // we could load the pc exchange prefs here too
2400         for ( size_t i = 0 ; i < WXSIZEOF( gDefaults ) ; ++i )
2401         {
2402             gMacDefaultExtensions.Add( gDefaults[i] ) ;
2403         }
2404         gMacDefaultExtensionsInited = true ;
2405     }
2406 }
2407
2408 bool wxFileName::MacSetTypeAndCreator( wxUint32 type , wxUint32 creator )
2409 {
2410     FSRef fsRef ;
2411     FSCatalogInfo catInfo;
2412     FileInfo *finfo ;
2413
2414     if ( wxMacPathToFSRef( GetFullPath() , &fsRef ) == noErr )
2415     {
2416         if ( FSGetCatalogInfo (&fsRef, kFSCatInfoFinderInfo, &catInfo, NULL, NULL, NULL) == noErr )
2417         {
2418             finfo = (FileInfo*)&catInfo.finderInfo;
2419             finfo->fileType = type ;
2420             finfo->fileCreator = creator ;
2421             FSSetCatalogInfo( &fsRef, kFSCatInfoFinderInfo, &catInfo ) ;
2422             return true ;
2423         }
2424     }
2425     return false ;
2426 }
2427
2428 bool wxFileName::MacGetTypeAndCreator( wxUint32 *type , wxUint32 *creator )
2429 {
2430     FSRef fsRef ;
2431     FSCatalogInfo catInfo;
2432     FileInfo *finfo ;
2433
2434     if ( wxMacPathToFSRef( GetFullPath() , &fsRef ) == noErr )
2435     {
2436         if ( FSGetCatalogInfo (&fsRef, kFSCatInfoFinderInfo, &catInfo, NULL, NULL, NULL) == noErr )
2437         {
2438             finfo = (FileInfo*)&catInfo.finderInfo;
2439             *type = finfo->fileType ;
2440             *creator = finfo->fileCreator ;
2441             return true ;
2442         }
2443     }
2444     return false ;
2445 }
2446
2447 bool wxFileName::MacSetDefaultTypeAndCreator()
2448 {
2449     wxUint32 type , creator ;
2450     if ( wxFileName::MacFindDefaultTypeAndCreator(GetExt() , &type ,
2451       &creator ) )
2452     {
2453         return MacSetTypeAndCreator( type , creator ) ;
2454     }
2455     return false;
2456 }
2457
2458 bool wxFileName::MacFindDefaultTypeAndCreator( const wxString& ext , wxUint32 *type , wxUint32 *creator )
2459 {
2460   MacEnsureDefaultExtensionsLoaded() ;
2461   wxString extl = ext.Lower() ;
2462   for( int i = gMacDefaultExtensions.Count() - 1 ; i >= 0 ; --i )
2463   {
2464     if ( gMacDefaultExtensions.Item(i).m_ext == extl )
2465     {
2466       *type = gMacDefaultExtensions.Item(i).m_type ;
2467       *creator = gMacDefaultExtensions.Item(i).m_creator ;
2468       return true ;
2469     }
2470   }
2471   return false ;
2472 }
2473
2474 void wxFileName::MacRegisterDefaultTypeAndCreator( const wxString& ext , wxUint32 type , wxUint32 creator )
2475 {
2476   MacEnsureDefaultExtensionsLoaded() ;
2477   MacDefaultExtensionRecord rec ;
2478   rec.m_type = type ;
2479   rec.m_creator = creator ;
2480   wxStrncpy( rec.m_ext , ext.Lower().c_str() , kMacExtensionMaxLength ) ;
2481   gMacDefaultExtensions.Add( rec ) ;
2482 }
2483 #endif