1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/filename.cpp
3 // Purpose: wxFileName - encapsulates a file path
4 // Author: Robert Roebling, Vadim Zeitlin
8 // Copyright: (c) 2000 Robert Roebling
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
13 Here are brief descriptions of the filename formats supported by this class:
15 wxPATH_UNIX: standard Unix format, used under Darwin as well, absolute file
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
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 "~".
25 There are also UNC names of the form \\share\fullpath
27 wxPATH_MAC: Mac OS 8/9 and Mac OS X under CodeWarrior 7 format, absolute file
29 volume:dir1:...:dirN:filename
30 and the relative file names are either
31 :dir1:...:dirN: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.
39 wxPATH_VMS: VMS native format, absolute file names have the form
40 <device>:[dir1.dir2.dir3]file.txt
42 <device>:[000000.dir1.dir2.dir3]file.txt
44 the <device> is the physical device (i.e. disk). 000000 is the
45 root directory on the device which can be omitted.
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
55 // ============================================================================
57 // ============================================================================
59 // ----------------------------------------------------------------------------
61 // ----------------------------------------------------------------------------
63 // For compilers that support precompilation, includes "wx.h".
64 #include "wx/wxprec.h"
72 #include "wx/msw/wrapwin.h" // For GetShort/LongPathName
74 #include "wx/dynarray.h"
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"
87 #if defined(__WIN32__) && defined(__MINGW32__)
88 #include "wx/msw/gccpriv.h"
92 #include "wx/msw/private.h"
95 #if defined(__WXMAC__)
96 #include "wx/osx/private.h" // includes mac headers
99 // utime() is POSIX so should normally be available on all Unices
101 #include <sys/types.h>
103 #include <sys/stat.h>
113 #include <sys/types.h>
115 #include <sys/stat.h>
126 #include <sys/utime.h>
127 #include <sys/stat.h>
138 #define MAX_PATH _MAX_PATH
143 extern const wxULongLong wxInvalidSize
= (unsigned)-1;
144 #endif // wxUSE_LONGLONG
147 // ----------------------------------------------------------------------------
149 // ----------------------------------------------------------------------------
151 // small helper class which opens and closes the file - we use it just to get
152 // a file handle for the given file name to pass it to some Win32 API function
153 #if defined(__WIN32__) && !defined(__WXMICROWIN__)
164 wxFileHandle(const wxString
& filename
, OpenMode mode
)
166 m_hFile
= ::CreateFile
168 filename
.fn_str(), // name
169 mode
== Read
? GENERIC_READ
// access mask
171 FILE_SHARE_READ
| // sharing mode
172 FILE_SHARE_WRITE
, // (allow everything)
173 NULL
, // no secutity attr
174 OPEN_EXISTING
, // creation disposition
176 NULL
// no template file
179 if ( m_hFile
== INVALID_HANDLE_VALUE
)
182 wxLogSysError(_("Failed to open '%s' for reading"),
185 wxLogSysError(_("Failed to open '%s' for writing"),
192 if ( m_hFile
!= INVALID_HANDLE_VALUE
)
194 if ( !::CloseHandle(m_hFile
) )
196 wxLogSysError(_("Failed to close file handle"));
201 // return true only if the file could be opened successfully
202 bool IsOk() const { return m_hFile
!= INVALID_HANDLE_VALUE
; }
205 operator HANDLE() const { return m_hFile
; }
213 // ----------------------------------------------------------------------------
215 // ----------------------------------------------------------------------------
217 #if wxUSE_DATETIME && defined(__WIN32__) && !defined(__WXMICROWIN__)
219 // convert between wxDateTime and FILETIME which is a 64-bit value representing
220 // the number of 100-nanosecond intervals since January 1, 1601.
222 static void ConvertFileTimeToWx(wxDateTime
*dt
, const FILETIME
&ft
)
224 FILETIME ftcopy
= ft
;
226 if ( !::FileTimeToLocalFileTime(&ftcopy
, &ftLocal
) )
228 wxLogLastError(_T("FileTimeToLocalFileTime"));
232 if ( !::FileTimeToSystemTime(&ftLocal
, &st
) )
234 wxLogLastError(_T("FileTimeToSystemTime"));
237 dt
->Set(st
.wDay
, wxDateTime::Month(st
.wMonth
- 1), st
.wYear
,
238 st
.wHour
, st
.wMinute
, st
.wSecond
, st
.wMilliseconds
);
241 static void ConvertWxToFileTime(FILETIME
*ft
, const wxDateTime
& dt
)
244 st
.wDay
= dt
.GetDay();
245 st
.wMonth
= (WORD
)(dt
.GetMonth() + 1);
246 st
.wYear
= (WORD
)dt
.GetYear();
247 st
.wHour
= dt
.GetHour();
248 st
.wMinute
= dt
.GetMinute();
249 st
.wSecond
= dt
.GetSecond();
250 st
.wMilliseconds
= dt
.GetMillisecond();
253 if ( !::SystemTimeToFileTime(&st
, &ftLocal
) )
255 wxLogLastError(_T("SystemTimeToFileTime"));
258 if ( !::LocalFileTimeToFileTime(&ftLocal
, ft
) )
260 wxLogLastError(_T("LocalFileTimeToFileTime"));
264 #endif // wxUSE_DATETIME && __WIN32__
266 // return a string with the volume par
267 static wxString
wxGetVolumeString(const wxString
& volume
, wxPathFormat format
)
271 if ( !volume
.empty() )
273 format
= wxFileName::GetFormat(format
);
275 // Special Windows UNC paths hack, part 2: undo what we did in
276 // SplitPath() and make an UNC path if we have a drive which is not a
277 // single letter (hopefully the network shares can't be one letter only
278 // although I didn't find any authoritative docs on this)
279 if ( format
== wxPATH_DOS
&& volume
.length() > 1 )
281 path
<< wxFILE_SEP_PATH_DOS
<< wxFILE_SEP_PATH_DOS
<< volume
;
283 else if ( format
== wxPATH_DOS
|| format
== wxPATH_VMS
)
285 path
<< volume
<< wxFileName::GetVolumeSeparator(format
);
293 // return true if the format used is the DOS/Windows one and the string looks
295 static bool IsUNCPath(const wxString
& path
, wxPathFormat format
)
297 return format
== wxPATH_DOS
&&
298 path
.length() >= 4 && // "\\a" can't be a UNC path
299 path
[0u] == wxFILE_SEP_PATH_DOS
&&
300 path
[1u] == wxFILE_SEP_PATH_DOS
&&
301 path
[2u] != wxFILE_SEP_PATH_DOS
;
304 // ============================================================================
306 // ============================================================================
308 // ----------------------------------------------------------------------------
309 // wxFileName construction
310 // ----------------------------------------------------------------------------
312 void wxFileName::Assign( const wxFileName
&filepath
)
314 m_volume
= filepath
.GetVolume();
315 m_dirs
= filepath
.GetDirs();
316 m_name
= filepath
.GetName();
317 m_ext
= filepath
.GetExt();
318 m_relative
= filepath
.m_relative
;
319 m_hasExt
= filepath
.m_hasExt
;
322 void wxFileName::Assign(const wxString
& volume
,
323 const wxString
& path
,
324 const wxString
& name
,
329 // we should ignore paths which look like UNC shares because we already
330 // have the volume here and the UNC notation (\\server\path) is only valid
331 // for paths which don't start with a volume, so prevent SetPath() from
332 // recognizing "\\foo\bar" in "c:\\foo\bar" as an UNC path
334 // note also that this is a rather ugly way to do what we want (passing
335 // some kind of flag telling to ignore UNC paths to SetPath() would be
336 // better) but this is the safest thing to do to avoid breaking backwards
337 // compatibility in 2.8
338 if ( IsUNCPath(path
, format
) )
340 // remove one of the 2 leading backslashes to ensure that it's not
341 // recognized as an UNC path by SetPath()
342 wxString
pathNonUNC(path
, 1, wxString::npos
);
343 SetPath(pathNonUNC
, format
);
345 else // no UNC complications
347 SetPath(path
, format
);
357 void wxFileName::SetPath( const wxString
& pathOrig
, wxPathFormat format
)
361 if ( pathOrig
.empty() )
369 format
= GetFormat( format
);
371 // 0) deal with possible volume part first
374 SplitVolume(pathOrig
, &volume
, &path
, format
);
375 if ( !volume
.empty() )
382 // 1) Determine if the path is relative or absolute.
383 wxChar leadingChar
= path
[0u];
388 m_relative
= leadingChar
== wxT(':');
390 // We then remove a leading ":". The reason is in our
391 // storage form for relative paths:
392 // ":dir:file.txt" actually means "./dir/file.txt" in
393 // DOS notation and should get stored as
394 // (relative) (dir) (file.txt)
395 // "::dir:file.txt" actually means "../dir/file.txt"
396 // stored as (relative) (..) (dir) (file.txt)
397 // This is important only for the Mac as an empty dir
398 // actually means <UP>, whereas under DOS, double
399 // slashes can be ignored: "\\\\" is the same as "\\".
405 // TODO: what is the relative path format here?
410 wxFAIL_MSG( _T("Unknown path format") );
411 // !! Fall through !!
414 // the paths of the form "~" or "~username" are absolute
415 m_relative
= leadingChar
!= wxT('/') && leadingChar
!= _T('~');
419 m_relative
= !IsPathSeparator(leadingChar
, format
);
424 // 2) Break up the path into its members. If the original path
425 // was just "/" or "\\", m_dirs will be empty. We know from
426 // the m_relative field, if this means "nothing" or "root dir".
428 wxStringTokenizer
tn( path
, GetPathSeparators(format
) );
430 while ( tn
.HasMoreTokens() )
432 wxString token
= tn
.GetNextToken();
434 // Remove empty token under DOS and Unix, interpret them
438 if (format
== wxPATH_MAC
)
439 m_dirs
.Add( wxT("..") );
449 void wxFileName::Assign(const wxString
& fullpath
,
452 wxString volume
, path
, name
, ext
;
454 SplitPath(fullpath
, &volume
, &path
, &name
, &ext
, &hasExt
, format
);
456 Assign(volume
, path
, name
, ext
, hasExt
, format
);
459 void wxFileName::Assign(const wxString
& fullpathOrig
,
460 const wxString
& fullname
,
463 // always recognize fullpath as directory, even if it doesn't end with a
465 wxString fullpath
= fullpathOrig
;
466 if ( !fullpath
.empty() && !wxEndsWithPathSeparator(fullpath
) )
468 fullpath
+= GetPathSeparator(format
);
471 wxString volume
, path
, name
, ext
;
474 // do some consistency checks in debug mode: the name should be really just
475 // the filename and the path should be really just a path
477 wxString volDummy
, pathDummy
, nameDummy
, extDummy
;
479 SplitPath(fullname
, &volDummy
, &pathDummy
, &name
, &ext
, &hasExt
, format
);
481 wxASSERT_MSG( volDummy
.empty() && pathDummy
.empty(),
482 _T("the file name shouldn't contain the path") );
484 SplitPath(fullpath
, &volume
, &path
, &nameDummy
, &extDummy
, format
);
486 wxASSERT_MSG( nameDummy
.empty() && extDummy
.empty(),
487 _T("the path shouldn't contain file name nor extension") );
489 #else // !__WXDEBUG__
490 SplitPath(fullname
, NULL
/* no volume */, NULL
/* no path */,
491 &name
, &ext
, &hasExt
, format
);
492 SplitPath(fullpath
, &volume
, &path
, NULL
, NULL
, format
);
493 #endif // __WXDEBUG__/!__WXDEBUG__
495 Assign(volume
, path
, name
, ext
, hasExt
, format
);
498 void wxFileName::Assign(const wxString
& pathOrig
,
499 const wxString
& name
,
505 SplitVolume(pathOrig
, &volume
, &path
, format
);
507 Assign(volume
, path
, name
, ext
, format
);
510 void wxFileName::AssignDir(const wxString
& dir
, wxPathFormat format
)
512 Assign(dir
, wxEmptyString
, format
);
515 void wxFileName::Clear()
521 m_ext
= wxEmptyString
;
523 // we don't have any absolute path for now
531 wxFileName
wxFileName::FileName(const wxString
& file
, wxPathFormat format
)
533 return wxFileName(file
, format
);
537 wxFileName
wxFileName::DirName(const wxString
& dir
, wxPathFormat format
)
540 fn
.AssignDir(dir
, format
);
544 // ----------------------------------------------------------------------------
546 // ----------------------------------------------------------------------------
548 bool wxFileName::FileExists() const
550 return wxFileName::FileExists( GetFullPath() );
553 bool wxFileName::FileExists( const wxString
&file
)
555 return ::wxFileExists( file
);
558 bool wxFileName::DirExists() const
560 return wxFileName::DirExists( GetPath() );
563 bool wxFileName::DirExists( const wxString
&dir
)
565 return ::wxDirExists( dir
);
568 // ----------------------------------------------------------------------------
569 // CWD and HOME stuff
570 // ----------------------------------------------------------------------------
572 void wxFileName::AssignCwd(const wxString
& volume
)
574 AssignDir(wxFileName::GetCwd(volume
));
578 wxString
wxFileName::GetCwd(const wxString
& volume
)
580 // if we have the volume, we must get the current directory on this drive
581 // and to do this we have to chdir to this volume - at least under Windows,
582 // I don't know how to get the current drive on another volume elsewhere
585 if ( !volume
.empty() )
588 SetCwd(volume
+ GetVolumeSeparator());
591 wxString cwd
= ::wxGetCwd();
593 if ( !volume
.empty() )
601 bool wxFileName::SetCwd()
603 return wxFileName::SetCwd( GetPath() );
606 bool wxFileName::SetCwd( const wxString
&cwd
)
608 return ::wxSetWorkingDirectory( cwd
);
611 void wxFileName::AssignHomeDir()
613 AssignDir(wxFileName::GetHomeDir());
616 wxString
wxFileName::GetHomeDir()
618 return ::wxGetHomeDir();
622 // ----------------------------------------------------------------------------
623 // CreateTempFileName
624 // ----------------------------------------------------------------------------
626 #if wxUSE_FILE || wxUSE_FFILE
629 #if !defined wx_fdopen && defined HAVE_FDOPEN
630 #define wx_fdopen fdopen
633 // NB: GetTempFileName() under Windows creates the file, so using
634 // O_EXCL there would fail
636 #define wxOPEN_EXCL 0
638 #define wxOPEN_EXCL O_EXCL
642 #ifdef wxOpenOSFHandle
643 #define WX_HAVE_DELETE_ON_CLOSE
644 // On Windows create a file with the FILE_FLAGS_DELETE_ON_CLOSE flags.
646 static int wxOpenWithDeleteOnClose(const wxString
& filename
)
648 DWORD access
= GENERIC_READ
| GENERIC_WRITE
;
650 DWORD disposition
= OPEN_ALWAYS
;
652 DWORD attributes
= FILE_ATTRIBUTE_TEMPORARY
|
653 FILE_FLAG_DELETE_ON_CLOSE
;
655 HANDLE h
= ::CreateFile(filename
.fn_str(), access
, 0, NULL
,
656 disposition
, attributes
, NULL
);
658 return wxOpenOSFHandle(h
, wxO_BINARY
);
660 #endif // wxOpenOSFHandle
663 // Helper to open the file
665 static int wxTempOpen(const wxString
& path
, bool *deleteOnClose
)
667 #ifdef WX_HAVE_DELETE_ON_CLOSE
669 return wxOpenWithDeleteOnClose(path
);
672 *deleteOnClose
= false;
674 return wxOpen(path
, wxO_BINARY
| O_RDWR
| O_CREAT
| wxOPEN_EXCL
, 0600);
679 // Helper to open the file and attach it to the wxFFile
681 static bool wxTempOpen(wxFFile
*file
, const wxString
& path
, bool *deleteOnClose
)
684 *deleteOnClose
= false;
685 return file
->Open(path
, _T("w+b"));
687 int fd
= wxTempOpen(path
, deleteOnClose
);
690 file
->Attach(wx_fdopen(fd
, "w+b"));
691 return file
->IsOpened();
694 #endif // wxUSE_FFILE
698 #define WXFILEARGS(x, y) y
700 #define WXFILEARGS(x, y) x
702 #define WXFILEARGS(x, y) x, y
706 // Implementation of wxFileName::CreateTempFileName().
708 static wxString
wxCreateTempImpl(
709 const wxString
& prefix
,
710 WXFILEARGS(wxFile
*fileTemp
, wxFFile
*ffileTemp
),
711 bool *deleteOnClose
= NULL
)
713 #if wxUSE_FILE && wxUSE_FFILE
714 wxASSERT(fileTemp
== NULL
|| ffileTemp
== NULL
);
716 wxString path
, dir
, name
;
717 bool wantDeleteOnClose
= false;
721 // set the result to false initially
722 wantDeleteOnClose
= *deleteOnClose
;
723 *deleteOnClose
= false;
727 // easier if it alwasys points to something
728 deleteOnClose
= &wantDeleteOnClose
;
731 // use the directory specified by the prefix
732 wxFileName::SplitPath(prefix
, &dir
, &name
, NULL
/* extension */);
736 dir
= wxFileName::GetTempDir();
739 #if defined(__WXWINCE__)
740 path
= dir
+ wxT("\\") + name
;
742 while (wxFileName::FileExists(path
))
744 path
= dir
+ wxT("\\") + name
;
749 #elif defined(__WINDOWS__) && !defined(__WXMICROWIN__)
750 if ( !::GetTempFileName(dir
.fn_str(), name
.fn_str(), 0,
751 wxStringBuffer(path
, MAX_PATH
+ 1)) )
753 wxLogLastError(_T("GetTempFileName"));
761 if ( !wxEndsWithPathSeparator(dir
) &&
762 (name
.empty() || !wxIsPathSeparator(name
[0u])) )
764 path
+= wxFILE_SEP_PATH
;
769 #if defined(HAVE_MKSTEMP)
770 // scratch space for mkstemp()
771 path
+= _T("XXXXXX");
773 // we need to copy the path to the buffer in which mkstemp() can modify it
774 wxCharBuffer
buf(path
.fn_str());
776 // cast is safe because the string length doesn't change
777 int fdTemp
= mkstemp( (char*)(const char*) buf
);
780 // this might be not necessary as mkstemp() on most systems should have
781 // already done it but it doesn't hurt neither...
784 else // mkstemp() succeeded
786 path
= wxConvFile
.cMB2WX( (const char*) buf
);
789 // avoid leaking the fd
792 fileTemp
->Attach(fdTemp
);
801 ffileTemp
->Attach(wx_fdopen(fdTemp
, "r+b"));
803 ffileTemp
->Open(path
, _T("r+b"));
814 #else // !HAVE_MKSTEMP
818 path
+= _T("XXXXXX");
820 wxCharBuffer buf
= wxConvFile
.cWX2MB( path
);
821 if ( !mktemp( (char*)(const char*) buf
) )
827 path
= wxConvFile
.cMB2WX( (const char*) buf
);
829 #else // !HAVE_MKTEMP (includes __DOS__)
830 // generate the unique file name ourselves
831 #if !defined(__DOS__) && !defined(__PALMOS__) && (!defined(__MWERKS__) || defined(__DARWIN__) )
832 path
<< (unsigned int)getpid();
837 static const size_t numTries
= 1000;
838 for ( size_t n
= 0; n
< numTries
; n
++ )
840 // 3 hex digits is enough for numTries == 1000 < 4096
841 pathTry
= path
+ wxString::Format(_T("%.03x"), (unsigned int) n
);
842 if ( !wxFileName::FileExists(pathTry
) )
851 #endif // HAVE_MKTEMP/!HAVE_MKTEMP
853 #endif // HAVE_MKSTEMP/!HAVE_MKSTEMP
855 #endif // Windows/!Windows
859 wxLogSysError(_("Failed to create a temporary file name"));
865 // open the file - of course, there is a race condition here, this is
866 // why we always prefer using mkstemp()...
868 if ( fileTemp
&& !fileTemp
->IsOpened() )
870 *deleteOnClose
= wantDeleteOnClose
;
871 int fd
= wxTempOpen(path
, deleteOnClose
);
873 fileTemp
->Attach(fd
);
880 if ( ffileTemp
&& !ffileTemp
->IsOpened() )
882 *deleteOnClose
= wantDeleteOnClose
;
883 ok
= wxTempOpen(ffileTemp
, path
, deleteOnClose
);
889 // FIXME: If !ok here should we loop and try again with another
890 // file name? That is the standard recourse if open(O_EXCL)
891 // fails, though of course it should be protected against
892 // possible infinite looping too.
894 wxLogError(_("Failed to open temporary file."));
904 static bool wxCreateTempImpl(
905 const wxString
& prefix
,
906 WXFILEARGS(wxFile
*fileTemp
, wxFFile
*ffileTemp
),
909 bool deleteOnClose
= true;
911 *name
= wxCreateTempImpl(prefix
,
912 WXFILEARGS(fileTemp
, ffileTemp
),
915 bool ok
= !name
->empty();
920 else if (ok
&& wxRemoveFile(*name
))
928 static void wxAssignTempImpl(
930 const wxString
& prefix
,
931 WXFILEARGS(wxFile
*fileTemp
, wxFFile
*ffileTemp
))
934 tempname
= wxCreateTempImpl(prefix
, WXFILEARGS(fileTemp
, ffileTemp
));
936 if ( tempname
.empty() )
938 // error, failed to get temp file name
943 fn
->Assign(tempname
);
948 void wxFileName::AssignTempFileName(const wxString
& prefix
)
950 wxAssignTempImpl(this, prefix
, WXFILEARGS(NULL
, NULL
));
954 wxString
wxFileName::CreateTempFileName(const wxString
& prefix
)
956 return wxCreateTempImpl(prefix
, WXFILEARGS(NULL
, NULL
));
959 #endif // wxUSE_FILE || wxUSE_FFILE
964 wxString
wxCreateTempFileName(const wxString
& prefix
,
968 return wxCreateTempImpl(prefix
, WXFILEARGS(fileTemp
, NULL
), deleteOnClose
);
971 bool wxCreateTempFile(const wxString
& prefix
,
975 return wxCreateTempImpl(prefix
, WXFILEARGS(fileTemp
, NULL
), name
);
978 void wxFileName::AssignTempFileName(const wxString
& prefix
, wxFile
*fileTemp
)
980 wxAssignTempImpl(this, prefix
, WXFILEARGS(fileTemp
, NULL
));
985 wxFileName::CreateTempFileName(const wxString
& prefix
, wxFile
*fileTemp
)
987 return wxCreateTempFileName(prefix
, fileTemp
);
995 wxString
wxCreateTempFileName(const wxString
& prefix
,
999 return wxCreateTempImpl(prefix
, WXFILEARGS(NULL
, fileTemp
), deleteOnClose
);
1002 bool wxCreateTempFile(const wxString
& prefix
,
1006 return wxCreateTempImpl(prefix
, WXFILEARGS(NULL
, fileTemp
), name
);
1010 void wxFileName::AssignTempFileName(const wxString
& prefix
, wxFFile
*fileTemp
)
1012 wxAssignTempImpl(this, prefix
, WXFILEARGS(NULL
, fileTemp
));
1017 wxFileName::CreateTempFileName(const wxString
& prefix
, wxFFile
*fileTemp
)
1019 return wxCreateTempFileName(prefix
, fileTemp
);
1022 #endif // wxUSE_FFILE
1025 // ----------------------------------------------------------------------------
1026 // directory operations
1027 // ----------------------------------------------------------------------------
1029 // helper of GetTempDir(): check if the given directory exists and return it if
1030 // it does or an empty string otherwise
1034 wxString
CheckIfDirExists(const wxString
& dir
)
1036 return wxFileName::DirExists(dir
) ? dir
: wxString();
1039 } // anonymous namespace
1041 wxString
wxFileName::GetTempDir()
1043 // first try getting it from environment: this allows overriding the values
1044 // used by default if the user wants to create temporary files in another
1046 wxString dir
= CheckIfDirExists(wxGetenv("TMPDIR"));
1049 dir
= CheckIfDirExists(wxGetenv("TMP"));
1051 dir
= CheckIfDirExists(wxGetenv("TEMP"));
1054 // if no environment variables are set, use the system default
1057 #if defined(__WXWINCE__)
1058 dir
= CheckIfDirExists(wxT("\\temp"));
1059 #elif defined(__WINDOWS__) && !defined(__WXMICROWIN__)
1060 if ( !::GetTempPath(MAX_PATH
, wxStringBuffer(dir
, MAX_PATH
+ 1)) )
1062 wxLogLastError(_T("GetTempPath"));
1064 #elif defined(__WXMAC__) && wxOSX_USE_CARBON
1065 dir
= wxMacFindFolder(short(kOnSystemDisk
), kTemporaryFolderType
, kCreateFolder
);
1066 #endif // systems with native way
1069 // fall back to hard coded value
1072 #ifdef __UNIX_LIKE__
1073 dir
= CheckIfDirExists("/tmp");
1075 #endif // __UNIX_LIKE__
1082 bool wxFileName::Mkdir( int perm
, int flags
)
1084 return wxFileName::Mkdir(GetPath(), perm
, flags
);
1087 bool wxFileName::Mkdir( const wxString
& dir
, int perm
, int flags
)
1089 if ( flags
& wxPATH_MKDIR_FULL
)
1091 // split the path in components
1092 wxFileName filename
;
1093 filename
.AssignDir(dir
);
1096 if ( filename
.HasVolume())
1098 currPath
<< wxGetVolumeString(filename
.GetVolume(), wxPATH_NATIVE
);
1101 wxArrayString dirs
= filename
.GetDirs();
1102 size_t count
= dirs
.GetCount();
1103 for ( size_t i
= 0; i
< count
; i
++ )
1105 if ( i
> 0 || filename
.IsAbsolute() )
1106 currPath
+= wxFILE_SEP_PATH
;
1107 currPath
+= dirs
[i
];
1109 if (!DirExists(currPath
))
1111 if (!wxMkdir(currPath
, perm
))
1113 // no need to try creating further directories
1123 return ::wxMkdir( dir
, perm
);
1126 bool wxFileName::Rmdir()
1128 return wxFileName::Rmdir( GetPath() );
1131 bool wxFileName::Rmdir( const wxString
&dir
)
1133 return ::wxRmdir( dir
);
1136 // ----------------------------------------------------------------------------
1137 // path normalization
1138 // ----------------------------------------------------------------------------
1140 bool wxFileName::Normalize(int flags
,
1141 const wxString
& cwd
,
1142 wxPathFormat format
)
1144 // deal with env vars renaming first as this may seriously change the path
1145 if ( flags
& wxPATH_NORM_ENV_VARS
)
1147 wxString pathOrig
= GetFullPath(format
);
1148 wxString path
= wxExpandEnvVars(pathOrig
);
1149 if ( path
!= pathOrig
)
1156 // the existing path components
1157 wxArrayString dirs
= GetDirs();
1159 // the path to prepend in front to make the path absolute
1162 format
= GetFormat(format
);
1164 // set up the directory to use for making the path absolute later
1165 if ( (flags
& wxPATH_NORM_ABSOLUTE
) && !IsAbsolute(format
) )
1169 curDir
.AssignCwd(GetVolume());
1171 else // cwd provided
1173 curDir
.AssignDir(cwd
);
1177 // handle ~ stuff under Unix only
1178 if ( (format
== wxPATH_UNIX
) && (flags
& wxPATH_NORM_TILDE
) )
1180 if ( !dirs
.IsEmpty() )
1182 wxString dir
= dirs
[0u];
1183 if ( !dir
.empty() && dir
[0u] == _T('~') )
1185 // to make the path absolute use the home directory
1186 curDir
.AssignDir(wxGetUserHome(dir
.c_str() + 1));
1188 // if we are expanding the tilde, then this path
1189 // *should* be already relative (since we checked for
1190 // the tilde only in the first char of the first dir);
1191 // if m_relative==false, it's because it was initialized
1192 // from a string which started with /~; in that case
1193 // we reach this point but then need m_relative=true
1194 // for relative->absolute expansion later
1202 // transform relative path into abs one
1203 if ( curDir
.IsOk() )
1205 // this path may be relative because it doesn't have the volume name
1206 // and still have m_relative=true; in this case we shouldn't modify
1207 // our directory components but just set the current volume
1208 if ( !HasVolume() && curDir
.HasVolume() )
1210 SetVolume(curDir
.GetVolume());
1214 // yes, it was the case - we don't need curDir then
1219 // finally, prepend curDir to the dirs array
1220 wxArrayString dirsNew
= curDir
.GetDirs();
1221 WX_PREPEND_ARRAY(dirs
, dirsNew
);
1223 // if we used e.g. tilde expansion previously and wxGetUserHome didn't
1224 // return for some reason an absolute path, then curDir maybe not be absolute!
1225 if ( curDir
.IsAbsolute(format
) )
1227 // we have prepended an absolute path and thus we are now an absolute
1231 // else if (flags & wxPATH_NORM_ABSOLUTE):
1232 // should we warn the user that we didn't manage to make the path absolute?
1235 // now deal with ".", ".." and the rest
1237 size_t count
= dirs
.GetCount();
1238 for ( size_t n
= 0; n
< count
; n
++ )
1240 wxString dir
= dirs
[n
];
1242 if ( flags
& wxPATH_NORM_DOTS
)
1244 if ( dir
== wxT(".") )
1250 if ( dir
== wxT("..") )
1252 if ( m_dirs
.IsEmpty() )
1254 wxLogError(_("The path '%s' contains too many \"..\"!"),
1255 GetFullPath().c_str());
1259 m_dirs
.RemoveAt(m_dirs
.GetCount() - 1);
1267 #if defined(__WIN32__) && !defined(__WXWINCE__) && wxUSE_OLE
1268 if ( (flags
& wxPATH_NORM_SHORTCUT
) )
1271 if (GetShortcutTarget(GetFullPath(format
), filename
))
1279 #if defined(__WIN32__)
1280 if ( (flags
& wxPATH_NORM_LONG
) && (format
== wxPATH_DOS
) )
1282 Assign(GetLongPath());
1286 // Change case (this should be kept at the end of the function, to ensure
1287 // that the path doesn't change any more after we normalize its case)
1288 if ( (flags
& wxPATH_NORM_CASE
) && !IsCaseSensitive(format
) )
1290 m_volume
.MakeLower();
1294 // directory entries must be made lower case as well
1295 count
= m_dirs
.GetCount();
1296 for ( size_t i
= 0; i
< count
; i
++ )
1298 m_dirs
[i
].MakeLower();
1305 // ----------------------------------------------------------------------------
1306 // get the shortcut target
1307 // ----------------------------------------------------------------------------
1309 // WinCE (3) doesn't have CLSID_ShellLink, IID_IShellLink definitions.
1310 // The .lnk file is a plain text file so it should be easy to
1311 // make it work. Hint from Google Groups:
1312 // "If you open up a lnk file, you'll see a
1313 // number, followed by a pound sign (#), followed by more text. The
1314 // number is the number of characters that follows the pound sign. The
1315 // characters after the pound sign are the command line (which _can_
1316 // include arguments) to be executed. Any path (e.g. \windows\program
1317 // files\myapp.exe) that includes spaces needs to be enclosed in
1318 // quotation marks."
1320 #if defined(__WIN32__) && !defined(__WXWINCE__) && wxUSE_OLE
1321 // The following lines are necessary under WinCE
1322 // #include "wx/msw/private.h"
1323 // #include <ole2.h>
1325 #if defined(__WXWINCE__)
1326 #include <shlguid.h>
1329 bool wxFileName::GetShortcutTarget(const wxString
& shortcutPath
,
1330 wxString
& targetFilename
,
1331 wxString
* arguments
)
1333 wxString path
, file
, ext
;
1334 wxSplitPath(shortcutPath
, & path
, & file
, & ext
);
1338 bool success
= false;
1340 // Assume it's not a shortcut if it doesn't end with lnk
1341 if (ext
.CmpNoCase(wxT("lnk"))!=0)
1344 // create a ShellLink object
1345 hres
= CoCreateInstance(CLSID_ShellLink
, NULL
, CLSCTX_INPROC_SERVER
,
1346 IID_IShellLink
, (LPVOID
*) &psl
);
1348 if (SUCCEEDED(hres
))
1351 hres
= psl
->QueryInterface( IID_IPersistFile
, (LPVOID
*) &ppf
);
1352 if (SUCCEEDED(hres
))
1354 WCHAR wsz
[MAX_PATH
];
1356 MultiByteToWideChar(CP_ACP
, MB_PRECOMPOSED
, shortcutPath
.mb_str(), -1, wsz
,
1359 hres
= ppf
->Load(wsz
, 0);
1362 if (SUCCEEDED(hres
))
1365 // Wrong prototype in early versions
1366 #if defined(__MINGW32__) && !wxCHECK_W32API_VERSION(2, 2)
1367 psl
->GetPath((CHAR
*) buf
, 2048, NULL
, SLGP_UNCPRIORITY
);
1369 psl
->GetPath(buf
, 2048, NULL
, SLGP_UNCPRIORITY
);
1371 targetFilename
= wxString(buf
);
1372 success
= (shortcutPath
!= targetFilename
);
1374 psl
->GetArguments(buf
, 2048);
1376 if (!args
.empty() && arguments
)
1388 #endif // __WIN32__ && !__WXWINCE__
1391 // ----------------------------------------------------------------------------
1392 // absolute/relative paths
1393 // ----------------------------------------------------------------------------
1395 bool wxFileName::IsAbsolute(wxPathFormat format
) const
1397 // if our path doesn't start with a path separator, it's not an absolute
1402 if ( !GetVolumeSeparator(format
).empty() )
1404 // this format has volumes and an absolute path must have one, it's not
1405 // enough to have the full path to bean absolute file under Windows
1406 if ( GetVolume().empty() )
1413 bool wxFileName::MakeRelativeTo(const wxString
& pathBase
, wxPathFormat format
)
1415 wxFileName fnBase
= wxFileName::DirName(pathBase
, format
);
1417 // get cwd only once - small time saving
1418 wxString cwd
= wxGetCwd();
1419 Normalize(wxPATH_NORM_ALL
& ~wxPATH_NORM_CASE
, cwd
, format
);
1420 fnBase
.Normalize(wxPATH_NORM_ALL
& ~wxPATH_NORM_CASE
, cwd
, format
);
1422 bool withCase
= IsCaseSensitive(format
);
1424 // we can't do anything if the files live on different volumes
1425 if ( !GetVolume().IsSameAs(fnBase
.GetVolume(), withCase
) )
1431 // same drive, so we don't need our volume
1434 // remove common directories starting at the top
1435 while ( !m_dirs
.IsEmpty() && !fnBase
.m_dirs
.IsEmpty() &&
1436 m_dirs
[0u].IsSameAs(fnBase
.m_dirs
[0u], withCase
) )
1439 fnBase
.m_dirs
.RemoveAt(0);
1442 // add as many ".." as needed
1443 size_t count
= fnBase
.m_dirs
.GetCount();
1444 for ( size_t i
= 0; i
< count
; i
++ )
1446 m_dirs
.Insert(wxT(".."), 0u);
1449 if ( format
== wxPATH_UNIX
|| format
== wxPATH_DOS
)
1451 // a directory made relative with respect to itself is '.' under Unix
1452 // and DOS, by definition (but we don't have to insert "./" for the
1454 if ( m_dirs
.IsEmpty() && IsDir() )
1456 m_dirs
.Add(_T('.'));
1466 // ----------------------------------------------------------------------------
1467 // filename kind tests
1468 // ----------------------------------------------------------------------------
1470 bool wxFileName::SameAs(const wxFileName
& filepath
, wxPathFormat format
) const
1472 wxFileName fn1
= *this,
1475 // get cwd only once - small time saving
1476 wxString cwd
= wxGetCwd();
1477 fn1
.Normalize(wxPATH_NORM_ALL
| wxPATH_NORM_CASE
, cwd
, format
);
1478 fn2
.Normalize(wxPATH_NORM_ALL
| wxPATH_NORM_CASE
, cwd
, format
);
1480 if ( fn1
.GetFullPath() == fn2
.GetFullPath() )
1483 // TODO: compare inodes for Unix, this works even when filenames are
1484 // different but files are the same (symlinks) (VZ)
1490 bool wxFileName::IsCaseSensitive( wxPathFormat format
)
1492 // only Unix filenames are truely case-sensitive
1493 return GetFormat(format
) == wxPATH_UNIX
;
1497 wxString
wxFileName::GetForbiddenChars(wxPathFormat format
)
1499 // Inits to forbidden characters that are common to (almost) all platforms.
1500 wxString strForbiddenChars
= wxT("*?");
1502 // If asserts, wxPathFormat has been changed. In case of a new path format
1503 // addition, the following code might have to be updated.
1504 wxCOMPILE_TIME_ASSERT(wxPATH_MAX
== 5, wxPathFormatChanged
);
1505 switch ( GetFormat(format
) )
1508 wxFAIL_MSG( wxT("Unknown path format") );
1509 // !! Fall through !!
1515 // On a Mac even names with * and ? are allowed (Tested with OS
1516 // 9.2.1 and OS X 10.2.5)
1517 strForbiddenChars
= wxEmptyString
;
1521 strForbiddenChars
+= wxT("\\/:\"<>|");
1528 return strForbiddenChars
;
1532 wxString
wxFileName::GetVolumeSeparator(wxPathFormat
WXUNUSED_IN_WINCE(format
))
1535 return wxEmptyString
;
1539 if ( (GetFormat(format
) == wxPATH_DOS
) ||
1540 (GetFormat(format
) == wxPATH_VMS
) )
1542 sepVol
= wxFILE_SEP_DSK
;
1551 wxString
wxFileName::GetPathSeparators(wxPathFormat format
)
1554 switch ( GetFormat(format
) )
1557 // accept both as native APIs do but put the native one first as
1558 // this is the one we use in GetFullPath()
1559 seps
<< wxFILE_SEP_PATH_DOS
<< wxFILE_SEP_PATH_UNIX
;
1563 wxFAIL_MSG( _T("Unknown wxPATH_XXX style") );
1567 seps
= wxFILE_SEP_PATH_UNIX
;
1571 seps
= wxFILE_SEP_PATH_MAC
;
1575 seps
= wxFILE_SEP_PATH_VMS
;
1583 wxString
wxFileName::GetPathTerminators(wxPathFormat format
)
1585 format
= GetFormat(format
);
1587 // under VMS the end of the path is ']', not the path separator used to
1588 // separate the components
1589 return format
== wxPATH_VMS
? wxString(_T(']')) : GetPathSeparators(format
);
1593 bool wxFileName::IsPathSeparator(wxChar ch
, wxPathFormat format
)
1595 // wxString::Find() doesn't work as expected with NUL - it will always find
1596 // it, so test for it separately
1597 return ch
!= _T('\0') && GetPathSeparators(format
).Find(ch
) != wxNOT_FOUND
;
1600 // ----------------------------------------------------------------------------
1601 // path components manipulation
1602 // ----------------------------------------------------------------------------
1604 /* static */ bool wxFileName::IsValidDirComponent(const wxString
& dir
)
1608 wxFAIL_MSG( _T("empty directory passed to wxFileName::InsertDir()") );
1613 const size_t len
= dir
.length();
1614 for ( size_t n
= 0; n
< len
; n
++ )
1616 if ( dir
[n
] == GetVolumeSeparator() || IsPathSeparator(dir
[n
]) )
1618 wxFAIL_MSG( _T("invalid directory component in wxFileName") );
1627 void wxFileName::AppendDir( const wxString
& dir
)
1629 if ( IsValidDirComponent(dir
) )
1633 void wxFileName::PrependDir( const wxString
& dir
)
1638 void wxFileName::InsertDir(size_t before
, const wxString
& dir
)
1640 if ( IsValidDirComponent(dir
) )
1641 m_dirs
.Insert(dir
, before
);
1644 void wxFileName::RemoveDir(size_t pos
)
1646 m_dirs
.RemoveAt(pos
);
1649 // ----------------------------------------------------------------------------
1651 // ----------------------------------------------------------------------------
1653 void wxFileName::SetFullName(const wxString
& fullname
)
1655 SplitPath(fullname
, NULL
/* no volume */, NULL
/* no path */,
1656 &m_name
, &m_ext
, &m_hasExt
);
1659 wxString
wxFileName::GetFullName() const
1661 wxString fullname
= m_name
;
1664 fullname
<< wxFILE_SEP_EXT
<< m_ext
;
1670 wxString
wxFileName::GetPath( int flags
, wxPathFormat format
) const
1672 format
= GetFormat( format
);
1676 // return the volume with the path as well if requested
1677 if ( flags
& wxPATH_GET_VOLUME
)
1679 fullpath
+= wxGetVolumeString(GetVolume(), format
);
1682 // the leading character
1687 fullpath
+= wxFILE_SEP_PATH_MAC
;
1692 fullpath
+= wxFILE_SEP_PATH_DOS
;
1696 wxFAIL_MSG( wxT("Unknown path format") );
1702 // normally the absolute file names start with a slash
1703 // with one exception: the ones like "~/foo.bar" don't
1705 if ( m_dirs
.IsEmpty() || m_dirs
[0u] != _T('~') )
1707 fullpath
+= wxFILE_SEP_PATH_UNIX
;
1713 // no leading character here but use this place to unset
1714 // wxPATH_GET_SEPARATOR flag: under VMS it doesn't make sense
1715 // as, if I understand correctly, there should never be a dot
1716 // before the closing bracket
1717 flags
&= ~wxPATH_GET_SEPARATOR
;
1720 if ( m_dirs
.empty() )
1722 // there is nothing more
1726 // then concatenate all the path components using the path separator
1727 if ( format
== wxPATH_VMS
)
1729 fullpath
+= wxT('[');
1732 const size_t dirCount
= m_dirs
.GetCount();
1733 for ( size_t i
= 0; i
< dirCount
; i
++ )
1738 if ( m_dirs
[i
] == wxT(".") )
1740 // skip appending ':', this shouldn't be done in this
1741 // case as "::" is interpreted as ".." under Unix
1745 // convert back from ".." to nothing
1746 if ( !m_dirs
[i
].IsSameAs(wxT("..")) )
1747 fullpath
+= m_dirs
[i
];
1751 wxFAIL_MSG( wxT("Unexpected path format") );
1752 // still fall through
1756 fullpath
+= m_dirs
[i
];
1760 // TODO: What to do with ".." under VMS
1762 // convert back from ".." to nothing
1763 if ( !m_dirs
[i
].IsSameAs(wxT("..")) )
1764 fullpath
+= m_dirs
[i
];
1768 if ( (flags
& wxPATH_GET_SEPARATOR
) || (i
!= dirCount
- 1) )
1769 fullpath
+= GetPathSeparator(format
);
1772 if ( format
== wxPATH_VMS
)
1774 fullpath
+= wxT(']');
1780 wxString
wxFileName::GetFullPath( wxPathFormat format
) const
1782 // we already have a function to get the path
1783 wxString fullpath
= GetPath(wxPATH_GET_VOLUME
| wxPATH_GET_SEPARATOR
,
1786 // now just add the file name and extension to it
1787 fullpath
+= GetFullName();
1792 // Return the short form of the path (returns identity on non-Windows platforms)
1793 wxString
wxFileName::GetShortPath() const
1795 wxString
path(GetFullPath());
1797 #if defined(__WXMSW__) && defined(__WIN32__) && !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
1798 DWORD sz
= ::GetShortPathName(path
.fn_str(), NULL
, 0);
1802 if ( ::GetShortPathName
1805 wxStringBuffer(pathOut
, sz
),
1817 // Return the long form of the path (returns identity on non-Windows platforms)
1818 wxString
wxFileName::GetLongPath() const
1821 path
= GetFullPath();
1823 #if defined(__WIN32__) && !defined(__WXWINCE__) && !defined(__WXMICROWIN__)
1825 #if wxUSE_DYNLIB_CLASS
1826 typedef DWORD (WINAPI
*GET_LONG_PATH_NAME
)(const wxChar
*, wxChar
*, DWORD
);
1828 // this is MT-safe as in the worst case we're going to resolve the function
1829 // twice -- but as the result is the same in both threads, it's ok
1830 static GET_LONG_PATH_NAME s_pfnGetLongPathName
= NULL
;
1831 if ( !s_pfnGetLongPathName
)
1833 static bool s_triedToLoad
= false;
1835 if ( !s_triedToLoad
)
1837 s_triedToLoad
= true;
1839 wxDynamicLibrary
dllKernel(_T("kernel32"));
1841 const wxChar
* GetLongPathName
= _T("GetLongPathName")
1846 #endif // Unicode/ANSI
1848 if ( dllKernel
.HasSymbol(GetLongPathName
) )
1850 s_pfnGetLongPathName
= (GET_LONG_PATH_NAME
)
1851 dllKernel
.GetSymbol(GetLongPathName
);
1854 // note that kernel32.dll can be unloaded, it stays in memory
1855 // anyhow as all Win32 programs link to it and so it's safe to call
1856 // GetLongPathName() even after unloading it
1860 if ( s_pfnGetLongPathName
)
1862 DWORD dwSize
= (*s_pfnGetLongPathName
)(path
.fn_str(), NULL
, 0);
1865 if ( (*s_pfnGetLongPathName
)
1868 wxStringBuffer(pathOut
, dwSize
),
1876 #endif // wxUSE_DYNLIB_CLASS
1878 // The OS didn't support GetLongPathName, or some other error.
1879 // We need to call FindFirstFile on each component in turn.
1881 WIN32_FIND_DATA findFileData
;
1885 pathOut
= GetVolume() +
1886 GetVolumeSeparator(wxPATH_DOS
) +
1887 GetPathSeparator(wxPATH_DOS
);
1889 pathOut
= wxEmptyString
;
1891 wxArrayString dirs
= GetDirs();
1892 dirs
.Add(GetFullName());
1896 size_t count
= dirs
.GetCount();
1897 for ( size_t i
= 0; i
< count
; i
++ )
1899 // We're using pathOut to collect the long-name path, but using a
1900 // temporary for appending the last path component which may be
1902 tmpPath
= pathOut
+ dirs
[i
];
1904 if ( tmpPath
.empty() )
1907 // can't see this being necessary? MF
1908 if ( tmpPath
.Last() == GetVolumeSeparator(wxPATH_DOS
) )
1910 // Can't pass a drive and root dir to FindFirstFile,
1911 // so continue to next dir
1912 tmpPath
+= wxFILE_SEP_PATH
;
1917 hFind
= ::FindFirstFile(tmpPath
.fn_str(), &findFileData
);
1918 if (hFind
== INVALID_HANDLE_VALUE
)
1920 // Error: most likely reason is that path doesn't exist, so
1921 // append any unprocessed parts and return
1922 for ( i
+= 1; i
< count
; i
++ )
1923 tmpPath
+= wxFILE_SEP_PATH
+ dirs
[i
];
1928 pathOut
+= findFileData
.cFileName
;
1929 if ( (i
< (count
-1)) )
1930 pathOut
+= wxFILE_SEP_PATH
;
1936 #endif // Win32/!Win32
1941 wxPathFormat
wxFileName::GetFormat( wxPathFormat format
)
1943 if (format
== wxPATH_NATIVE
)
1945 #if defined(__WXMSW__) || defined(__OS2__) || defined(__DOS__)
1946 format
= wxPATH_DOS
;
1947 #elif defined(__VMS)
1948 format
= wxPATH_VMS
;
1950 format
= wxPATH_UNIX
;
1956 // ----------------------------------------------------------------------------
1957 // path splitting function
1958 // ----------------------------------------------------------------------------
1962 wxFileName::SplitVolume(const wxString
& fullpathWithVolume
,
1963 wxString
*pstrVolume
,
1965 wxPathFormat format
)
1967 format
= GetFormat(format
);
1969 wxString fullpath
= fullpathWithVolume
;
1971 // special Windows UNC paths hack: transform \\share\path into share:path
1972 if ( IsUNCPath(fullpath
, format
) )
1974 fullpath
.erase(0, 2);
1976 size_t posFirstSlash
=
1977 fullpath
.find_first_of(GetPathTerminators(format
));
1978 if ( posFirstSlash
!= wxString::npos
)
1980 fullpath
[posFirstSlash
] = wxFILE_SEP_DSK
;
1982 // UNC paths are always absolute, right? (FIXME)
1983 fullpath
.insert(posFirstSlash
+ 1, 1, wxFILE_SEP_PATH_DOS
);
1987 // We separate the volume here
1988 if ( format
== wxPATH_DOS
|| format
== wxPATH_VMS
)
1990 wxString sepVol
= GetVolumeSeparator(format
);
1992 size_t posFirstColon
= fullpath
.find_first_of(sepVol
);
1993 if ( posFirstColon
!= wxString::npos
)
1997 *pstrVolume
= fullpath
.Left(posFirstColon
);
2000 // remove the volume name and the separator from the full path
2001 fullpath
.erase(0, posFirstColon
+ sepVol
.length());
2006 *pstrPath
= fullpath
;
2010 void wxFileName::SplitPath(const wxString
& fullpathWithVolume
,
2011 wxString
*pstrVolume
,
2016 wxPathFormat format
)
2018 format
= GetFormat(format
);
2021 SplitVolume(fullpathWithVolume
, pstrVolume
, &fullpath
, format
);
2023 // find the positions of the last dot and last path separator in the path
2024 size_t posLastDot
= fullpath
.find_last_of(wxFILE_SEP_EXT
);
2025 size_t posLastSlash
= fullpath
.find_last_of(GetPathTerminators(format
));
2027 // check whether this dot occurs at the very beginning of a path component
2028 if ( (posLastDot
!= wxString::npos
) &&
2030 IsPathSeparator(fullpath
[posLastDot
- 1]) ||
2031 (format
== wxPATH_VMS
&& fullpath
[posLastDot
- 1] == _T(']'))) )
2033 // dot may be (and commonly -- at least under Unix -- is) the first
2034 // character of the filename, don't treat the entire filename as
2035 // extension in this case
2036 posLastDot
= wxString::npos
;
2039 // if we do have a dot and a slash, check that the dot is in the name part
2040 if ( (posLastDot
!= wxString::npos
) &&
2041 (posLastSlash
!= wxString::npos
) &&
2042 (posLastDot
< posLastSlash
) )
2044 // the dot is part of the path, not the start of the extension
2045 posLastDot
= wxString::npos
;
2048 // now fill in the variables provided by user
2051 if ( posLastSlash
== wxString::npos
)
2058 // take everything up to the path separator but take care to make
2059 // the path equal to something like '/', not empty, for the files
2060 // immediately under root directory
2061 size_t len
= posLastSlash
;
2063 // this rule does not apply to mac since we do not start with colons (sep)
2064 // except for relative paths
2065 if ( !len
&& format
!= wxPATH_MAC
)
2068 *pstrPath
= fullpath
.Left(len
);
2070 // special VMS hack: remove the initial bracket
2071 if ( format
== wxPATH_VMS
)
2073 if ( (*pstrPath
)[0u] == _T('[') )
2074 pstrPath
->erase(0, 1);
2081 // take all characters starting from the one after the last slash and
2082 // up to, but excluding, the last dot
2083 size_t nStart
= posLastSlash
== wxString::npos
? 0 : posLastSlash
+ 1;
2085 if ( posLastDot
== wxString::npos
)
2087 // take all until the end
2088 count
= wxString::npos
;
2090 else if ( posLastSlash
== wxString::npos
)
2094 else // have both dot and slash
2096 count
= posLastDot
- posLastSlash
- 1;
2099 *pstrName
= fullpath
.Mid(nStart
, count
);
2102 // finally deal with the extension here: we have an added complication that
2103 // extension may be empty (but present) as in "foo." where trailing dot
2104 // indicates the empty extension at the end -- and hence we must remember
2105 // that we have it independently of pstrExt
2106 if ( posLastDot
== wxString::npos
)
2116 // take everything after the dot
2118 *pstrExt
= fullpath
.Mid(posLastDot
+ 1);
2125 void wxFileName::SplitPath(const wxString
& fullpath
,
2129 wxPathFormat format
)
2132 SplitPath(fullpath
, &volume
, path
, name
, ext
, format
);
2136 path
->Prepend(wxGetVolumeString(volume
, format
));
2140 // ----------------------------------------------------------------------------
2142 // ----------------------------------------------------------------------------
2146 bool wxFileName::SetTimes(const wxDateTime
*dtAccess
,
2147 const wxDateTime
*dtMod
,
2148 const wxDateTime
*dtCreate
)
2150 #if defined(__WIN32__)
2153 // VZ: please let me know how to do this if you can
2154 wxFAIL_MSG( _T("SetTimes() not implemented for the directories") );
2158 wxFileHandle
fh(GetFullPath(), wxFileHandle::Write
);
2161 FILETIME ftAccess
, ftCreate
, ftWrite
;
2164 ConvertWxToFileTime(&ftCreate
, *dtCreate
);
2166 ConvertWxToFileTime(&ftAccess
, *dtAccess
);
2168 ConvertWxToFileTime(&ftWrite
, *dtMod
);
2170 if ( ::SetFileTime(fh
,
2171 dtCreate
? &ftCreate
: NULL
,
2172 dtAccess
? &ftAccess
: NULL
,
2173 dtMod
? &ftWrite
: NULL
) )
2179 #elif defined(__UNIX_LIKE__) || (defined(__DOS__) && defined(__WATCOMC__))
2180 wxUnusedVar(dtCreate
);
2182 if ( !dtAccess
&& !dtMod
)
2184 // can't modify the creation time anyhow, don't try
2188 // if dtAccess or dtMod is not specified, use the other one (which must be
2189 // non NULL because of the test above) for both times
2191 utm
.actime
= dtAccess
? dtAccess
->GetTicks() : dtMod
->GetTicks();
2192 utm
.modtime
= dtMod
? dtMod
->GetTicks() : dtAccess
->GetTicks();
2193 if ( utime(GetFullPath().fn_str(), &utm
) == 0 )
2197 #else // other platform
2198 wxUnusedVar(dtAccess
);
2200 wxUnusedVar(dtCreate
);
2203 wxLogSysError(_("Failed to modify file times for '%s'"),
2204 GetFullPath().c_str());
2209 bool wxFileName::Touch()
2211 #if defined(__UNIX_LIKE__)
2212 // under Unix touching file is simple: just pass NULL to utime()
2213 if ( utime(GetFullPath().fn_str(), NULL
) == 0 )
2218 wxLogSysError(_("Failed to touch the file '%s'"), GetFullPath().c_str());
2221 #else // other platform
2222 wxDateTime dtNow
= wxDateTime::Now();
2224 return SetTimes(&dtNow
, &dtNow
, NULL
/* don't change create time */);
2228 bool wxFileName::GetTimes(wxDateTime
*dtAccess
,
2230 wxDateTime
*dtCreate
) const
2232 #if defined(__WIN32__)
2233 // we must use different methods for the files and directories under
2234 // Windows as CreateFile(GENERIC_READ) doesn't work for the directories and
2235 // CreateFile(FILE_FLAG_BACKUP_SEMANTICS) works -- but only under NT and
2238 FILETIME ftAccess
, ftCreate
, ftWrite
;
2241 // implemented in msw/dir.cpp
2242 extern bool wxGetDirectoryTimes(const wxString
& dirname
,
2243 FILETIME
*, FILETIME
*, FILETIME
*);
2245 // we should pass the path without the trailing separator to
2246 // wxGetDirectoryTimes()
2247 ok
= wxGetDirectoryTimes(GetPath(wxPATH_GET_VOLUME
),
2248 &ftAccess
, &ftCreate
, &ftWrite
);
2252 wxFileHandle
fh(GetFullPath(), wxFileHandle::Read
);
2255 ok
= ::GetFileTime(fh
,
2256 dtCreate
? &ftCreate
: NULL
,
2257 dtAccess
? &ftAccess
: NULL
,
2258 dtMod
? &ftWrite
: NULL
) != 0;
2269 ConvertFileTimeToWx(dtCreate
, ftCreate
);
2271 ConvertFileTimeToWx(dtAccess
, ftAccess
);
2273 ConvertFileTimeToWx(dtMod
, ftWrite
);
2277 #elif defined(__UNIX_LIKE__) || defined(__WXMAC__) || defined(__OS2__) || (defined(__DOS__) && defined(__WATCOMC__))
2278 // no need to test for IsDir() here
2280 if ( wxStat( GetFullPath().c_str(), &stBuf
) == 0 )
2283 dtAccess
->Set(stBuf
.st_atime
);
2285 dtMod
->Set(stBuf
.st_mtime
);
2287 dtCreate
->Set(stBuf
.st_ctime
);
2291 #else // other platform
2292 wxUnusedVar(dtAccess
);
2294 wxUnusedVar(dtCreate
);
2297 wxLogSysError(_("Failed to retrieve file times for '%s'"),
2298 GetFullPath().c_str());
2303 #endif // wxUSE_DATETIME
2306 // ----------------------------------------------------------------------------
2307 // file size functions
2308 // ----------------------------------------------------------------------------
2313 wxULongLong
wxFileName::GetSize(const wxString
&filename
)
2315 if (!wxFileExists(filename
))
2316 return wxInvalidSize
;
2318 #if defined(__WXPALMOS__)
2320 return wxInvalidSize
;
2321 #elif defined(__WIN32__)
2322 wxFileHandle
f(filename
, wxFileHandle::Read
);
2324 return wxInvalidSize
;
2326 DWORD lpFileSizeHigh
;
2327 DWORD ret
= GetFileSize(f
, &lpFileSizeHigh
);
2328 if ( ret
== INVALID_FILE_SIZE
&& ::GetLastError() != NO_ERROR
)
2329 return wxInvalidSize
;
2331 return wxULongLong(lpFileSizeHigh
, ret
);
2332 #else // ! __WIN32__
2334 #ifndef wxNEED_WX_UNISTD_H
2335 if (wxStat( filename
.fn_str() , &st
) != 0)
2337 if (wxStat( filename
, &st
) != 0)
2339 return wxInvalidSize
;
2340 return wxULongLong(st
.st_size
);
2345 wxString
wxFileName::GetHumanReadableSize(const wxULongLong
&bs
,
2346 const wxString
&nullsize
,
2349 static const double KILOBYTESIZE
= 1024.0;
2350 static const double MEGABYTESIZE
= 1024.0*KILOBYTESIZE
;
2351 static const double GIGABYTESIZE
= 1024.0*MEGABYTESIZE
;
2352 static const double TERABYTESIZE
= 1024.0*GIGABYTESIZE
;
2354 if (bs
== 0 || bs
== wxInvalidSize
)
2357 double bytesize
= bs
.ToDouble();
2358 if (bytesize
< KILOBYTESIZE
)
2359 return wxString::Format(_("%s B"), bs
.ToString().c_str());
2360 if (bytesize
< MEGABYTESIZE
)
2361 return wxString::Format(_("%.*f kB"), precision
, bytesize
/KILOBYTESIZE
);
2362 if (bytesize
< GIGABYTESIZE
)
2363 return wxString::Format(_("%.*f MB"), precision
, bytesize
/MEGABYTESIZE
);
2364 if (bytesize
< TERABYTESIZE
)
2365 return wxString::Format(_("%.*f GB"), precision
, bytesize
/GIGABYTESIZE
);
2367 return wxString::Format(_("%.*f TB"), precision
, bytesize
/TERABYTESIZE
);
2370 wxULongLong
wxFileName::GetSize() const
2372 return GetSize(GetFullPath());
2375 wxString
wxFileName::GetHumanReadableSize(const wxString
&failmsg
, int precision
) const
2377 return GetHumanReadableSize(GetSize(), failmsg
, precision
);
2380 #endif // wxUSE_LONGLONG
2382 // ----------------------------------------------------------------------------
2383 // Mac-specific functions
2384 // ----------------------------------------------------------------------------
2386 #if defined( __WXOSX_MAC__ ) && wxOSX_USE_CARBON
2388 const short kMacExtensionMaxLength
= 16 ;
2389 class MacDefaultExtensionRecord
2392 MacDefaultExtensionRecord()
2395 m_type
= m_creator
= 0 ;
2397 MacDefaultExtensionRecord( const MacDefaultExtensionRecord
& from
)
2399 wxStrcpy( m_ext
, from
.m_ext
) ;
2400 m_type
= from
.m_type
;
2401 m_creator
= from
.m_creator
;
2403 MacDefaultExtensionRecord( const wxChar
* extension
, OSType type
, OSType creator
)
2405 wxStrncpy( m_ext
, extension
, kMacExtensionMaxLength
) ;
2406 m_ext
[kMacExtensionMaxLength
] = 0 ;
2408 m_creator
= creator
;
2410 wxChar m_ext
[kMacExtensionMaxLength
] ;
2415 WX_DECLARE_OBJARRAY(MacDefaultExtensionRecord
, MacDefaultExtensionArray
) ;
2417 bool gMacDefaultExtensionsInited
= false ;
2419 #include "wx/arrimpl.cpp"
2421 WX_DEFINE_EXPORTED_OBJARRAY(MacDefaultExtensionArray
) ;
2423 MacDefaultExtensionArray gMacDefaultExtensions
;
2425 // load the default extensions
2426 MacDefaultExtensionRecord gDefaults
[] =
2428 MacDefaultExtensionRecord( wxT("txt") , 'TEXT' , 'ttxt' ) ,
2429 MacDefaultExtensionRecord( wxT("tif") , 'TIFF' , '****' ) ,
2430 MacDefaultExtensionRecord( wxT("jpg") , 'JPEG' , '****' ) ,
2433 static void MacEnsureDefaultExtensionsLoaded()
2435 if ( !gMacDefaultExtensionsInited
)
2437 // we could load the pc exchange prefs here too
2438 for ( size_t i
= 0 ; i
< WXSIZEOF( gDefaults
) ; ++i
)
2440 gMacDefaultExtensions
.Add( gDefaults
[i
] ) ;
2442 gMacDefaultExtensionsInited
= true ;
2446 bool wxFileName::MacSetTypeAndCreator( wxUint32 type
, wxUint32 creator
)
2449 FSCatalogInfo catInfo
;
2452 if ( wxMacPathToFSRef( GetFullPath() , &fsRef
) == noErr
)
2454 if ( FSGetCatalogInfo (&fsRef
, kFSCatInfoFinderInfo
, &catInfo
, NULL
, NULL
, NULL
) == noErr
)
2456 finfo
= (FileInfo
*)&catInfo
.finderInfo
;
2457 finfo
->fileType
= type
;
2458 finfo
->fileCreator
= creator
;
2459 FSSetCatalogInfo( &fsRef
, kFSCatInfoFinderInfo
, &catInfo
) ;
2466 bool wxFileName::MacGetTypeAndCreator( wxUint32
*type
, wxUint32
*creator
)
2469 FSCatalogInfo catInfo
;
2472 if ( wxMacPathToFSRef( GetFullPath() , &fsRef
) == noErr
)
2474 if ( FSGetCatalogInfo (&fsRef
, kFSCatInfoFinderInfo
, &catInfo
, NULL
, NULL
, NULL
) == noErr
)
2476 finfo
= (FileInfo
*)&catInfo
.finderInfo
;
2477 *type
= finfo
->fileType
;
2478 *creator
= finfo
->fileCreator
;
2485 bool wxFileName::MacSetDefaultTypeAndCreator()
2487 wxUint32 type
, creator
;
2488 if ( wxFileName::MacFindDefaultTypeAndCreator(GetExt() , &type
,
2491 return MacSetTypeAndCreator( type
, creator
) ;
2496 bool wxFileName::MacFindDefaultTypeAndCreator( const wxString
& ext
, wxUint32
*type
, wxUint32
*creator
)
2498 MacEnsureDefaultExtensionsLoaded() ;
2499 wxString extl
= ext
.Lower() ;
2500 for( int i
= gMacDefaultExtensions
.Count() - 1 ; i
>= 0 ; --i
)
2502 if ( gMacDefaultExtensions
.Item(i
).m_ext
== extl
)
2504 *type
= gMacDefaultExtensions
.Item(i
).m_type
;
2505 *creator
= gMacDefaultExtensions
.Item(i
).m_creator
;
2512 void wxFileName::MacRegisterDefaultTypeAndCreator( const wxString
& ext
, wxUint32 type
, wxUint32 creator
)
2514 MacEnsureDefaultExtensionsLoaded() ;
2515 MacDefaultExtensionRecord rec
;
2517 rec
.m_creator
= creator
;
2518 wxStrncpy( rec
.m_ext
, ext
.Lower().c_str() , kMacExtensionMaxLength
) ;
2519 gMacDefaultExtensions
.Add( rec
) ;