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