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 and
26 MSW unique volume names of the form \\?\Volume{GUID}\fullpath.
28 The latter provide a uniform way to access a volume regardless of
29 its current mount point, i.e. you can change a volume's mount
30 point from D: to E:, or even remove it, and still be able to
31 access it through its unique volume name. More on the subject can
32 be found in MSDN's article "Naming a Volume" that is currently at
33 http://msdn.microsoft.com/en-us/library/aa365248(VS.85).aspx.
36 wxPATH_MAC: Mac OS 8/9 and Mac OS X under CodeWarrior 7 format, absolute file
38 volume:dir1:...:dirN:filename
39 and the relative file names are either
40 :dir1:...:dirN:filename
43 (although :filename works as well).
44 Since the volume is just part of the file path, it is not
45 treated like a separate entity as it is done under DOS and
46 VMS, it is just treated as another dir.
48 wxPATH_VMS: VMS native format, absolute file names have the form
49 <device>:[dir1.dir2.dir3]file.txt
51 <device>:[000000.dir1.dir2.dir3]file.txt
53 the <device> is the physical device (i.e. disk). 000000 is the
54 root directory on the device which can be omitted.
56 Note that VMS uses different separators unlike Unix:
57 : always after the device. If the path does not contain : than
58 the default (the device of the current directory) is assumed.
59 [ start of directory specification
60 . separator between directory and subdirectory
61 ] between directory and file
64 // ============================================================================
66 // ============================================================================
68 // ----------------------------------------------------------------------------
70 // ----------------------------------------------------------------------------
72 // For compilers that support precompilation, includes "wx.h".
73 #include "wx/wxprec.h"
81 #include "wx/msw/wrapwin.h" // For GetShort/LongPathName
83 #include "wx/dynarray.h"
90 #include "wx/filename.h"
91 #include "wx/private/filename.h"
92 #include "wx/tokenzr.h"
93 #include "wx/config.h" // for wxExpandEnvVars
94 #include "wx/dynlib.h"
97 #if defined(__WIN32__) && defined(__MINGW32__)
98 #include "wx/msw/gccpriv.h"
102 #include "wx/msw/private.h"
105 #if defined(__WXMAC__)
106 #include "wx/osx/private.h" // includes mac headers
109 // utime() is POSIX so should normally be available on all Unices
111 #include <sys/types.h>
113 #include <sys/stat.h>
123 #include <sys/types.h>
125 #include <sys/stat.h>
136 #include <sys/utime.h>
137 #include <sys/stat.h>
148 #define MAX_PATH _MAX_PATH
152 #define S_ISREG(mode) ((mode) & S_IFREG)
155 #define S_ISDIR(mode) ((mode) & S_IFDIR)
159 extern const wxULongLong wxInvalidSize
= (unsigned)-1;
160 #endif // wxUSE_LONGLONG
165 // ----------------------------------------------------------------------------
167 // ----------------------------------------------------------------------------
169 // small helper class which opens and closes the file - we use it just to get
170 // a file handle for the given file name to pass it to some Win32 API function
171 #if defined(__WIN32__) && !defined(__WXMICROWIN__)
182 wxFileHandle(const wxString
& filename
, OpenMode mode
, int flags
= 0)
184 // be careful and use FILE_{READ,WRITE}_ATTRIBUTES here instead of the
185 // usual GENERIC_{READ,WRITE} as we don't want the file access time to
186 // be changed when we open it because this class is used for setting
187 // access time (see #10567)
188 m_hFile
= ::CreateFile
190 filename
.t_str(), // name
191 mode
== ReadAttr
? FILE_READ_ATTRIBUTES
// access mask
192 : FILE_WRITE_ATTRIBUTES
,
193 FILE_SHARE_READ
| // sharing mode
194 FILE_SHARE_WRITE
, // (allow everything)
195 NULL
, // no secutity attr
196 OPEN_EXISTING
, // creation disposition
198 NULL
// no template file
201 if ( m_hFile
== INVALID_HANDLE_VALUE
)
203 if ( mode
== ReadAttr
)
205 wxLogSysError(_("Failed to open '%s' for reading"),
210 wxLogSysError(_("Failed to open '%s' for writing"),
218 if ( m_hFile
!= INVALID_HANDLE_VALUE
)
220 if ( !::CloseHandle(m_hFile
) )
222 wxLogSysError(_("Failed to close file handle"));
227 // return true only if the file could be opened successfully
228 bool IsOk() const { return m_hFile
!= INVALID_HANDLE_VALUE
; }
231 operator HANDLE() const { return m_hFile
; }
239 // ----------------------------------------------------------------------------
241 // ----------------------------------------------------------------------------
243 #if wxUSE_DATETIME && defined(__WIN32__) && !defined(__WXMICROWIN__)
245 // convert between wxDateTime and FILETIME which is a 64-bit value representing
246 // the number of 100-nanosecond intervals since January 1, 1601.
248 static void ConvertFileTimeToWx(wxDateTime
*dt
, const FILETIME
&ft
)
250 FILETIME ftcopy
= ft
;
252 if ( !::FileTimeToLocalFileTime(&ftcopy
, &ftLocal
) )
254 wxLogLastError(wxT("FileTimeToLocalFileTime"));
258 if ( !::FileTimeToSystemTime(&ftLocal
, &st
) )
260 wxLogLastError(wxT("FileTimeToSystemTime"));
263 dt
->Set(st
.wDay
, wxDateTime::Month(st
.wMonth
- 1), st
.wYear
,
264 st
.wHour
, st
.wMinute
, st
.wSecond
, st
.wMilliseconds
);
267 static void ConvertWxToFileTime(FILETIME
*ft
, const wxDateTime
& dt
)
270 st
.wDay
= dt
.GetDay();
271 st
.wMonth
= (WORD
)(dt
.GetMonth() + 1);
272 st
.wYear
= (WORD
)dt
.GetYear();
273 st
.wHour
= dt
.GetHour();
274 st
.wMinute
= dt
.GetMinute();
275 st
.wSecond
= dt
.GetSecond();
276 st
.wMilliseconds
= dt
.GetMillisecond();
279 if ( !::SystemTimeToFileTime(&st
, &ftLocal
) )
281 wxLogLastError(wxT("SystemTimeToFileTime"));
284 if ( !::LocalFileTimeToFileTime(&ftLocal
, ft
) )
286 wxLogLastError(wxT("LocalFileTimeToFileTime"));
290 #endif // wxUSE_DATETIME && __WIN32__
292 // return a string with the volume par
293 static wxString
wxGetVolumeString(const wxString
& volume
, wxPathFormat format
)
297 if ( !volume
.empty() )
299 format
= wxFileName::GetFormat(format
);
301 // Special Windows UNC paths hack, part 2: undo what we did in
302 // SplitPath() and make an UNC path if we have a drive which is not a
303 // single letter (hopefully the network shares can't be one letter only
304 // although I didn't find any authoritative docs on this)
305 if ( format
== wxPATH_DOS
&& volume
.length() > 1 )
307 // We also have to check for Windows unique volume names here and
308 // return it with '\\?\' prepended to it
309 if ( wxFileName::IsMSWUniqueVolumeNamePath("\\\\?\\" + volume
+ "\\",
312 path
<< "\\\\?\\" << volume
;
316 // it must be a UNC path
317 path
<< wxFILE_SEP_PATH_DOS
<< wxFILE_SEP_PATH_DOS
<< volume
;
320 else if ( format
== wxPATH_DOS
|| format
== wxPATH_VMS
)
322 path
<< volume
<< wxFileName::GetVolumeSeparator(format
);
330 // return true if the character is a DOS path separator i.e. either a slash or
332 inline bool IsDOSPathSep(wxUniChar ch
)
334 return ch
== wxFILE_SEP_PATH_DOS
|| ch
== wxFILE_SEP_PATH_UNIX
;
337 // return true if the format used is the DOS/Windows one and the string looks
339 static bool IsUNCPath(const wxString
& path
, wxPathFormat format
)
341 return format
== wxPATH_DOS
&&
342 path
.length() >= 4 && // "\\a" can't be a UNC path
343 IsDOSPathSep(path
[0u]) &&
344 IsDOSPathSep(path
[1u]) &&
345 !IsDOSPathSep(path
[2u]);
348 // ----------------------------------------------------------------------------
350 // ----------------------------------------------------------------------------
352 // length of \\?\Volume{xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}\ string
353 static const size_t wxMSWUniqueVolumePrefixLength
= 49;
355 } // anonymous namespace
357 // ============================================================================
359 // ============================================================================
361 // ----------------------------------------------------------------------------
362 // wxFileName construction
363 // ----------------------------------------------------------------------------
365 void wxFileName::Assign( const wxFileName
&filepath
)
367 m_volume
= filepath
.GetVolume();
368 m_dirs
= filepath
.GetDirs();
369 m_name
= filepath
.GetName();
370 m_ext
= filepath
.GetExt();
371 m_relative
= filepath
.m_relative
;
372 m_hasExt
= filepath
.m_hasExt
;
375 void wxFileName::Assign(const wxString
& volume
,
376 const wxString
& path
,
377 const wxString
& name
,
382 // we should ignore paths which look like UNC shares because we already
383 // have the volume here and the UNC notation (\\server\path) is only valid
384 // for paths which don't start with a volume, so prevent SetPath() from
385 // recognizing "\\foo\bar" in "c:\\foo\bar" as an UNC path
387 // note also that this is a rather ugly way to do what we want (passing
388 // some kind of flag telling to ignore UNC paths to SetPath() would be
389 // better) but this is the safest thing to do to avoid breaking backwards
390 // compatibility in 2.8
391 if ( IsUNCPath(path
, format
) )
393 // remove one of the 2 leading backslashes to ensure that it's not
394 // recognized as an UNC path by SetPath()
395 wxString
pathNonUNC(path
, 1, wxString::npos
);
396 SetPath(pathNonUNC
, format
);
398 else // no UNC complications
400 SetPath(path
, format
);
410 void wxFileName::SetPath( const wxString
& pathOrig
, wxPathFormat format
)
414 if ( pathOrig
.empty() )
422 format
= GetFormat( format
);
424 // 0) deal with possible volume part first
427 SplitVolume(pathOrig
, &volume
, &path
, format
);
428 if ( !volume
.empty() )
435 // 1) Determine if the path is relative or absolute.
439 // we had only the volume
443 wxChar leadingChar
= path
[0u];
448 m_relative
= leadingChar
== wxT(':');
450 // We then remove a leading ":". The reason is in our
451 // storage form for relative paths:
452 // ":dir:file.txt" actually means "./dir/file.txt" in
453 // DOS notation and should get stored as
454 // (relative) (dir) (file.txt)
455 // "::dir:file.txt" actually means "../dir/file.txt"
456 // stored as (relative) (..) (dir) (file.txt)
457 // This is important only for the Mac as an empty dir
458 // actually means <UP>, whereas under DOS, double
459 // slashes can be ignored: "\\\\" is the same as "\\".
465 // TODO: what is the relative path format here?
470 wxFAIL_MSG( wxT("Unknown path format") );
471 // !! Fall through !!
474 m_relative
= leadingChar
!= wxT('/');
478 m_relative
= !IsPathSeparator(leadingChar
, format
);
483 // 2) Break up the path into its members. If the original path
484 // was just "/" or "\\", m_dirs will be empty. We know from
485 // the m_relative field, if this means "nothing" or "root dir".
487 wxStringTokenizer
tn( path
, GetPathSeparators(format
) );
489 while ( tn
.HasMoreTokens() )
491 wxString token
= tn
.GetNextToken();
493 // Remove empty token under DOS and Unix, interpret them
497 if (format
== wxPATH_MAC
)
498 m_dirs
.Add( wxT("..") );
508 void wxFileName::Assign(const wxString
& fullpath
,
511 wxString volume
, path
, name
, ext
;
513 SplitPath(fullpath
, &volume
, &path
, &name
, &ext
, &hasExt
, format
);
515 Assign(volume
, path
, name
, ext
, hasExt
, format
);
518 void wxFileName::Assign(const wxString
& fullpathOrig
,
519 const wxString
& fullname
,
522 // always recognize fullpath as directory, even if it doesn't end with a
524 wxString fullpath
= fullpathOrig
;
525 if ( !fullpath
.empty() && !wxEndsWithPathSeparator(fullpath
) )
527 fullpath
+= GetPathSeparator(format
);
530 wxString volume
, path
, name
, ext
;
533 // do some consistency checks: the name should be really just the filename
534 // and the path should be really just a path
535 wxString volDummy
, pathDummy
, nameDummy
, extDummy
;
537 SplitPath(fullname
, &volDummy
, &pathDummy
, &name
, &ext
, &hasExt
, format
);
539 wxASSERT_MSG( volDummy
.empty() && pathDummy
.empty(),
540 wxT("the file name shouldn't contain the path") );
542 SplitPath(fullpath
, &volume
, &path
, &nameDummy
, &extDummy
, format
);
545 // This test makes no sense on an OpenVMS system.
546 wxASSERT_MSG( nameDummy
.empty() && extDummy
.empty(),
547 wxT("the path shouldn't contain file name nor extension") );
549 Assign(volume
, path
, name
, ext
, hasExt
, format
);
552 void wxFileName::Assign(const wxString
& pathOrig
,
553 const wxString
& name
,
559 SplitVolume(pathOrig
, &volume
, &path
, format
);
561 Assign(volume
, path
, name
, ext
, format
);
564 void wxFileName::AssignDir(const wxString
& dir
, wxPathFormat format
)
566 Assign(dir
, wxEmptyString
, format
);
569 void wxFileName::Clear()
575 m_ext
= wxEmptyString
;
577 // we don't have any absolute path for now
585 wxFileName
wxFileName::FileName(const wxString
& file
, wxPathFormat format
)
587 return wxFileName(file
, format
);
591 wxFileName
wxFileName::DirName(const wxString
& dir
, wxPathFormat format
)
594 fn
.AssignDir(dir
, format
);
598 // ----------------------------------------------------------------------------
600 // ----------------------------------------------------------------------------
605 // Flags for wxFileSystemObjectExists() asking it to check for:
608 wxFileSystemObject_File
= 1, // file existence
609 wxFileSystemObject_Dir
= 2, // directory existence
610 wxFileSystemObject_Other
= 4, // existence of something else, e.g.
611 // device, socket, FIFO under Unix
612 wxFileSystemObject_Any
= 7 // existence of anything at all
615 #if defined(__WINDOWS__) && !defined(__WXMICROWIN__)
617 void RemoveTrailingSeparatorsFromPath(wxString
& strPath
)
619 // Windows fails to find directory named "c:\dir\" even if "c:\dir" exists,
620 // so remove all trailing backslashes from the path - but don't do this for
621 // the paths "d:\" (which are different from "d:"), for just "\" or for
622 // windows unique volume names ("\\?\Volume{GUID}\")
623 while ( wxEndsWithPathSeparator( strPath
) )
625 size_t len
= strPath
.length();
626 if ( len
== 1 || (len
== 3 && strPath
[len
- 2] == wxT(':')) ||
627 (len
== wxMSWUniqueVolumePrefixLength
&&
628 wxFileName::IsMSWUniqueVolumeNamePath(strPath
)))
633 strPath
.Truncate(len
- 1);
637 #endif // __WINDOWS__ || __OS2__
639 bool wxFileSystemObjectExists(const wxString
& path
, int flags
)
641 // Should the existence of file/directory with this name be accepted, i.e.
642 // result in the true return value from this function?
643 const bool acceptFile
= flags
& wxFileSystemObject_File
;
644 const bool acceptDir
= flags
& wxFileSystemObject_Dir
;
646 wxString
strPath(path
);
648 #if defined(__WINDOWS__) && !defined(__WXMICROWIN__)
651 // Ensure that the path doesn't have any trailing separators when
652 // checking for directories.
653 RemoveTrailingSeparatorsFromPath(strPath
);
656 // we must use GetFileAttributes() instead of the ANSI C functions because
657 // it can cope with network (UNC) paths unlike them
658 DWORD ret
= ::GetFileAttributes(path
.t_str());
660 if ( ret
== INVALID_FILE_ATTRIBUTES
)
663 if ( ret
& FILE_ATTRIBUTE_DIRECTORY
)
666 // Anything else must be a file (perhaps we should check for
667 // FILE_ATTRIBUTE_REPARSE_POINT?)
669 #elif defined(__OS2__)
672 // OS/2 can't handle "d:", it wants either "d:\" or "d:."
673 if (strPath
.length() == 2 && strPath
[1u] == wxT(':'))
677 FILESTATUS3 Info
= {{0}};
678 APIRET rc
= ::DosQueryPathInfo((PSZ
)(WXSTRINGCAST strPath
), FIL_STANDARD
,
679 (void*) &Info
, sizeof(FILESTATUS3
));
681 if ( rc
== NO_ERROR
)
683 if ( Info
.attrFile
& FILE_DIRECTORY
)
689 // We consider that the path must exist if we get a sharing violation for
690 // it but we don't know what is it in this case.
691 if ( rc
== ERROR_SHARING_VIOLATION
)
692 return flags
& wxFileSystemObject_Other
;
694 // Any other error (usually ERROR_PATH_NOT_FOUND), means there is nothing
697 #else // Non-MSW, non-OS/2
699 if ( wxStat(strPath
, &st
) != 0 )
702 if ( S_ISREG(st
.st_mode
) )
704 if ( S_ISDIR(st
.st_mode
) )
707 return flags
& wxFileSystemObject_Other
;
711 } // anonymous namespace
713 bool wxFileName::FileExists() const
715 return wxFileName::FileExists( GetFullPath() );
719 bool wxFileName::FileExists( const wxString
&filePath
)
721 return wxFileSystemObjectExists(filePath
, wxFileSystemObject_File
);
724 bool wxFileName::DirExists() const
726 return wxFileName::DirExists( GetPath() );
730 bool wxFileName::DirExists( const wxString
&dirPath
)
732 return wxFileSystemObjectExists(dirPath
, wxFileSystemObject_Dir
);
736 bool wxFileName::Exists(const wxString
& path
)
738 return wxFileSystemObjectExists(path
, wxFileSystemObject_Any
);
741 // ----------------------------------------------------------------------------
742 // CWD and HOME stuff
743 // ----------------------------------------------------------------------------
745 void wxFileName::AssignCwd(const wxString
& volume
)
747 AssignDir(wxFileName::GetCwd(volume
));
751 wxString
wxFileName::GetCwd(const wxString
& volume
)
753 // if we have the volume, we must get the current directory on this drive
754 // and to do this we have to chdir to this volume - at least under Windows,
755 // I don't know how to get the current drive on another volume elsewhere
758 if ( !volume
.empty() )
761 SetCwd(volume
+ GetVolumeSeparator());
764 wxString cwd
= ::wxGetCwd();
766 if ( !volume
.empty() )
774 bool wxFileName::SetCwd() const
776 return wxFileName::SetCwd( GetPath() );
779 bool wxFileName::SetCwd( const wxString
&cwd
)
781 return ::wxSetWorkingDirectory( cwd
);
784 void wxFileName::AssignHomeDir()
786 AssignDir(wxFileName::GetHomeDir());
789 wxString
wxFileName::GetHomeDir()
791 return ::wxGetHomeDir();
795 // ----------------------------------------------------------------------------
796 // CreateTempFileName
797 // ----------------------------------------------------------------------------
799 #if wxUSE_FILE || wxUSE_FFILE
802 #if !defined wx_fdopen && defined HAVE_FDOPEN
803 #define wx_fdopen fdopen
806 // NB: GetTempFileName() under Windows creates the file, so using
807 // O_EXCL there would fail
809 #define wxOPEN_EXCL 0
811 #define wxOPEN_EXCL O_EXCL
815 #ifdef wxOpenOSFHandle
816 #define WX_HAVE_DELETE_ON_CLOSE
817 // On Windows create a file with the FILE_FLAGS_DELETE_ON_CLOSE flags.
819 static int wxOpenWithDeleteOnClose(const wxString
& filename
)
821 DWORD access
= GENERIC_READ
| GENERIC_WRITE
;
823 DWORD disposition
= OPEN_ALWAYS
;
825 DWORD attributes
= FILE_ATTRIBUTE_TEMPORARY
|
826 FILE_FLAG_DELETE_ON_CLOSE
;
828 HANDLE h
= ::CreateFile(filename
.fn_str(), access
, 0, NULL
,
829 disposition
, attributes
, NULL
);
831 return wxOpenOSFHandle(h
, wxO_BINARY
);
833 #endif // wxOpenOSFHandle
836 // Helper to open the file
838 static int wxTempOpen(const wxString
& path
, bool *deleteOnClose
)
840 #ifdef WX_HAVE_DELETE_ON_CLOSE
842 return wxOpenWithDeleteOnClose(path
);
845 *deleteOnClose
= false;
847 return wxOpen(path
, wxO_BINARY
| O_RDWR
| O_CREAT
| wxOPEN_EXCL
, 0600);
852 // Helper to open the file and attach it to the wxFFile
854 static bool wxTempOpen(wxFFile
*file
, const wxString
& path
, bool *deleteOnClose
)
857 *deleteOnClose
= false;
858 return file
->Open(path
, wxT("w+b"));
860 int fd
= wxTempOpen(path
, deleteOnClose
);
863 file
->Attach(wx_fdopen(fd
, "w+b"), path
);
864 return file
->IsOpened();
867 #endif // wxUSE_FFILE
871 #define WXFILEARGS(x, y) y
873 #define WXFILEARGS(x, y) x
875 #define WXFILEARGS(x, y) x, y
879 // Implementation of wxFileName::CreateTempFileName().
881 static wxString
wxCreateTempImpl(
882 const wxString
& prefix
,
883 WXFILEARGS(wxFile
*fileTemp
, wxFFile
*ffileTemp
),
884 bool *deleteOnClose
= NULL
)
886 #if wxUSE_FILE && wxUSE_FFILE
887 wxASSERT(fileTemp
== NULL
|| ffileTemp
== NULL
);
889 wxString path
, dir
, name
;
890 bool wantDeleteOnClose
= false;
894 // set the result to false initially
895 wantDeleteOnClose
= *deleteOnClose
;
896 *deleteOnClose
= false;
900 // easier if it alwasys points to something
901 deleteOnClose
= &wantDeleteOnClose
;
904 // use the directory specified by the prefix
905 wxFileName::SplitPath(prefix
, &dir
, &name
, NULL
/* extension */);
909 dir
= wxFileName::GetTempDir();
912 #if defined(__WXWINCE__)
913 path
= dir
+ wxT("\\") + name
;
915 while (wxFileName::FileExists(path
))
917 path
= dir
+ wxT("\\") + name
;
922 #elif defined(__WINDOWS__) && !defined(__WXMICROWIN__)
923 if (!::GetTempFileName(dir
.t_str(), name
.t_str(), 0,
924 wxStringBuffer(path
, MAX_PATH
+ 1)))
926 wxLogLastError(wxT("GetTempFileName"));
934 if ( !wxEndsWithPathSeparator(dir
) &&
935 (name
.empty() || !wxIsPathSeparator(name
[0u])) )
937 path
+= wxFILE_SEP_PATH
;
942 #if defined(HAVE_MKSTEMP)
943 // scratch space for mkstemp()
944 path
+= wxT("XXXXXX");
946 // we need to copy the path to the buffer in which mkstemp() can modify it
947 wxCharBuffer
buf(path
.fn_str());
949 // cast is safe because the string length doesn't change
950 int fdTemp
= mkstemp( (char*)(const char*) buf
);
953 // this might be not necessary as mkstemp() on most systems should have
954 // already done it but it doesn't hurt neither...
957 else // mkstemp() succeeded
959 path
= wxConvFile
.cMB2WX( (const char*) buf
);
962 // avoid leaking the fd
965 fileTemp
->Attach(fdTemp
);
974 ffileTemp
->Attach(wx_fdopen(fdTemp
, "r+b"), path
);
976 ffileTemp
->Open(path
, wxT("r+b"));
987 #else // !HAVE_MKSTEMP
991 path
+= wxT("XXXXXX");
993 wxCharBuffer buf
= wxConvFile
.cWX2MB( path
);
994 if ( !mktemp( (char*)(const char*) buf
) )
1000 path
= wxConvFile
.cMB2WX( (const char*) buf
);
1002 #else // !HAVE_MKTEMP (includes __DOS__)
1003 // generate the unique file name ourselves
1004 #if !defined(__DOS__) && (!defined(__MWERKS__) || defined(__DARWIN__) )
1005 path
<< (unsigned int)getpid();
1010 static const size_t numTries
= 1000;
1011 for ( size_t n
= 0; n
< numTries
; n
++ )
1013 // 3 hex digits is enough for numTries == 1000 < 4096
1014 pathTry
= path
+ wxString::Format(wxT("%.03x"), (unsigned int) n
);
1015 if ( !wxFileName::FileExists(pathTry
) )
1024 #endif // HAVE_MKTEMP/!HAVE_MKTEMP
1026 #endif // HAVE_MKSTEMP/!HAVE_MKSTEMP
1028 #endif // Windows/!Windows
1032 wxLogSysError(_("Failed to create a temporary file name"));
1038 // open the file - of course, there is a race condition here, this is
1039 // why we always prefer using mkstemp()...
1041 if ( fileTemp
&& !fileTemp
->IsOpened() )
1043 *deleteOnClose
= wantDeleteOnClose
;
1044 int fd
= wxTempOpen(path
, deleteOnClose
);
1046 fileTemp
->Attach(fd
);
1053 if ( ffileTemp
&& !ffileTemp
->IsOpened() )
1055 *deleteOnClose
= wantDeleteOnClose
;
1056 ok
= wxTempOpen(ffileTemp
, path
, deleteOnClose
);
1062 // FIXME: If !ok here should we loop and try again with another
1063 // file name? That is the standard recourse if open(O_EXCL)
1064 // fails, though of course it should be protected against
1065 // possible infinite looping too.
1067 wxLogError(_("Failed to open temporary file."));
1077 static bool wxCreateTempImpl(
1078 const wxString
& prefix
,
1079 WXFILEARGS(wxFile
*fileTemp
, wxFFile
*ffileTemp
),
1082 bool deleteOnClose
= true;
1084 *name
= wxCreateTempImpl(prefix
,
1085 WXFILEARGS(fileTemp
, ffileTemp
),
1088 bool ok
= !name
->empty();
1093 else if (ok
&& wxRemoveFile(*name
))
1101 static void wxAssignTempImpl(
1103 const wxString
& prefix
,
1104 WXFILEARGS(wxFile
*fileTemp
, wxFFile
*ffileTemp
))
1107 tempname
= wxCreateTempImpl(prefix
, WXFILEARGS(fileTemp
, ffileTemp
));
1109 if ( tempname
.empty() )
1111 // error, failed to get temp file name
1116 fn
->Assign(tempname
);
1121 void wxFileName::AssignTempFileName(const wxString
& prefix
)
1123 wxAssignTempImpl(this, prefix
, WXFILEARGS(NULL
, NULL
));
1127 wxString
wxFileName::CreateTempFileName(const wxString
& prefix
)
1129 return wxCreateTempImpl(prefix
, WXFILEARGS(NULL
, NULL
));
1132 #endif // wxUSE_FILE || wxUSE_FFILE
1137 wxString
wxCreateTempFileName(const wxString
& prefix
,
1139 bool *deleteOnClose
)
1141 return wxCreateTempImpl(prefix
, WXFILEARGS(fileTemp
, NULL
), deleteOnClose
);
1144 bool wxCreateTempFile(const wxString
& prefix
,
1148 return wxCreateTempImpl(prefix
, WXFILEARGS(fileTemp
, NULL
), name
);
1151 void wxFileName::AssignTempFileName(const wxString
& prefix
, wxFile
*fileTemp
)
1153 wxAssignTempImpl(this, prefix
, WXFILEARGS(fileTemp
, NULL
));
1158 wxFileName::CreateTempFileName(const wxString
& prefix
, wxFile
*fileTemp
)
1160 return wxCreateTempFileName(prefix
, fileTemp
);
1163 #endif // wxUSE_FILE
1168 wxString
wxCreateTempFileName(const wxString
& prefix
,
1170 bool *deleteOnClose
)
1172 return wxCreateTempImpl(prefix
, WXFILEARGS(NULL
, fileTemp
), deleteOnClose
);
1175 bool wxCreateTempFile(const wxString
& prefix
,
1179 return wxCreateTempImpl(prefix
, WXFILEARGS(NULL
, fileTemp
), name
);
1183 void wxFileName::AssignTempFileName(const wxString
& prefix
, wxFFile
*fileTemp
)
1185 wxAssignTempImpl(this, prefix
, WXFILEARGS(NULL
, fileTemp
));
1190 wxFileName::CreateTempFileName(const wxString
& prefix
, wxFFile
*fileTemp
)
1192 return wxCreateTempFileName(prefix
, fileTemp
);
1195 #endif // wxUSE_FFILE
1198 // ----------------------------------------------------------------------------
1199 // directory operations
1200 // ----------------------------------------------------------------------------
1202 // helper of GetTempDir(): check if the given directory exists and return it if
1203 // it does or an empty string otherwise
1207 wxString
CheckIfDirExists(const wxString
& dir
)
1209 return wxFileName::DirExists(dir
) ? dir
: wxString();
1212 } // anonymous namespace
1214 wxString
wxFileName::GetTempDir()
1216 // first try getting it from environment: this allows overriding the values
1217 // used by default if the user wants to create temporary files in another
1219 wxString dir
= CheckIfDirExists(wxGetenv("TMPDIR"));
1222 dir
= CheckIfDirExists(wxGetenv("TMP"));
1224 dir
= CheckIfDirExists(wxGetenv("TEMP"));
1227 // if no environment variables are set, use the system default
1230 #if defined(__WXWINCE__)
1231 dir
= CheckIfDirExists(wxT("\\temp"));
1232 #elif defined(__WINDOWS__) && !defined(__WXMICROWIN__)
1233 if ( !::GetTempPath(MAX_PATH
, wxStringBuffer(dir
, MAX_PATH
+ 1)) )
1235 wxLogLastError(wxT("GetTempPath"));
1237 #elif defined(__WXMAC__) && wxOSX_USE_CARBON
1238 dir
= wxMacFindFolderNoSeparator(short(kOnSystemDisk
), kTemporaryFolderType
, kCreateFolder
);
1239 #endif // systems with native way
1241 else // we got directory from an environment variable
1243 // remove any trailing path separators, we don't want to ever return
1244 // them from this function for consistency
1245 const size_t lastNonSep
= dir
.find_last_not_of(GetPathSeparators());
1246 if ( lastNonSep
== wxString::npos
)
1248 // the string consists entirely of separators, leave only one
1249 dir
= GetPathSeparator();
1253 dir
.erase(lastNonSep
+ 1);
1257 // fall back to hard coded value
1260 #ifdef __UNIX_LIKE__
1261 dir
= CheckIfDirExists("/tmp");
1263 #endif // __UNIX_LIKE__
1270 bool wxFileName::Mkdir( int perm
, int flags
) const
1272 return wxFileName::Mkdir(GetPath(), perm
, flags
);
1275 bool wxFileName::Mkdir( const wxString
& dir
, int perm
, int flags
)
1277 if ( flags
& wxPATH_MKDIR_FULL
)
1279 // split the path in components
1280 wxFileName filename
;
1281 filename
.AssignDir(dir
);
1284 if ( filename
.HasVolume())
1286 currPath
<< wxGetVolumeString(filename
.GetVolume(), wxPATH_NATIVE
);
1289 wxArrayString dirs
= filename
.GetDirs();
1290 size_t count
= dirs
.GetCount();
1291 for ( size_t i
= 0; i
< count
; i
++ )
1293 if ( i
> 0 || filename
.IsAbsolute() )
1294 currPath
+= wxFILE_SEP_PATH
;
1295 currPath
+= dirs
[i
];
1297 if (!DirExists(currPath
))
1299 if (!wxMkdir(currPath
, perm
))
1301 // no need to try creating further directories
1311 return ::wxMkdir( dir
, perm
);
1314 bool wxFileName::Rmdir(int flags
) const
1316 return wxFileName::Rmdir( GetPath(), flags
);
1319 bool wxFileName::Rmdir(const wxString
& dir
, int flags
)
1322 if ( flags
& wxPATH_RMDIR_RECURSIVE
)
1324 // SHFileOperation needs double null termination string
1325 // but without separator at the end of the path
1327 if ( path
.Last() == wxFILE_SEP_PATH
)
1331 SHFILEOPSTRUCT fileop
;
1332 wxZeroMemory(fileop
);
1333 fileop
.wFunc
= FO_DELETE
;
1334 #if defined(__CYGWIN__) && defined(wxUSE_UNICODE)
1335 fileop
.pFrom
= path
.wc_str();
1337 fileop
.pFrom
= path
.fn_str();
1339 fileop
.fFlags
= FOF_SILENT
| FOF_NOCONFIRMATION
;
1341 // FOF_NOERRORUI is not defined in WinCE
1342 fileop
.fFlags
|= FOF_NOERRORUI
;
1345 int ret
= SHFileOperation(&fileop
);
1348 // SHFileOperation may return non-Win32 error codes, so the error
1349 // message can be incorrect
1350 wxLogApiError(wxT("SHFileOperation"), ret
);
1356 else if ( flags
& wxPATH_RMDIR_FULL
)
1358 if ( flags
!= 0 ) // wxPATH_RMDIR_FULL or wxPATH_RMDIR_RECURSIVE
1359 #endif // !__WXMSW__
1362 if ( path
.Last() != wxFILE_SEP_PATH
)
1363 path
+= wxFILE_SEP_PATH
;
1367 if ( !d
.IsOpened() )
1372 // first delete all subdirectories
1373 bool cont
= d
.GetFirst(&filename
, "", wxDIR_DIRS
| wxDIR_HIDDEN
);
1376 wxFileName::Rmdir(path
+ filename
, flags
);
1377 cont
= d
.GetNext(&filename
);
1381 if ( flags
& wxPATH_RMDIR_RECURSIVE
)
1383 // delete all files too
1384 cont
= d
.GetFirst(&filename
, "", wxDIR_FILES
| wxDIR_HIDDEN
);
1387 ::wxRemoveFile(path
+ filename
);
1388 cont
= d
.GetNext(&filename
);
1391 #endif // !__WXMSW__
1394 return ::wxRmdir(dir
);
1397 // ----------------------------------------------------------------------------
1398 // path normalization
1399 // ----------------------------------------------------------------------------
1401 bool wxFileName::Normalize(int flags
,
1402 const wxString
& cwd
,
1403 wxPathFormat format
)
1405 // deal with env vars renaming first as this may seriously change the path
1406 if ( flags
& wxPATH_NORM_ENV_VARS
)
1408 wxString pathOrig
= GetFullPath(format
);
1409 wxString path
= wxExpandEnvVars(pathOrig
);
1410 if ( path
!= pathOrig
)
1416 // the existing path components
1417 wxArrayString dirs
= GetDirs();
1419 // the path to prepend in front to make the path absolute
1422 format
= GetFormat(format
);
1424 // set up the directory to use for making the path absolute later
1425 if ( (flags
& wxPATH_NORM_ABSOLUTE
) && !IsAbsolute(format
) )
1429 curDir
.AssignCwd(GetVolume());
1431 else // cwd provided
1433 curDir
.AssignDir(cwd
);
1437 // handle ~ stuff under Unix only
1438 if ( (format
== wxPATH_UNIX
) && (flags
& wxPATH_NORM_TILDE
) && m_relative
)
1440 if ( !dirs
.IsEmpty() )
1442 wxString dir
= dirs
[0u];
1443 if ( !dir
.empty() && dir
[0u] == wxT('~') )
1445 // to make the path absolute use the home directory
1446 curDir
.AssignDir(wxGetUserHome(dir
.c_str() + 1));
1452 // transform relative path into abs one
1453 if ( curDir
.IsOk() )
1455 // this path may be relative because it doesn't have the volume name
1456 // and still have m_relative=true; in this case we shouldn't modify
1457 // our directory components but just set the current volume
1458 if ( !HasVolume() && curDir
.HasVolume() )
1460 SetVolume(curDir
.GetVolume());
1464 // yes, it was the case - we don't need curDir then
1469 // finally, prepend curDir to the dirs array
1470 wxArrayString dirsNew
= curDir
.GetDirs();
1471 WX_PREPEND_ARRAY(dirs
, dirsNew
);
1473 // if we used e.g. tilde expansion previously and wxGetUserHome didn't
1474 // return for some reason an absolute path, then curDir maybe not be absolute!
1475 if ( !curDir
.m_relative
)
1477 // we have prepended an absolute path and thus we are now an absolute
1481 // else if (flags & wxPATH_NORM_ABSOLUTE):
1482 // should we warn the user that we didn't manage to make the path absolute?
1485 // now deal with ".", ".." and the rest
1487 size_t count
= dirs
.GetCount();
1488 for ( size_t n
= 0; n
< count
; n
++ )
1490 wxString dir
= dirs
[n
];
1492 if ( flags
& wxPATH_NORM_DOTS
)
1494 if ( dir
== wxT(".") )
1500 if ( dir
== wxT("..") )
1502 if ( m_dirs
.empty() )
1504 // We have more ".." than directory components so far.
1505 // Don't treat this as an error as the path could have been
1506 // entered by user so try to handle it reasonably: if the
1507 // path is absolute, just ignore the extra ".." because
1508 // "/.." is the same as "/". Otherwise, i.e. for relative
1509 // paths, keep ".." unchanged because removing it would
1510 // modify the file a relative path refers to.
1515 else // Normal case, go one step up.
1526 #if defined(__WIN32__) && !defined(__WXWINCE__) && wxUSE_OLE
1527 if ( (flags
& wxPATH_NORM_SHORTCUT
) )
1530 if (GetShortcutTarget(GetFullPath(format
), filename
))
1538 #if defined(__WIN32__)
1539 if ( (flags
& wxPATH_NORM_LONG
) && (format
== wxPATH_DOS
) )
1541 Assign(GetLongPath());
1545 // Change case (this should be kept at the end of the function, to ensure
1546 // that the path doesn't change any more after we normalize its case)
1547 if ( (flags
& wxPATH_NORM_CASE
) && !IsCaseSensitive(format
) )
1549 m_volume
.MakeLower();
1553 // directory entries must be made lower case as well
1554 count
= m_dirs
.GetCount();
1555 for ( size_t i
= 0; i
< count
; i
++ )
1557 m_dirs
[i
].MakeLower();
1565 bool wxFileName::ReplaceEnvVariable(const wxString
& envname
,
1566 const wxString
& replacementFmtString
,
1567 wxPathFormat format
)
1569 // look into stringForm for the contents of the given environment variable
1571 if (envname
.empty() ||
1572 !wxGetEnv(envname
, &val
))
1577 wxString stringForm
= GetPath(wxPATH_GET_VOLUME
, format
);
1578 // do not touch the file name and the extension
1580 wxString replacement
= wxString::Format(replacementFmtString
, envname
);
1581 stringForm
.Replace(val
, replacement
);
1583 // Now assign ourselves the modified path:
1584 Assign(stringForm
, GetFullName(), format
);
1590 bool wxFileName::ReplaceHomeDir(wxPathFormat format
)
1592 wxString homedir
= wxGetHomeDir();
1593 if (homedir
.empty())
1596 wxString stringForm
= GetPath(wxPATH_GET_VOLUME
, format
);
1597 // do not touch the file name and the extension
1599 stringForm
.Replace(homedir
, "~");
1601 // Now assign ourselves the modified path:
1602 Assign(stringForm
, GetFullName(), format
);
1607 // ----------------------------------------------------------------------------
1608 // get the shortcut target
1609 // ----------------------------------------------------------------------------
1611 // WinCE (3) doesn't have CLSID_ShellLink, IID_IShellLink definitions.
1612 // The .lnk file is a plain text file so it should be easy to
1613 // make it work. Hint from Google Groups:
1614 // "If you open up a lnk file, you'll see a
1615 // number, followed by a pound sign (#), followed by more text. The
1616 // number is the number of characters that follows the pound sign. The
1617 // characters after the pound sign are the command line (which _can_
1618 // include arguments) to be executed. Any path (e.g. \windows\program
1619 // files\myapp.exe) that includes spaces needs to be enclosed in
1620 // quotation marks."
1622 #if defined(__WIN32__) && !defined(__WXWINCE__) && wxUSE_OLE
1623 // The following lines are necessary under WinCE
1624 // #include "wx/msw/private.h"
1625 // #include <ole2.h>
1627 #if defined(__WXWINCE__)
1628 #include <shlguid.h>
1631 bool wxFileName::GetShortcutTarget(const wxString
& shortcutPath
,
1632 wxString
& targetFilename
,
1633 wxString
* arguments
) const
1635 wxString path
, file
, ext
;
1636 wxFileName::SplitPath(shortcutPath
, & path
, & file
, & ext
);
1640 bool success
= false;
1642 // Assume it's not a shortcut if it doesn't end with lnk
1643 if (ext
.CmpNoCase(wxT("lnk"))!=0)
1646 // create a ShellLink object
1647 hres
= CoCreateInstance(CLSID_ShellLink
, NULL
, CLSCTX_INPROC_SERVER
,
1648 IID_IShellLink
, (LPVOID
*) &psl
);
1650 if (SUCCEEDED(hres
))
1653 hres
= psl
->QueryInterface( IID_IPersistFile
, (LPVOID
*) &ppf
);
1654 if (SUCCEEDED(hres
))
1656 WCHAR wsz
[MAX_PATH
];
1658 MultiByteToWideChar(CP_ACP
, MB_PRECOMPOSED
, shortcutPath
.mb_str(), -1, wsz
,
1661 hres
= ppf
->Load(wsz
, 0);
1664 if (SUCCEEDED(hres
))
1667 // Wrong prototype in early versions
1668 #if defined(__MINGW32__) && !wxCHECK_W32API_VERSION(2, 2)
1669 psl
->GetPath((CHAR
*) buf
, 2048, NULL
, SLGP_UNCPRIORITY
);
1671 psl
->GetPath(buf
, 2048, NULL
, SLGP_UNCPRIORITY
);
1673 targetFilename
= wxString(buf
);
1674 success
= (shortcutPath
!= targetFilename
);
1676 psl
->GetArguments(buf
, 2048);
1678 if (!args
.empty() && arguments
)
1690 #endif // __WIN32__ && !__WXWINCE__
1693 // ----------------------------------------------------------------------------
1694 // absolute/relative paths
1695 // ----------------------------------------------------------------------------
1697 bool wxFileName::IsAbsolute(wxPathFormat format
) const
1699 // unix paths beginning with ~ are reported as being absolute
1700 if ( format
== wxPATH_UNIX
)
1702 if ( !m_dirs
.IsEmpty() )
1704 wxString dir
= m_dirs
[0u];
1706 if (!dir
.empty() && dir
[0u] == wxT('~'))
1711 // if our path doesn't start with a path separator, it's not an absolute
1716 if ( !GetVolumeSeparator(format
).empty() )
1718 // this format has volumes and an absolute path must have one, it's not
1719 // enough to have the full path to be an absolute file under Windows
1720 if ( GetVolume().empty() )
1727 bool wxFileName::MakeRelativeTo(const wxString
& pathBase
, wxPathFormat format
)
1729 wxFileName fnBase
= wxFileName::DirName(pathBase
, format
);
1731 // get cwd only once - small time saving
1732 wxString cwd
= wxGetCwd();
1733 Normalize(wxPATH_NORM_ALL
& ~wxPATH_NORM_CASE
, cwd
, format
);
1734 fnBase
.Normalize(wxPATH_NORM_ALL
& ~wxPATH_NORM_CASE
, cwd
, format
);
1736 bool withCase
= IsCaseSensitive(format
);
1738 // we can't do anything if the files live on different volumes
1739 if ( !GetVolume().IsSameAs(fnBase
.GetVolume(), withCase
) )
1745 // same drive, so we don't need our volume
1748 // remove common directories starting at the top
1749 while ( !m_dirs
.IsEmpty() && !fnBase
.m_dirs
.IsEmpty() &&
1750 m_dirs
[0u].IsSameAs(fnBase
.m_dirs
[0u], withCase
) )
1753 fnBase
.m_dirs
.RemoveAt(0);
1756 // add as many ".." as needed
1757 size_t count
= fnBase
.m_dirs
.GetCount();
1758 for ( size_t i
= 0; i
< count
; i
++ )
1760 m_dirs
.Insert(wxT(".."), 0u);
1763 if ( format
== wxPATH_UNIX
|| format
== wxPATH_DOS
)
1765 // a directory made relative with respect to itself is '.' under Unix
1766 // and DOS, by definition (but we don't have to insert "./" for the
1768 if ( m_dirs
.IsEmpty() && IsDir() )
1770 m_dirs
.Add(wxT('.'));
1780 // ----------------------------------------------------------------------------
1781 // filename kind tests
1782 // ----------------------------------------------------------------------------
1784 bool wxFileName::SameAs(const wxFileName
& filepath
, wxPathFormat format
) const
1786 wxFileName fn1
= *this,
1789 // get cwd only once - small time saving
1790 wxString cwd
= wxGetCwd();
1791 fn1
.Normalize(wxPATH_NORM_ALL
| wxPATH_NORM_CASE
, cwd
, format
);
1792 fn2
.Normalize(wxPATH_NORM_ALL
| wxPATH_NORM_CASE
, cwd
, format
);
1794 if ( fn1
.GetFullPath() == fn2
.GetFullPath() )
1797 // TODO: compare inodes for Unix, this works even when filenames are
1798 // different but files are the same (symlinks) (VZ)
1804 bool wxFileName::IsCaseSensitive( wxPathFormat format
)
1806 // only Unix filenames are truely case-sensitive
1807 return GetFormat(format
) == wxPATH_UNIX
;
1811 wxString
wxFileName::GetForbiddenChars(wxPathFormat format
)
1813 // Inits to forbidden characters that are common to (almost) all platforms.
1814 wxString strForbiddenChars
= wxT("*?");
1816 // If asserts, wxPathFormat has been changed. In case of a new path format
1817 // addition, the following code might have to be updated.
1818 wxCOMPILE_TIME_ASSERT(wxPATH_MAX
== 5, wxPathFormatChanged
);
1819 switch ( GetFormat(format
) )
1822 wxFAIL_MSG( wxT("Unknown path format") );
1823 // !! Fall through !!
1829 // On a Mac even names with * and ? are allowed (Tested with OS
1830 // 9.2.1 and OS X 10.2.5)
1831 strForbiddenChars
= wxEmptyString
;
1835 strForbiddenChars
+= wxT("\\/:\"<>|");
1842 return strForbiddenChars
;
1846 wxString
wxFileName::GetVolumeSeparator(wxPathFormat
WXUNUSED_IN_WINCE(format
))
1849 return wxEmptyString
;
1853 if ( (GetFormat(format
) == wxPATH_DOS
) ||
1854 (GetFormat(format
) == wxPATH_VMS
) )
1856 sepVol
= wxFILE_SEP_DSK
;
1865 wxString
wxFileName::GetPathSeparators(wxPathFormat format
)
1868 switch ( GetFormat(format
) )
1871 // accept both as native APIs do but put the native one first as
1872 // this is the one we use in GetFullPath()
1873 seps
<< wxFILE_SEP_PATH_DOS
<< wxFILE_SEP_PATH_UNIX
;
1877 wxFAIL_MSG( wxT("Unknown wxPATH_XXX style") );
1881 seps
= wxFILE_SEP_PATH_UNIX
;
1885 seps
= wxFILE_SEP_PATH_MAC
;
1889 seps
= wxFILE_SEP_PATH_VMS
;
1897 wxString
wxFileName::GetPathTerminators(wxPathFormat format
)
1899 format
= GetFormat(format
);
1901 // under VMS the end of the path is ']', not the path separator used to
1902 // separate the components
1903 return format
== wxPATH_VMS
? wxString(wxT(']')) : GetPathSeparators(format
);
1907 bool wxFileName::IsPathSeparator(wxChar ch
, wxPathFormat format
)
1909 // wxString::Find() doesn't work as expected with NUL - it will always find
1910 // it, so test for it separately
1911 return ch
!= wxT('\0') && GetPathSeparators(format
).Find(ch
) != wxNOT_FOUND
;
1916 wxFileName::IsMSWUniqueVolumeNamePath(const wxString
& path
, wxPathFormat format
)
1918 // return true if the format used is the DOS/Windows one and the string begins
1919 // with a Windows unique volume name ("\\?\Volume{guid}\")
1920 return format
== wxPATH_DOS
&&
1921 path
.length() >= wxMSWUniqueVolumePrefixLength
&&
1922 path
.StartsWith(wxS("\\\\?\\Volume{")) &&
1923 path
[wxMSWUniqueVolumePrefixLength
- 1] == wxFILE_SEP_PATH_DOS
;
1926 // ----------------------------------------------------------------------------
1927 // path components manipulation
1928 // ----------------------------------------------------------------------------
1930 /* static */ bool wxFileName::IsValidDirComponent(const wxString
& dir
)
1934 wxFAIL_MSG( wxT("empty directory passed to wxFileName::InsertDir()") );
1939 const size_t len
= dir
.length();
1940 for ( size_t n
= 0; n
< len
; n
++ )
1942 if ( dir
[n
] == GetVolumeSeparator() || IsPathSeparator(dir
[n
]) )
1944 wxFAIL_MSG( wxT("invalid directory component in wxFileName") );
1953 void wxFileName::AppendDir( const wxString
& dir
)
1955 if ( IsValidDirComponent(dir
) )
1959 void wxFileName::PrependDir( const wxString
& dir
)
1964 void wxFileName::InsertDir(size_t before
, const wxString
& dir
)
1966 if ( IsValidDirComponent(dir
) )
1967 m_dirs
.Insert(dir
, before
);
1970 void wxFileName::RemoveDir(size_t pos
)
1972 m_dirs
.RemoveAt(pos
);
1975 // ----------------------------------------------------------------------------
1977 // ----------------------------------------------------------------------------
1979 void wxFileName::SetFullName(const wxString
& fullname
)
1981 SplitPath(fullname
, NULL
/* no volume */, NULL
/* no path */,
1982 &m_name
, &m_ext
, &m_hasExt
);
1985 wxString
wxFileName::GetFullName() const
1987 wxString fullname
= m_name
;
1990 fullname
<< wxFILE_SEP_EXT
<< m_ext
;
1996 wxString
wxFileName::GetPath( int flags
, wxPathFormat format
) const
1998 format
= GetFormat( format
);
2002 // return the volume with the path as well if requested
2003 if ( flags
& wxPATH_GET_VOLUME
)
2005 fullpath
+= wxGetVolumeString(GetVolume(), format
);
2008 // the leading character
2013 fullpath
+= wxFILE_SEP_PATH_MAC
;
2018 fullpath
+= wxFILE_SEP_PATH_DOS
;
2022 wxFAIL_MSG( wxT("Unknown path format") );
2028 fullpath
+= wxFILE_SEP_PATH_UNIX
;
2033 // no leading character here but use this place to unset
2034 // wxPATH_GET_SEPARATOR flag: under VMS it doesn't make sense
2035 // as, if I understand correctly, there should never be a dot
2036 // before the closing bracket
2037 flags
&= ~wxPATH_GET_SEPARATOR
;
2040 if ( m_dirs
.empty() )
2042 // there is nothing more
2046 // then concatenate all the path components using the path separator
2047 if ( format
== wxPATH_VMS
)
2049 fullpath
+= wxT('[');
2052 const size_t dirCount
= m_dirs
.GetCount();
2053 for ( size_t i
= 0; i
< dirCount
; i
++ )
2058 if ( m_dirs
[i
] == wxT(".") )
2060 // skip appending ':', this shouldn't be done in this
2061 // case as "::" is interpreted as ".." under Unix
2065 // convert back from ".." to nothing
2066 if ( !m_dirs
[i
].IsSameAs(wxT("..")) )
2067 fullpath
+= m_dirs
[i
];
2071 wxFAIL_MSG( wxT("Unexpected path format") );
2072 // still fall through
2076 fullpath
+= m_dirs
[i
];
2080 // TODO: What to do with ".." under VMS
2082 // convert back from ".." to nothing
2083 if ( !m_dirs
[i
].IsSameAs(wxT("..")) )
2084 fullpath
+= m_dirs
[i
];
2088 if ( (flags
& wxPATH_GET_SEPARATOR
) || (i
!= dirCount
- 1) )
2089 fullpath
+= GetPathSeparator(format
);
2092 if ( format
== wxPATH_VMS
)
2094 fullpath
+= wxT(']');
2100 wxString
wxFileName::GetFullPath( wxPathFormat format
) const
2102 // we already have a function to get the path
2103 wxString fullpath
= GetPath(wxPATH_GET_VOLUME
| wxPATH_GET_SEPARATOR
,
2106 // now just add the file name and extension to it
2107 fullpath
+= GetFullName();
2112 // Return the short form of the path (returns identity on non-Windows platforms)
2113 wxString
wxFileName::GetShortPath() const
2115 wxString
path(GetFullPath());
2117 #if defined(__WXMSW__) && defined(__WIN32__) && !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
2118 DWORD sz
= ::GetShortPathName(path
.t_str(), NULL
, 0);
2122 if ( ::GetShortPathName
2125 wxStringBuffer(pathOut
, sz
),
2137 // Return the long form of the path (returns identity on non-Windows platforms)
2138 wxString
wxFileName::GetLongPath() const
2141 path
= GetFullPath();
2143 #if defined(__WIN32__) && !defined(__WXWINCE__) && !defined(__WXMICROWIN__)
2145 #if wxUSE_DYNLIB_CLASS
2146 typedef DWORD (WINAPI
*GET_LONG_PATH_NAME
)(const wxChar
*, wxChar
*, DWORD
);
2148 // this is MT-safe as in the worst case we're going to resolve the function
2149 // twice -- but as the result is the same in both threads, it's ok
2150 static GET_LONG_PATH_NAME s_pfnGetLongPathName
= NULL
;
2151 if ( !s_pfnGetLongPathName
)
2153 static bool s_triedToLoad
= false;
2155 if ( !s_triedToLoad
)
2157 s_triedToLoad
= true;
2159 wxDynamicLibrary
dllKernel(wxT("kernel32"));
2161 const wxChar
* GetLongPathName
= wxT("GetLongPathName")
2166 #endif // Unicode/ANSI
2168 if ( dllKernel
.HasSymbol(GetLongPathName
) )
2170 s_pfnGetLongPathName
= (GET_LONG_PATH_NAME
)
2171 dllKernel
.GetSymbol(GetLongPathName
);
2174 // note that kernel32.dll can be unloaded, it stays in memory
2175 // anyhow as all Win32 programs link to it and so it's safe to call
2176 // GetLongPathName() even after unloading it
2180 if ( s_pfnGetLongPathName
)
2182 DWORD dwSize
= (*s_pfnGetLongPathName
)(path
.t_str(), NULL
, 0);
2185 if ( (*s_pfnGetLongPathName
)
2188 wxStringBuffer(pathOut
, dwSize
),
2196 #endif // wxUSE_DYNLIB_CLASS
2198 // The OS didn't support GetLongPathName, or some other error.
2199 // We need to call FindFirstFile on each component in turn.
2201 WIN32_FIND_DATA findFileData
;
2205 pathOut
= GetVolume() +
2206 GetVolumeSeparator(wxPATH_DOS
) +
2207 GetPathSeparator(wxPATH_DOS
);
2209 pathOut
= wxEmptyString
;
2211 wxArrayString dirs
= GetDirs();
2212 dirs
.Add(GetFullName());
2216 size_t count
= dirs
.GetCount();
2217 for ( size_t i
= 0; i
< count
; i
++ )
2219 const wxString
& dir
= dirs
[i
];
2221 // We're using pathOut to collect the long-name path, but using a
2222 // temporary for appending the last path component which may be
2224 tmpPath
= pathOut
+ dir
;
2226 // We must not process "." or ".." here as they would be (unexpectedly)
2227 // replaced by the corresponding directory names so just leave them
2230 // And we can't pass a drive and root dir to FindFirstFile (VZ: why?)
2231 if ( tmpPath
.empty() || dir
== '.' || dir
== ".." ||
2232 tmpPath
.Last() == GetVolumeSeparator(wxPATH_DOS
) )
2234 tmpPath
+= wxFILE_SEP_PATH
;
2239 hFind
= ::FindFirstFile(tmpPath
.t_str(), &findFileData
);
2240 if (hFind
== INVALID_HANDLE_VALUE
)
2242 // Error: most likely reason is that path doesn't exist, so
2243 // append any unprocessed parts and return
2244 for ( i
+= 1; i
< count
; i
++ )
2245 tmpPath
+= wxFILE_SEP_PATH
+ dirs
[i
];
2250 pathOut
+= findFileData
.cFileName
;
2251 if ( (i
< (count
-1)) )
2252 pathOut
+= wxFILE_SEP_PATH
;
2258 #endif // Win32/!Win32
2263 wxPathFormat
wxFileName::GetFormat( wxPathFormat format
)
2265 if (format
== wxPATH_NATIVE
)
2267 #if defined(__WXMSW__) || defined(__OS2__) || defined(__DOS__)
2268 format
= wxPATH_DOS
;
2269 #elif defined(__VMS)
2270 format
= wxPATH_VMS
;
2272 format
= wxPATH_UNIX
;
2278 #ifdef wxHAS_FILESYSTEM_VOLUMES
2281 wxString
wxFileName::GetVolumeString(char drive
, int flags
)
2283 wxASSERT_MSG( !(flags
& ~wxPATH_GET_SEPARATOR
), "invalid flag specified" );
2285 wxString
vol(drive
);
2286 vol
+= wxFILE_SEP_DSK
;
2287 if ( flags
& wxPATH_GET_SEPARATOR
)
2288 vol
+= wxFILE_SEP_PATH
;
2293 #endif // wxHAS_FILESYSTEM_VOLUMES
2295 // ----------------------------------------------------------------------------
2296 // path splitting function
2297 // ----------------------------------------------------------------------------
2301 wxFileName::SplitVolume(const wxString
& fullpathWithVolume
,
2302 wxString
*pstrVolume
,
2304 wxPathFormat format
)
2306 format
= GetFormat(format
);
2308 wxString fullpath
= fullpathWithVolume
;
2310 if ( IsMSWUniqueVolumeNamePath(fullpath
, format
) )
2312 // special Windows unique volume names hack: transform
2313 // \\?\Volume{guid}\path into Volume{guid}:path
2314 // note: this check must be done before the check for UNC path
2316 // we know the last backslash from the unique volume name is located
2317 // there from IsMSWUniqueVolumeNamePath
2318 fullpath
[wxMSWUniqueVolumePrefixLength
- 1] = wxFILE_SEP_DSK
;
2320 // paths starting with a unique volume name should always be absolute
2321 fullpath
.insert(wxMSWUniqueVolumePrefixLength
, 1, wxFILE_SEP_PATH_DOS
);
2323 // remove the leading "\\?\" part
2324 fullpath
.erase(0, 4);
2326 else if ( IsUNCPath(fullpath
, format
) )
2328 // special Windows UNC paths hack: transform \\share\path into share:path
2330 fullpath
.erase(0, 2);
2332 size_t posFirstSlash
=
2333 fullpath
.find_first_of(GetPathTerminators(format
));
2334 if ( posFirstSlash
!= wxString::npos
)
2336 fullpath
[posFirstSlash
] = wxFILE_SEP_DSK
;
2338 // UNC paths are always absolute, right? (FIXME)
2339 fullpath
.insert(posFirstSlash
+ 1, 1, wxFILE_SEP_PATH_DOS
);
2343 // We separate the volume here
2344 if ( format
== wxPATH_DOS
|| format
== wxPATH_VMS
)
2346 wxString sepVol
= GetVolumeSeparator(format
);
2348 // we have to exclude the case of a colon in the very beginning of the
2349 // string as it can't be a volume separator (nor can this be a valid
2350 // DOS file name at all but we'll leave dealing with this to our caller)
2351 size_t posFirstColon
= fullpath
.find_first_of(sepVol
);
2352 if ( posFirstColon
&& posFirstColon
!= wxString::npos
)
2356 *pstrVolume
= fullpath
.Left(posFirstColon
);
2359 // remove the volume name and the separator from the full path
2360 fullpath
.erase(0, posFirstColon
+ sepVol
.length());
2365 *pstrPath
= fullpath
;
2369 void wxFileName::SplitPath(const wxString
& fullpathWithVolume
,
2370 wxString
*pstrVolume
,
2375 wxPathFormat format
)
2377 format
= GetFormat(format
);
2380 SplitVolume(fullpathWithVolume
, pstrVolume
, &fullpath
, format
);
2382 // find the positions of the last dot and last path separator in the path
2383 size_t posLastDot
= fullpath
.find_last_of(wxFILE_SEP_EXT
);
2384 size_t posLastSlash
= fullpath
.find_last_of(GetPathTerminators(format
));
2386 // check whether this dot occurs at the very beginning of a path component
2387 if ( (posLastDot
!= wxString::npos
) &&
2389 IsPathSeparator(fullpath
[posLastDot
- 1]) ||
2390 (format
== wxPATH_VMS
&& fullpath
[posLastDot
- 1] == wxT(']'))) )
2392 // dot may be (and commonly -- at least under Unix -- is) the first
2393 // character of the filename, don't treat the entire filename as
2394 // extension in this case
2395 posLastDot
= wxString::npos
;
2398 // if we do have a dot and a slash, check that the dot is in the name part
2399 if ( (posLastDot
!= wxString::npos
) &&
2400 (posLastSlash
!= wxString::npos
) &&
2401 (posLastDot
< posLastSlash
) )
2403 // the dot is part of the path, not the start of the extension
2404 posLastDot
= wxString::npos
;
2407 // now fill in the variables provided by user
2410 if ( posLastSlash
== wxString::npos
)
2417 // take everything up to the path separator but take care to make
2418 // the path equal to something like '/', not empty, for the files
2419 // immediately under root directory
2420 size_t len
= posLastSlash
;
2422 // this rule does not apply to mac since we do not start with colons (sep)
2423 // except for relative paths
2424 if ( !len
&& format
!= wxPATH_MAC
)
2427 *pstrPath
= fullpath
.Left(len
);
2429 // special VMS hack: remove the initial bracket
2430 if ( format
== wxPATH_VMS
)
2432 if ( (*pstrPath
)[0u] == wxT('[') )
2433 pstrPath
->erase(0, 1);
2440 // take all characters starting from the one after the last slash and
2441 // up to, but excluding, the last dot
2442 size_t nStart
= posLastSlash
== wxString::npos
? 0 : posLastSlash
+ 1;
2444 if ( posLastDot
== wxString::npos
)
2446 // take all until the end
2447 count
= wxString::npos
;
2449 else if ( posLastSlash
== wxString::npos
)
2453 else // have both dot and slash
2455 count
= posLastDot
- posLastSlash
- 1;
2458 *pstrName
= fullpath
.Mid(nStart
, count
);
2461 // finally deal with the extension here: we have an added complication that
2462 // extension may be empty (but present) as in "foo." where trailing dot
2463 // indicates the empty extension at the end -- and hence we must remember
2464 // that we have it independently of pstrExt
2465 if ( posLastDot
== wxString::npos
)
2475 // take everything after the dot
2477 *pstrExt
= fullpath
.Mid(posLastDot
+ 1);
2484 void wxFileName::SplitPath(const wxString
& fullpath
,
2488 wxPathFormat format
)
2491 SplitPath(fullpath
, &volume
, path
, name
, ext
, format
);
2495 path
->Prepend(wxGetVolumeString(volume
, format
));
2500 wxString
wxFileName::StripExtension(const wxString
& fullpath
)
2502 wxFileName
fn(fullpath
);
2504 return fn
.GetFullPath();
2507 // ----------------------------------------------------------------------------
2509 // ----------------------------------------------------------------------------
2513 bool wxFileName::SetTimes(const wxDateTime
*dtAccess
,
2514 const wxDateTime
*dtMod
,
2515 const wxDateTime
*dtCreate
) const
2517 #if defined(__WIN32__)
2518 FILETIME ftAccess
, ftCreate
, ftWrite
;
2521 ConvertWxToFileTime(&ftCreate
, *dtCreate
);
2523 ConvertWxToFileTime(&ftAccess
, *dtAccess
);
2525 ConvertWxToFileTime(&ftWrite
, *dtMod
);
2531 if ( wxGetOsVersion() == wxOS_WINDOWS_9X
)
2533 wxLogError(_("Setting directory access times is not supported "
2534 "under this OS version"));
2539 flags
= FILE_FLAG_BACKUP_SEMANTICS
;
2543 path
= GetFullPath();
2547 wxFileHandle
fh(path
, wxFileHandle::WriteAttr
, flags
);
2550 if ( ::SetFileTime(fh
,
2551 dtCreate
? &ftCreate
: NULL
,
2552 dtAccess
? &ftAccess
: NULL
,
2553 dtMod
? &ftWrite
: NULL
) )
2558 #elif defined(__UNIX_LIKE__) || (defined(__DOS__) && defined(__WATCOMC__))
2559 wxUnusedVar(dtCreate
);
2561 if ( !dtAccess
&& !dtMod
)
2563 // can't modify the creation time anyhow, don't try
2567 // if dtAccess or dtMod is not specified, use the other one (which must be
2568 // non NULL because of the test above) for both times
2570 utm
.actime
= dtAccess
? dtAccess
->GetTicks() : dtMod
->GetTicks();
2571 utm
.modtime
= dtMod
? dtMod
->GetTicks() : dtAccess
->GetTicks();
2572 if ( utime(GetFullPath().fn_str(), &utm
) == 0 )
2576 #else // other platform
2577 wxUnusedVar(dtAccess
);
2579 wxUnusedVar(dtCreate
);
2582 wxLogSysError(_("Failed to modify file times for '%s'"),
2583 GetFullPath().c_str());
2588 bool wxFileName::Touch() const
2590 #if defined(__UNIX_LIKE__)
2591 // under Unix touching file is simple: just pass NULL to utime()
2592 if ( utime(GetFullPath().fn_str(), NULL
) == 0 )
2597 wxLogSysError(_("Failed to touch the file '%s'"), GetFullPath().c_str());
2600 #else // other platform
2601 wxDateTime dtNow
= wxDateTime::Now();
2603 return SetTimes(&dtNow
, &dtNow
, NULL
/* don't change create time */);
2607 bool wxFileName::GetTimes(wxDateTime
*dtAccess
,
2609 wxDateTime
*dtCreate
) const
2611 #if defined(__WIN32__)
2612 // we must use different methods for the files and directories under
2613 // Windows as CreateFile(GENERIC_READ) doesn't work for the directories and
2614 // CreateFile(FILE_FLAG_BACKUP_SEMANTICS) works -- but only under NT and
2617 FILETIME ftAccess
, ftCreate
, ftWrite
;
2620 // implemented in msw/dir.cpp
2621 extern bool wxGetDirectoryTimes(const wxString
& dirname
,
2622 FILETIME
*, FILETIME
*, FILETIME
*);
2624 // we should pass the path without the trailing separator to
2625 // wxGetDirectoryTimes()
2626 ok
= wxGetDirectoryTimes(GetPath(wxPATH_GET_VOLUME
),
2627 &ftAccess
, &ftCreate
, &ftWrite
);
2631 wxFileHandle
fh(GetFullPath(), wxFileHandle::ReadAttr
);
2634 ok
= ::GetFileTime(fh
,
2635 dtCreate
? &ftCreate
: NULL
,
2636 dtAccess
? &ftAccess
: NULL
,
2637 dtMod
? &ftWrite
: NULL
) != 0;
2648 ConvertFileTimeToWx(dtCreate
, ftCreate
);
2650 ConvertFileTimeToWx(dtAccess
, ftAccess
);
2652 ConvertFileTimeToWx(dtMod
, ftWrite
);
2656 #elif defined(__UNIX_LIKE__) || defined(__WXMAC__) || defined(__OS2__) || (defined(__DOS__) && defined(__WATCOMC__))
2657 // no need to test for IsDir() here
2659 if ( wxStat( GetFullPath(), &stBuf
) == 0 )
2662 dtAccess
->Set(stBuf
.st_atime
);
2664 dtMod
->Set(stBuf
.st_mtime
);
2666 dtCreate
->Set(stBuf
.st_ctime
);
2670 #else // other platform
2671 wxUnusedVar(dtAccess
);
2673 wxUnusedVar(dtCreate
);
2676 wxLogSysError(_("Failed to retrieve file times for '%s'"),
2677 GetFullPath().c_str());
2682 #endif // wxUSE_DATETIME
2685 // ----------------------------------------------------------------------------
2686 // file size functions
2687 // ----------------------------------------------------------------------------
2692 wxULongLong
wxFileName::GetSize(const wxString
&filename
)
2694 if (!wxFileExists(filename
))
2695 return wxInvalidSize
;
2697 #if defined(__WIN32__)
2698 wxFileHandle
f(filename
, wxFileHandle::ReadAttr
);
2700 return wxInvalidSize
;
2702 DWORD lpFileSizeHigh
;
2703 DWORD ret
= GetFileSize(f
, &lpFileSizeHigh
);
2704 if ( ret
== INVALID_FILE_SIZE
&& ::GetLastError() != NO_ERROR
)
2705 return wxInvalidSize
;
2707 return wxULongLong(lpFileSizeHigh
, ret
);
2708 #else // ! __WIN32__
2710 if (wxStat( filename
, &st
) != 0)
2711 return wxInvalidSize
;
2712 return wxULongLong(st
.st_size
);
2717 wxString
wxFileName::GetHumanReadableSize(const wxULongLong
&bs
,
2718 const wxString
&nullsize
,
2720 wxSizeConvention conv
)
2722 // deal with trivial case first
2723 if ( bs
== 0 || bs
== wxInvalidSize
)
2726 // depending on the convention used the multiplier may be either 1000 or
2727 // 1024 and the binary infix may be empty (for "KB") or "i" (for "KiB")
2728 double multiplier
= 1024.;
2733 case wxSIZE_CONV_TRADITIONAL
:
2734 // nothing to do, this corresponds to the default values of both
2735 // the multiplier and infix string
2738 case wxSIZE_CONV_IEC
:
2742 case wxSIZE_CONV_SI
:
2747 const double kiloByteSize
= multiplier
;
2748 const double megaByteSize
= multiplier
* kiloByteSize
;
2749 const double gigaByteSize
= multiplier
* megaByteSize
;
2750 const double teraByteSize
= multiplier
* gigaByteSize
;
2752 const double bytesize
= bs
.ToDouble();
2755 if ( bytesize
< kiloByteSize
)
2756 result
.Printf("%s B", bs
.ToString());
2757 else if ( bytesize
< megaByteSize
)
2758 result
.Printf("%.*f K%sB", precision
, bytesize
/kiloByteSize
, biInfix
);
2759 else if (bytesize
< gigaByteSize
)
2760 result
.Printf("%.*f M%sB", precision
, bytesize
/megaByteSize
, biInfix
);
2761 else if (bytesize
< teraByteSize
)
2762 result
.Printf("%.*f G%sB", precision
, bytesize
/gigaByteSize
, biInfix
);
2764 result
.Printf("%.*f T%sB", precision
, bytesize
/teraByteSize
, biInfix
);
2769 wxULongLong
wxFileName::GetSize() const
2771 return GetSize(GetFullPath());
2774 wxString
wxFileName::GetHumanReadableSize(const wxString
& failmsg
,
2776 wxSizeConvention conv
) const
2778 return GetHumanReadableSize(GetSize(), failmsg
, precision
, conv
);
2781 #endif // wxUSE_LONGLONG
2783 // ----------------------------------------------------------------------------
2784 // Mac-specific functions
2785 // ----------------------------------------------------------------------------
2787 #if defined( __WXOSX_MAC__ ) && wxOSX_USE_CARBON
2792 class MacDefaultExtensionRecord
2795 MacDefaultExtensionRecord()
2801 // default copy ctor, assignment operator and dtor are ok
2803 MacDefaultExtensionRecord(const wxString
& ext
, OSType type
, OSType creator
)
2807 m_creator
= creator
;
2815 WX_DECLARE_OBJARRAY(MacDefaultExtensionRecord
, MacDefaultExtensionArray
);
2817 bool gMacDefaultExtensionsInited
= false;
2819 #include "wx/arrimpl.cpp"
2821 WX_DEFINE_EXPORTED_OBJARRAY(MacDefaultExtensionArray
);
2823 MacDefaultExtensionArray gMacDefaultExtensions
;
2825 // load the default extensions
2826 const MacDefaultExtensionRecord gDefaults
[] =
2828 MacDefaultExtensionRecord( "txt", 'TEXT', 'ttxt' ),
2829 MacDefaultExtensionRecord( "tif", 'TIFF', '****' ),
2830 MacDefaultExtensionRecord( "jpg", 'JPEG', '****' ),
2833 void MacEnsureDefaultExtensionsLoaded()
2835 if ( !gMacDefaultExtensionsInited
)
2837 // we could load the pc exchange prefs here too
2838 for ( size_t i
= 0 ; i
< WXSIZEOF( gDefaults
) ; ++i
)
2840 gMacDefaultExtensions
.Add( gDefaults
[i
] ) ;
2842 gMacDefaultExtensionsInited
= true;
2846 } // anonymous namespace
2848 bool wxFileName::MacSetTypeAndCreator( wxUint32 type
, wxUint32 creator
)
2851 FSCatalogInfo catInfo
;
2854 if ( wxMacPathToFSRef( GetFullPath() , &fsRef
) == noErr
)
2856 if ( FSGetCatalogInfo (&fsRef
, kFSCatInfoFinderInfo
, &catInfo
, NULL
, NULL
, NULL
) == noErr
)
2858 finfo
= (FileInfo
*)&catInfo
.finderInfo
;
2859 finfo
->fileType
= type
;
2860 finfo
->fileCreator
= creator
;
2861 FSSetCatalogInfo( &fsRef
, kFSCatInfoFinderInfo
, &catInfo
) ;
2868 bool wxFileName::MacGetTypeAndCreator( wxUint32
*type
, wxUint32
*creator
) const
2871 FSCatalogInfo catInfo
;
2874 if ( wxMacPathToFSRef( GetFullPath() , &fsRef
) == noErr
)
2876 if ( FSGetCatalogInfo (&fsRef
, kFSCatInfoFinderInfo
, &catInfo
, NULL
, NULL
, NULL
) == noErr
)
2878 finfo
= (FileInfo
*)&catInfo
.finderInfo
;
2879 *type
= finfo
->fileType
;
2880 *creator
= finfo
->fileCreator
;
2887 bool wxFileName::MacSetDefaultTypeAndCreator()
2889 wxUint32 type
, creator
;
2890 if ( wxFileName::MacFindDefaultTypeAndCreator(GetExt() , &type
,
2893 return MacSetTypeAndCreator( type
, creator
) ;
2898 bool wxFileName::MacFindDefaultTypeAndCreator( const wxString
& ext
, wxUint32
*type
, wxUint32
*creator
)
2900 MacEnsureDefaultExtensionsLoaded() ;
2901 wxString extl
= ext
.Lower() ;
2902 for( int i
= gMacDefaultExtensions
.Count() - 1 ; i
>= 0 ; --i
)
2904 if ( gMacDefaultExtensions
.Item(i
).m_ext
== extl
)
2906 *type
= gMacDefaultExtensions
.Item(i
).m_type
;
2907 *creator
= gMacDefaultExtensions
.Item(i
).m_creator
;
2914 void wxFileName::MacRegisterDefaultTypeAndCreator( const wxString
& ext
, wxUint32 type
, wxUint32 creator
)
2916 MacEnsureDefaultExtensionsLoaded();
2917 MacDefaultExtensionRecord
rec(ext
.Lower(), type
, creator
);
2918 gMacDefaultExtensions
.Add( rec
);
2921 #endif // defined( __WXOSX_MAC__ ) && wxOSX_USE_CARBON