]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/common/filename.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
added more specializations for bcc32
[wxWidgets.git] / src / common / filename.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: src/common/filename.cpp
3// Purpose: wxFileName - encapsulates a file path
4// Author: Robert Roebling, Vadim Zeitlin
5// Modified by:
6// Created: 28.12.2000
7// RCS-ID: $Id$
8// Copyright: (c) 2000 Robert Roebling
9// Licence: wxWindows licence
10/////////////////////////////////////////////////////////////////////////////
11
12/*
13 Here are brief descriptions of the filename formats supported by this class:
14
15 wxPATH_UNIX: standard Unix format, used under Darwin as well, absolute file
16 names have the form:
17 /dir1/dir2/.../dirN/filename, "." and ".." stand for the
18 current and parent directory respectively, "~" is parsed as the
19 user HOME and "~username" as the HOME of that user
20
21 wxPATH_DOS: DOS/Windows format, absolute file names have the form:
22 drive:\dir1\dir2\...\dirN\filename.ext where drive is a single
23 letter. "." and ".." as for Unix but no "~".
24
25 There are also UNC names of the form \\share\fullpath
26
27 wxPATH_MAC: Mac OS 8/9 and Mac OS X under CodeWarrior 7 format, absolute file
28 names have the form
29 volume:dir1:...:dirN:filename
30 and the relative file names are either
31 :dir1:...:dirN:filename
32 or just
33 filename
34 (although :filename works as well).
35 Since the volume is just part of the file path, it is not
36 treated like a separate entity as it is done under DOS and
37 VMS, it is just treated as another dir.
38
39 wxPATH_VMS: VMS native format, absolute file names have the form
40 <device>:[dir1.dir2.dir3]file.txt
41 or
42 <device>:[000000.dir1.dir2.dir3]file.txt
43
44 the <device> is the physical device (i.e. disk). 000000 is the
45 root directory on the device which can be omitted.
46
47 Note that VMS uses different separators unlike Unix:
48 : always after the device. If the path does not contain : than
49 the default (the device of the current directory) is assumed.
50 [ start of directory specyfication
51 . separator between directory and subdirectory
52 ] between directory and file
53 */
54
55// ============================================================================
56// declarations
57// ============================================================================
58
59// ----------------------------------------------------------------------------
60// headers
61// ----------------------------------------------------------------------------
62
63#ifdef __GNUG__
64#pragma implementation "filename.h"
65#endif
66
67// For compilers that support precompilation, includes "wx.h".
68#include "wx/wxprec.h"
69
70#ifdef __BORLANDC__
71#pragma hdrstop
72#endif
73
74#ifndef WX_PRECOMP
75#include "wx/intl.h"
76#include "wx/log.h"
77#include "wx/file.h"
78#endif
79
80#include "wx/filename.h"
81#include "wx/tokenzr.h"
82#include "wx/config.h" // for wxExpandEnvVars
83#include "wx/utils.h"
84#include "wx/file.h"
85#include "wx/dynlib.h"
86
87// For GetShort/LongPathName
88#ifdef __WIN32__
89#include "wx/msw/wrapwin.h"
90#endif
91
92#ifdef __WXWINCE__
93#include "wx/msw/private.h"
94#endif
95
96#if defined(__WXMAC__)
97 #include "wx/mac/private.h" // includes mac headers
98#endif
99
100// utime() is POSIX so should normally be available on all Unices
101#ifdef __UNIX_LIKE__
102#include <sys/types.h>
103#include <utime.h>
104#include <sys/stat.h>
105#include <unistd.h>
106#endif
107
108#ifdef __DJGPP__
109#include <unistd.h>
110#endif
111
112#ifdef __MWERKS__
113#ifdef __MACH__
114#include <sys/types.h>
115#include <utime.h>
116#include <sys/stat.h>
117#include <unistd.h>
118#else
119#include <stat.h>
120#include <unistd.h>
121#include <unix.h>
122#endif
123#endif
124
125#ifdef __WATCOMC__
126#include <io.h>
127#include <sys/utime.h>
128#include <sys/stat.h>
129#endif
130
131#ifdef __VISAGECPP__
132#ifndef MAX_PATH
133#define MAX_PATH 256
134#endif
135#endif
136
137#ifdef __EMX__
138#define MAX_PATH _MAX_PATH
139#endif
140
141// ----------------------------------------------------------------------------
142// private classes
143// ----------------------------------------------------------------------------
144
145// small helper class which opens and closes the file - we use it just to get
146// a file handle for the given file name to pass it to some Win32 API function
147#if defined(__WIN32__) && !defined(__WXMICROWIN__)
148
149class wxFileHandle
150{
151public:
152 enum OpenMode
153 {
154 Read,
155 Write
156 };
157
158 wxFileHandle(const wxString& filename, OpenMode mode)
159 {
160 m_hFile = ::CreateFile
161 (
162 filename, // name
163 mode == Read ? GENERIC_READ // access mask
164 : GENERIC_WRITE,
165 0, // no sharing
166 NULL, // no secutity attr
167 OPEN_EXISTING, // creation disposition
168 0, // no flags
169 NULL // no template file
170 );
171
172 if ( m_hFile == INVALID_HANDLE_VALUE )
173 {
174 wxLogSysError(_("Failed to open '%s' for %s"),
175 filename.c_str(),
176 mode == Read ? _("reading") : _("writing"));
177 }
178 }
179
180 ~wxFileHandle()
181 {
182 if ( m_hFile != INVALID_HANDLE_VALUE )
183 {
184 if ( !::CloseHandle(m_hFile) )
185 {
186 wxLogSysError(_("Failed to close file handle"));
187 }
188 }
189 }
190
191 // return true only if the file could be opened successfully
192 bool IsOk() const { return m_hFile != INVALID_HANDLE_VALUE; }
193
194 // get the handle
195 operator HANDLE() const { return m_hFile; }
196
197private:
198 HANDLE m_hFile;
199};
200
201#endif // __WIN32__
202
203// ----------------------------------------------------------------------------
204// private functions
205// ----------------------------------------------------------------------------
206
207#if wxUSE_DATETIME && defined(__WIN32__) && !defined(__WXMICROWIN__)
208
209// convert between wxDateTime and FILETIME which is a 64-bit value representing
210// the number of 100-nanosecond intervals since January 1, 1601.
211
212static void ConvertFileTimeToWx(wxDateTime *dt, const FILETIME &ft)
213{
214 FILETIME ftcopy = ft;
215 FILETIME ftLocal;
216 if ( !::FileTimeToLocalFileTime(&ftcopy, &ftLocal) )
217 {
218 wxLogLastError(_T("FileTimeToLocalFileTime"));
219 }
220
221 SYSTEMTIME st;
222 if ( !::FileTimeToSystemTime(&ftLocal, &st) )
223 {
224 wxLogLastError(_T("FileTimeToSystemTime"));
225 }
226
227 dt->Set(st.wDay, wxDateTime::Month(st.wMonth - 1), st.wYear,
228 st.wHour, st.wMinute, st.wSecond, st.wMilliseconds);
229}
230
231static void ConvertWxToFileTime(FILETIME *ft, const wxDateTime& dt)
232{
233 SYSTEMTIME st;
234 st.wDay = dt.GetDay();
235 st.wMonth = dt.GetMonth() + 1;
236 st.wYear = dt.GetYear();
237 st.wHour = dt.GetHour();
238 st.wMinute = dt.GetMinute();
239 st.wSecond = dt.GetSecond();
240 st.wMilliseconds = dt.GetMillisecond();
241
242 FILETIME ftLocal;
243 if ( !::SystemTimeToFileTime(&st, &ftLocal) )
244 {
245 wxLogLastError(_T("SystemTimeToFileTime"));
246 }
247
248 if ( !::LocalFileTimeToFileTime(&ftLocal, ft) )
249 {
250 wxLogLastError(_T("LocalFileTimeToFileTime"));
251 }
252}
253
254#endif // wxUSE_DATETIME && __WIN32__
255
256// return a string with the volume par
257static wxString wxGetVolumeString(const wxString& volume, wxPathFormat format)
258{
259 wxString path;
260
261 if ( !volume.empty() )
262 {
263 format = wxFileName::GetFormat(format);
264
265 // Special Windows UNC paths hack, part 2: undo what we did in
266 // SplitPath() and make an UNC path if we have a drive which is not a
267 // single letter (hopefully the network shares can't be one letter only
268 // although I didn't find any authoritative docs on this)
269 if ( format == wxPATH_DOS && volume.length() > 1 )
270 {
271 path << wxFILE_SEP_PATH_DOS << wxFILE_SEP_PATH_DOS << volume;
272 }
273 else if ( format == wxPATH_DOS || format == wxPATH_VMS )
274 {
275 path << volume << wxFileName::GetVolumeSeparator(format);
276 }
277 // else ignore
278 }
279
280 return path;
281}
282
283// ============================================================================
284// implementation
285// ============================================================================
286
287// ----------------------------------------------------------------------------
288// wxFileName construction
289// ----------------------------------------------------------------------------
290
291void wxFileName::Assign( const wxFileName &filepath )
292{
293 m_volume = filepath.GetVolume();
294 m_dirs = filepath.GetDirs();
295 m_name = filepath.GetName();
296 m_ext = filepath.GetExt();
297 m_relative = filepath.m_relative;
298}
299
300void wxFileName::Assign(const wxString& volume,
301 const wxString& path,
302 const wxString& name,
303 const wxString& ext,
304 wxPathFormat format )
305{
306 SetPath( path, format );
307
308 m_volume = volume;
309 m_ext = ext;
310 m_name = name;
311}
312
313void wxFileName::SetPath( const wxString &path, wxPathFormat format )
314{
315 m_dirs.Clear();
316
317 if ( !path.empty() )
318 {
319 wxPathFormat my_format = GetFormat( format );
320 wxString my_path = path;
321
322 // 1) Determine if the path is relative or absolute.
323 wxChar leadingChar = my_path[0u];
324
325 switch (my_format)
326 {
327 case wxPATH_MAC:
328 m_relative = leadingChar == wxT(':');
329
330 // We then remove a leading ":". The reason is in our
331 // storage form for relative paths:
332 // ":dir:file.txt" actually means "./dir/file.txt" in
333 // DOS notation and should get stored as
334 // (relative) (dir) (file.txt)
335 // "::dir:file.txt" actually means "../dir/file.txt"
336 // stored as (relative) (..) (dir) (file.txt)
337 // This is important only for the Mac as an empty dir
338 // actually means <UP>, whereas under DOS, double
339 // slashes can be ignored: "\\\\" is the same as "\\".
340 if (m_relative)
341 my_path.erase( 0, 1 );
342 break;
343
344 case wxPATH_VMS:
345 // TODO: what is the relative path format here?
346 m_relative = false;
347 break;
348
349 default:
350 wxFAIL_MSG( _T("Unknown path format") );
351 // !! Fall through !!
352
353 case wxPATH_UNIX:
354 // the paths of the form "~" or "~username" are absolute
355 m_relative = leadingChar != wxT('/') && leadingChar != _T('~');
356 break;
357
358 case wxPATH_DOS:
359 m_relative = !IsPathSeparator(leadingChar, my_format);
360 break;
361
362 }
363
364 // 2) Break up the path into its members. If the original path
365 // was just "/" or "\\", m_dirs will be empty. We know from
366 // the m_relative field, if this means "nothing" or "root dir".
367
368 wxStringTokenizer tn( my_path, GetPathSeparators(my_format) );
369
370 while ( tn.HasMoreTokens() )
371 {
372 wxString token = tn.GetNextToken();
373
374 // Remove empty token under DOS and Unix, interpret them
375 // as .. under Mac.
376 if (token.empty())
377 {
378 if (my_format == wxPATH_MAC)
379 m_dirs.Add( wxT("..") );
380 // else ignore
381 }
382 else
383 {
384 m_dirs.Add( token );
385 }
386 }
387 }
388 else // no path at all
389 {
390 m_relative = true;
391 }
392}
393
394void wxFileName::Assign(const wxString& fullpath,
395 wxPathFormat format)
396{
397 wxString volume, path, name, ext;
398 SplitPath(fullpath, &volume, &path, &name, &ext, format);
399
400 Assign(volume, path, name, ext, format);
401}
402
403void wxFileName::Assign(const wxString& fullpathOrig,
404 const wxString& fullname,
405 wxPathFormat format)
406{
407 // always recognize fullpath as directory, even if it doesn't end with a
408 // slash
409 wxString fullpath = fullpathOrig;
410 if ( !wxEndsWithPathSeparator(fullpath) )
411 {
412 fullpath += GetPathSeparator(format);
413 }
414
415 wxString volume, path, name, ext;
416
417 // do some consistency checks in debug mode: the name should be really just
418 // the filename and the path should be really just a path
419#ifdef __WXDEBUG__
420 wxString pathDummy, nameDummy, extDummy;
421
422 SplitPath(fullname, &pathDummy, &name, &ext, format);
423
424 wxASSERT_MSG( pathDummy.empty(),
425 _T("the file name shouldn't contain the path") );
426
427 SplitPath(fullpath, &volume, &path, &nameDummy, &extDummy, format);
428
429 wxASSERT_MSG( nameDummy.empty() && extDummy.empty(),
430 _T("the path shouldn't contain file name nor extension") );
431
432#else // !__WXDEBUG__
433 SplitPath(fullname, NULL /* no path */, &name, &ext, format);
434 SplitPath(fullpath, &volume, &path, NULL, NULL, format);
435#endif // __WXDEBUG__/!__WXDEBUG__
436
437 Assign(volume, path, name, ext, format);
438}
439
440void wxFileName::AssignDir(const wxString& dir, wxPathFormat format)
441{
442 Assign(dir, _T(""), format);
443}
444
445void wxFileName::Clear()
446{
447 m_dirs.Clear();
448
449 m_volume =
450 m_name =
451 m_ext = wxEmptyString;
452
453 // we don't have any absolute path for now
454 m_relative = true;
455}
456
457/* static */
458wxFileName wxFileName::FileName(const wxString& file, wxPathFormat format)
459{
460 return wxFileName(file, format);
461}
462
463/* static */
464wxFileName wxFileName::DirName(const wxString& dir, wxPathFormat format)
465{
466 wxFileName fn;
467 fn.AssignDir(dir, format);
468 return fn;
469}
470
471// ----------------------------------------------------------------------------
472// existence tests
473// ----------------------------------------------------------------------------
474
475bool wxFileName::FileExists() const
476{
477 return wxFileName::FileExists( GetFullPath() );
478}
479
480bool wxFileName::FileExists( const wxString &file )
481{
482 return ::wxFileExists( file );
483}
484
485bool wxFileName::DirExists() const
486{
487 return wxFileName::DirExists( GetFullPath() );
488}
489
490bool wxFileName::DirExists( const wxString &dir )
491{
492 return ::wxDirExists( dir );
493}
494
495// ----------------------------------------------------------------------------
496// CWD and HOME stuff
497// ----------------------------------------------------------------------------
498
499void wxFileName::AssignCwd(const wxString& volume)
500{
501 AssignDir(wxFileName::GetCwd(volume));
502}
503
504/* static */
505wxString wxFileName::GetCwd(const wxString& volume)
506{
507 // if we have the volume, we must get the current directory on this drive
508 // and to do this we have to chdir to this volume - at least under Windows,
509 // I don't know how to get the current drive on another volume elsewhere
510 // (TODO)
511 wxString cwdOld;
512 if ( !volume.empty() )
513 {
514 cwdOld = wxGetCwd();
515 SetCwd(volume + GetVolumeSeparator());
516 }
517
518 wxString cwd = ::wxGetCwd();
519
520 if ( !volume.empty() )
521 {
522 SetCwd(cwdOld);
523 }
524
525 return cwd;
526}
527
528bool wxFileName::SetCwd()
529{
530 return wxFileName::SetCwd( GetFullPath() );
531}
532
533bool wxFileName::SetCwd( const wxString &cwd )
534{
535 return ::wxSetWorkingDirectory( cwd );
536}
537
538void wxFileName::AssignHomeDir()
539{
540 AssignDir(wxFileName::GetHomeDir());
541}
542
543wxString wxFileName::GetHomeDir()
544{
545 return ::wxGetHomeDir();
546}
547
548void wxFileName::AssignTempFileName(const wxString& prefix, wxFile *fileTemp)
549{
550 wxString tempname = CreateTempFileName(prefix, fileTemp);
551 if ( tempname.empty() )
552 {
553 // error, failed to get temp file name
554 Clear();
555 }
556 else // ok
557 {
558 Assign(tempname);
559 }
560}
561
562/* static */
563wxString
564wxFileName::CreateTempFileName(const wxString& prefix, wxFile *fileTemp)
565{
566 wxString path, dir, name;
567
568 // use the directory specified by the prefix
569 SplitPath(prefix, &dir, &name, NULL /* extension */);
570
571#if defined(__WXWINCE__)
572 if (dir.empty())
573 {
574 // FIXME. Create \temp dir?
575 dir = wxT("\\");
576 }
577 path = dir + wxT("\\") + prefix;
578 int i = 1;
579 while (wxFileExists(path))
580 {
581 path = dir + wxT("\\") + prefix ;
582 path << i;
583 i ++;
584 }
585
586#elif defined(__WINDOWS__) && !defined(__WXMICROWIN__)
587#ifdef __WIN32__
588 if ( dir.empty() )
589 {
590 if ( !::GetTempPath(MAX_PATH, wxStringBuffer(dir, MAX_PATH + 1)) )
591 {
592 wxLogLastError(_T("GetTempPath"));
593 }
594
595 if ( dir.empty() )
596 {
597 // GetTempFileName() fails if we pass it an empty string
598 dir = _T('.');
599 }
600 }
601 else // we have a dir to create the file in
602 {
603 // ensure we use only the back slashes as GetTempFileName(), unlike all
604 // the other APIs, is picky and doesn't accept the forward ones
605 dir.Replace(_T("/"), _T("\\"));
606 }
607
608 if ( !::GetTempFileName(dir, name, 0, wxStringBuffer(path, MAX_PATH + 1)) )
609 {
610 wxLogLastError(_T("GetTempFileName"));
611
612 path.clear();
613 }
614#else // Win16
615 if ( !::GetTempFileName(NULL, prefix, 0, wxStringBuffer(path, 1025)) )
616 {
617 path.clear();
618 }
619#endif // Win32/16
620
621#elif defined(__WXPM__)
622 // for now just create a file
623 //
624 // future enhancements can be to set some extended attributes for file
625 // systems OS/2 supports that have them (HPFS, FAT32) and security
626 // (HPFS386)
627 static const wxChar *szMktempSuffix = wxT("XXX");
628 path << dir << _T('/') << name << szMktempSuffix;
629
630 // Temporarily remove - MN
631 #ifndef __WATCOMC__
632 ::DosCreateDir(wxStringBuffer(path, MAX_PATH), NULL);
633 #endif
634
635#else // !Windows, !OS/2
636 if ( dir.empty() )
637 {
638#if defined(__WXMAC__) && !defined(__DARWIN__)
639 dir = wxMacFindFolder( (short) kOnSystemDisk, kTemporaryFolderType, kCreateFolder ) ;
640#else // !Mac
641 dir = wxGetenv(_T("TMP"));
642 if ( dir.empty() )
643 {
644 dir = wxGetenv(_T("TEMP"));
645 }
646
647 if ( dir.empty() )
648 {
649 // default
650 #ifdef __DOS__
651 dir = _T(".");
652 #else
653 dir = _T("/tmp");
654 #endif
655 }
656#endif // Mac/!Mac
657 }
658
659 path = dir;
660
661 if ( !wxEndsWithPathSeparator(dir) &&
662 (name.empty() || !wxIsPathSeparator(name[0u])) )
663 {
664 path += wxFILE_SEP_PATH;
665 }
666
667 path += name;
668
669#if defined(HAVE_MKSTEMP)
670 // scratch space for mkstemp()
671 path += _T("XXXXXX");
672
673 // we need to copy the path to the buffer in which mkstemp() can modify it
674 wxCharBuffer buf( wxConvFile.cWX2MB( path ) );
675
676 // cast is safe because the string length doesn't change
677 int fdTemp = mkstemp( (char*)(const char*) buf );
678 if ( fdTemp == -1 )
679 {
680 // this might be not necessary as mkstemp() on most systems should have
681 // already done it but it doesn't hurt neither...
682 path.clear();
683 }
684 else // mkstemp() succeeded
685 {
686 path = wxConvFile.cMB2WX( (const char*) buf );
687
688 // avoid leaking the fd
689 if ( fileTemp )
690 {
691 fileTemp->Attach(fdTemp);
692 }
693 else
694 {
695 close(fdTemp);
696 }
697 }
698#else // !HAVE_MKSTEMP
699
700#ifdef HAVE_MKTEMP
701 // same as above
702 path += _T("XXXXXX");
703
704 wxCharBuffer buf = wxConvFile.cWX2MB( path );
705 if ( !mktemp( (const char*) buf ) )
706 {
707 path.clear();
708 }
709 else
710 {
711 path = wxConvFile.cMB2WX( (const char*) buf );
712 }
713#else // !HAVE_MKTEMP (includes __DOS__)
714 // generate the unique file name ourselves
715 #if !defined(__DOS__) && (!defined(__MWERKS__) || defined(__DARWIN__) )
716 path << (unsigned int)getpid();
717 #endif
718
719 wxString pathTry;
720
721 static const size_t numTries = 1000;
722 for ( size_t n = 0; n < numTries; n++ )
723 {
724 // 3 hex digits is enough for numTries == 1000 < 4096
725 pathTry = path + wxString::Format(_T("%.03x"), n);
726 if ( !wxFile::Exists(pathTry) )
727 {
728 break;
729 }
730
731 pathTry.clear();
732 }
733
734 path = pathTry;
735#endif // HAVE_MKTEMP/!HAVE_MKTEMP
736
737 if ( !path.empty() )
738 {
739 }
740#endif // HAVE_MKSTEMP/!HAVE_MKSTEMP
741
742#endif // Windows/!Windows
743
744 if ( path.empty() )
745 {
746 wxLogSysError(_("Failed to create a temporary file name"));
747 }
748 else if ( fileTemp && !fileTemp->IsOpened() )
749 {
750 // open the file - of course, there is a race condition here, this is
751 // why we always prefer using mkstemp()...
752 //
753 // NB: GetTempFileName() under Windows creates the file, so using
754 // write_excl there would fail
755 if ( !fileTemp->Open(path,
756#if defined(__WINDOWS__) && !defined(__WXMICROWIN__)
757 wxFile::write,
758#else
759 wxFile::write_excl,
760#endif
761 wxS_IRUSR | wxS_IWUSR) )
762 {
763 // FIXME: If !ok here should we loop and try again with another
764 // file name? That is the standard recourse if open(O_EXCL)
765 // fails, though of course it should be protected against
766 // possible infinite looping too.
767
768 wxLogError(_("Failed to open temporary file."));
769
770 path.clear();
771 }
772 }
773
774 return path;
775}
776
777// ----------------------------------------------------------------------------
778// directory operations
779// ----------------------------------------------------------------------------
780
781bool wxFileName::Mkdir( int perm, int flags )
782{
783 return wxFileName::Mkdir( GetFullPath(), perm, flags );
784}
785
786bool wxFileName::Mkdir( const wxString& dir, int perm, int flags )
787{
788 if ( flags & wxPATH_MKDIR_FULL )
789 {
790 // split the path in components
791 wxFileName filename;
792 filename.AssignDir(dir);
793
794 wxString currPath;
795 if ( filename.HasVolume())
796 {
797 currPath << wxGetVolumeString(filename.GetVolume(), wxPATH_NATIVE);
798 }
799
800 wxArrayString dirs = filename.GetDirs();
801 size_t count = dirs.GetCount();
802 for ( size_t i = 0; i < count; i++ )
803 {
804 if ( i > 0 ||
805#if defined(__WXMAC__) && !defined(__DARWIN__)
806 // relative pathnames are exactely the other way round under mac...
807 !filename.IsAbsolute()
808#else
809 filename.IsAbsolute()
810#endif
811 )
812 currPath += wxFILE_SEP_PATH;
813 currPath += dirs[i];
814
815 if (!DirExists(currPath))
816 {
817 if (!wxMkdir(currPath, perm))
818 {
819 // no need to try creating further directories
820 return false;
821 }
822 }
823 }
824
825 return true;
826
827 }
828
829 return ::wxMkdir( dir, perm );
830}
831
832bool wxFileName::Rmdir()
833{
834 return wxFileName::Rmdir( GetFullPath() );
835}
836
837bool wxFileName::Rmdir( const wxString &dir )
838{
839 return ::wxRmdir( dir );
840}
841
842// ----------------------------------------------------------------------------
843// path normalization
844// ----------------------------------------------------------------------------
845
846bool wxFileName::Normalize(int flags,
847 const wxString& cwd,
848 wxPathFormat format)
849{
850 // the existing path components
851 wxArrayString dirs = GetDirs();
852
853 // the path to prepend in front to make the path absolute
854 wxFileName curDir;
855
856 format = GetFormat(format);
857
858 // make the path absolute
859 if ( (flags & wxPATH_NORM_ABSOLUTE) && !IsAbsolute(format) )
860 {
861 if ( cwd.empty() )
862 {
863 curDir.AssignCwd(GetVolume());
864 }
865 else // cwd provided
866 {
867 curDir.AssignDir(cwd);
868 }
869
870 // the path may be not absolute because it doesn't have the volume name
871 // but in this case we shouldn't modify the directory components of it
872 // but just set the current volume
873 if ( !HasVolume() && curDir.HasVolume() )
874 {
875 SetVolume(curDir.GetVolume());
876
877 if ( !m_relative )
878 {
879 // yes, it was the case - we don't need curDir then
880 curDir.Clear();
881 }
882 }
883 }
884
885 // handle ~ stuff under Unix only
886 if ( (format == wxPATH_UNIX) && (flags & wxPATH_NORM_TILDE) )
887 {
888 if ( !dirs.IsEmpty() )
889 {
890 wxString dir = dirs[0u];
891 if ( !dir.empty() && dir[0u] == _T('~') )
892 {
893 curDir.AssignDir(wxGetUserHome(dir.c_str() + 1));
894
895 dirs.RemoveAt(0u);
896 }
897 }
898 }
899
900 // transform relative path into abs one
901 if ( curDir.IsOk() )
902 {
903 wxArrayString dirsNew = curDir.GetDirs();
904 size_t count = dirs.GetCount();
905 for ( size_t n = 0; n < count; n++ )
906 {
907 dirsNew.Add(dirs[n]);
908 }
909
910 dirs = dirsNew;
911 }
912
913 // now deal with ".", ".." and the rest
914 m_dirs.Empty();
915 size_t count = dirs.GetCount();
916 for ( size_t n = 0; n < count; n++ )
917 {
918 wxString dir = dirs[n];
919
920 if ( flags & wxPATH_NORM_DOTS )
921 {
922 if ( dir == wxT(".") )
923 {
924 // just ignore
925 continue;
926 }
927
928 if ( dir == wxT("..") )
929 {
930 if ( m_dirs.IsEmpty() )
931 {
932 wxLogError(_("The path '%s' contains too many \"..\"!"),
933 GetFullPath().c_str());
934 return false;
935 }
936
937 m_dirs.RemoveAt(m_dirs.GetCount() - 1);
938 continue;
939 }
940 }
941
942 if ( flags & wxPATH_NORM_ENV_VARS )
943 {
944 dir = wxExpandEnvVars(dir);
945 }
946
947 if ( (flags & wxPATH_NORM_CASE) && !IsCaseSensitive(format) )
948 {
949 dir.MakeLower();
950 }
951
952 m_dirs.Add(dir);
953 }
954
955 if ( (flags & wxPATH_NORM_CASE) && !IsCaseSensitive(format) )
956 {
957 // VZ: expand env vars here too?
958
959 m_name.MakeLower();
960 m_ext.MakeLower();
961 }
962
963 // we do have the path now
964 //
965 // NB: need to do this before (maybe) calling Assign() below
966 m_relative = false;
967
968#if defined(__WIN32__)
969 if ( (flags & wxPATH_NORM_LONG) && (format == wxPATH_DOS) )
970 {
971 Assign(GetLongPath());
972 }
973#endif // Win32
974
975 return true;
976}
977
978// ----------------------------------------------------------------------------
979// absolute/relative paths
980// ----------------------------------------------------------------------------
981
982bool wxFileName::IsAbsolute(wxPathFormat format) const
983{
984 // if our path doesn't start with a path separator, it's not an absolute
985 // path
986 if ( m_relative )
987 return false;
988
989 if ( !GetVolumeSeparator(format).empty() )
990 {
991 // this format has volumes and an absolute path must have one, it's not
992 // enough to have the full path to bean absolute file under Windows
993 if ( GetVolume().empty() )
994 return false;
995 }
996
997 return true;
998}
999
1000bool wxFileName::MakeRelativeTo(const wxString& pathBase, wxPathFormat format)
1001{
1002 wxFileName fnBase = wxFileName::DirName(pathBase, format);
1003
1004 // get cwd only once - small time saving
1005 wxString cwd = wxGetCwd();
1006 Normalize(wxPATH_NORM_ALL & ~wxPATH_NORM_CASE, cwd, format);
1007 fnBase.Normalize(wxPATH_NORM_ALL & ~wxPATH_NORM_CASE, cwd, format);
1008
1009 bool withCase = IsCaseSensitive(format);
1010
1011 // we can't do anything if the files live on different volumes
1012 if ( !GetVolume().IsSameAs(fnBase.GetVolume(), withCase) )
1013 {
1014 // nothing done
1015 return false;
1016 }
1017
1018 // same drive, so we don't need our volume
1019 m_volume.clear();
1020
1021 // remove common directories starting at the top
1022 while ( !m_dirs.IsEmpty() && !fnBase.m_dirs.IsEmpty() &&
1023 m_dirs[0u].IsSameAs(fnBase.m_dirs[0u], withCase) )
1024 {
1025 m_dirs.RemoveAt(0);
1026 fnBase.m_dirs.RemoveAt(0);
1027 }
1028
1029 // add as many ".." as needed
1030 size_t count = fnBase.m_dirs.GetCount();
1031 for ( size_t i = 0; i < count; i++ )
1032 {
1033 m_dirs.Insert(wxT(".."), 0u);
1034 }
1035
1036 if ( format == wxPATH_UNIX || format == wxPATH_DOS )
1037 {
1038 // a directory made relative with respect to itself is '.' under Unix
1039 // and DOS, by definition (but we don't have to insert "./" for the
1040 // files)
1041 if ( m_dirs.IsEmpty() && IsDir() )
1042 {
1043 m_dirs.Add(_T('.'));
1044 }
1045 }
1046
1047 m_relative = true;
1048
1049 // we were modified
1050 return true;
1051}
1052
1053// ----------------------------------------------------------------------------
1054// filename kind tests
1055// ----------------------------------------------------------------------------
1056
1057bool wxFileName::SameAs(const wxFileName& filepath, wxPathFormat format) const
1058{
1059 wxFileName fn1 = *this,
1060 fn2 = filepath;
1061
1062 // get cwd only once - small time saving
1063 wxString cwd = wxGetCwd();
1064 fn1.Normalize(wxPATH_NORM_ALL & ~wxPATH_NORM_CASE, cwd, format);
1065 fn2.Normalize(wxPATH_NORM_ALL & ~wxPATH_NORM_CASE, cwd, format);
1066
1067 if ( fn1.GetFullPath() == fn2.GetFullPath() )
1068 return true;
1069
1070 // TODO: compare inodes for Unix, this works even when filenames are
1071 // different but files are the same (symlinks) (VZ)
1072
1073 return false;
1074}
1075
1076/* static */
1077bool wxFileName::IsCaseSensitive( wxPathFormat format )
1078{
1079 // only Unix filenames are truely case-sensitive
1080 return GetFormat(format) == wxPATH_UNIX;
1081}
1082
1083/* static */
1084wxString wxFileName::GetForbiddenChars(wxPathFormat format)
1085{
1086 // Inits to forbidden characters that are common to (almost) all platforms.
1087 wxString strForbiddenChars = wxT("*?");
1088
1089 // If asserts, wxPathFormat has been changed. In case of a new path format
1090 // addition, the following code might have to be updated.
1091 wxCOMPILE_TIME_ASSERT(wxPATH_MAX == 5, wxPathFormatChanged);
1092 switch ( GetFormat(format) )
1093 {
1094 default :
1095 wxFAIL_MSG( wxT("Unknown path format") );
1096 // !! Fall through !!
1097
1098 case wxPATH_UNIX:
1099 break;
1100
1101 case wxPATH_MAC:
1102 // On a Mac even names with * and ? are allowed (Tested with OS
1103 // 9.2.1 and OS X 10.2.5)
1104 strForbiddenChars = wxEmptyString;
1105 break;
1106
1107 case wxPATH_DOS:
1108 strForbiddenChars += wxT("\\/:\"<>|");
1109 break;
1110
1111 case wxPATH_VMS:
1112 break;
1113 }
1114
1115 return strForbiddenChars;
1116}
1117
1118/* static */
1119wxString wxFileName::GetVolumeSeparator(wxPathFormat format)
1120{
1121 wxString sepVol;
1122
1123 if ( (GetFormat(format) == wxPATH_DOS) ||
1124 (GetFormat(format) == wxPATH_VMS) )
1125 {
1126 sepVol = wxFILE_SEP_DSK;
1127 }
1128 //else: leave empty
1129
1130 return sepVol;
1131}
1132
1133/* static */
1134wxString wxFileName::GetPathSeparators(wxPathFormat format)
1135{
1136 wxString seps;
1137 switch ( GetFormat(format) )
1138 {
1139 case wxPATH_DOS:
1140 // accept both as native APIs do but put the native one first as
1141 // this is the one we use in GetFullPath()
1142 seps << wxFILE_SEP_PATH_DOS << wxFILE_SEP_PATH_UNIX;
1143 break;
1144
1145 default:
1146 wxFAIL_MSG( _T("Unknown wxPATH_XXX style") );
1147 // fall through
1148
1149 case wxPATH_UNIX:
1150 seps = wxFILE_SEP_PATH_UNIX;
1151 break;
1152
1153 case wxPATH_MAC:
1154 seps = wxFILE_SEP_PATH_MAC;
1155 break;
1156
1157 case wxPATH_VMS:
1158 seps = wxFILE_SEP_PATH_VMS;
1159 break;
1160 }
1161
1162 return seps;
1163}
1164
1165/* static */
1166bool wxFileName::IsPathSeparator(wxChar ch, wxPathFormat format)
1167{
1168 // wxString::Find() doesn't work as expected with NUL - it will always find
1169 // it, so it is almost surely a bug if this function is called with NUL arg
1170 wxASSERT_MSG( ch != _T('\0'), _T("shouldn't be called with NUL") );
1171
1172 return GetPathSeparators(format).Find(ch) != wxNOT_FOUND;
1173}
1174
1175// ----------------------------------------------------------------------------
1176// path components manipulation
1177// ----------------------------------------------------------------------------
1178
1179void wxFileName::AppendDir( const wxString &dir )
1180{
1181 m_dirs.Add( dir );
1182}
1183
1184void wxFileName::PrependDir( const wxString &dir )
1185{
1186 m_dirs.Insert( dir, 0 );
1187}
1188
1189void wxFileName::InsertDir( int before, const wxString &dir )
1190{
1191 m_dirs.Insert( dir, before );
1192}
1193
1194void wxFileName::RemoveDir( int pos )
1195{
1196 m_dirs.RemoveAt( (size_t)pos );
1197}
1198
1199// ----------------------------------------------------------------------------
1200// accessors
1201// ----------------------------------------------------------------------------
1202
1203void wxFileName::SetFullName(const wxString& fullname)
1204{
1205 SplitPath(fullname, NULL /* no path */, &m_name, &m_ext);
1206}
1207
1208wxString wxFileName::GetFullName() const
1209{
1210 wxString fullname = m_name;
1211 if ( !m_ext.empty() )
1212 {
1213 fullname << wxFILE_SEP_EXT << m_ext;
1214 }
1215
1216 return fullname;
1217}
1218
1219wxString wxFileName::GetPath( int flags, wxPathFormat format ) const
1220{
1221 format = GetFormat( format );
1222
1223 wxString fullpath;
1224
1225 // return the volume with the path as well if requested
1226 if ( flags & wxPATH_GET_VOLUME )
1227 {
1228 fullpath += wxGetVolumeString(GetVolume(), format);
1229 }
1230
1231 // the leading character
1232 switch ( format )
1233 {
1234 case wxPATH_MAC:
1235 if ( m_relative )
1236 fullpath += wxFILE_SEP_PATH_MAC;
1237 break;
1238
1239 case wxPATH_DOS:
1240 if (!m_relative)
1241 fullpath += wxFILE_SEP_PATH_DOS;
1242 break;
1243
1244 default:
1245 wxFAIL_MSG( wxT("Unknown path format") );
1246 // fall through
1247
1248 case wxPATH_UNIX:
1249 if ( !m_relative )
1250 {
1251 // normally the absolute file names starts with a slash with
1252 // one exception: file names like "~/foo.bar" don't have it
1253 if ( m_dirs.IsEmpty() || m_dirs[0u] != _T('~') )
1254 {
1255 fullpath += wxFILE_SEP_PATH_UNIX;
1256 }
1257 }
1258 break;
1259
1260 case wxPATH_VMS:
1261 // no leading character here but use this place to unset
1262 // wxPATH_GET_SEPARATOR flag: under VMS it doesn't make sense as,
1263 // if I understand correctly, there should never be a dot before
1264 // the closing bracket
1265 flags &= ~wxPATH_GET_SEPARATOR;
1266 }
1267
1268 // then concatenate all the path components using the path separator
1269 size_t dirCount = m_dirs.GetCount();
1270 if ( dirCount )
1271 {
1272 if ( format == wxPATH_VMS )
1273 {
1274 fullpath += wxT('[');
1275 }
1276
1277 for ( size_t i = 0; i < dirCount; i++ )
1278 {
1279 switch (format)
1280 {
1281 case wxPATH_MAC:
1282 if ( m_dirs[i] == wxT(".") )
1283 {
1284 // skip appending ':', this shouldn't be done in this
1285 // case as "::" is interpreted as ".." under Unix
1286 continue;
1287 }
1288
1289 // convert back from ".." to nothing
1290 if ( m_dirs[i] != wxT("..") )
1291 fullpath += m_dirs[i];
1292 break;
1293
1294 default:
1295 wxFAIL_MSG( wxT("Unexpected path format") );
1296 // still fall through
1297
1298 case wxPATH_DOS:
1299 case wxPATH_UNIX:
1300 fullpath += m_dirs[i];
1301 break;
1302
1303 case wxPATH_VMS:
1304 // TODO: What to do with ".." under VMS
1305
1306 // convert back from ".." to nothing
1307 if ( m_dirs[i] != wxT("..") )
1308 fullpath += m_dirs[i];
1309 break;
1310 }
1311
1312 if ( (flags & wxPATH_GET_SEPARATOR) || (i != dirCount - 1) )
1313 fullpath += GetPathSeparator(format);
1314 }
1315
1316 if ( format == wxPATH_VMS )
1317 {
1318 fullpath += wxT(']');
1319 }
1320 }
1321
1322 return fullpath;
1323}
1324
1325wxString wxFileName::GetFullPath( wxPathFormat format ) const
1326{
1327 // we already have a function to get the path
1328 wxString fullpath = GetPath(wxPATH_GET_VOLUME | wxPATH_GET_SEPARATOR,
1329 format);
1330
1331 // now just add the file name and extension to it
1332 fullpath += GetFullName();
1333
1334 return fullpath;
1335}
1336
1337// Return the short form of the path (returns identity on non-Windows platforms)
1338wxString wxFileName::GetShortPath() const
1339{
1340#if defined(__WXMSW__) && defined(__WIN32__) && !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
1341 wxString path(GetFullPath());
1342 wxString pathOut;
1343 DWORD sz = ::GetShortPathName(path, NULL, 0);
1344 bool ok = sz != 0;
1345 if ( ok )
1346 {
1347 ok = ::GetShortPathName
1348 (
1349 path,
1350 wxStringBuffer(pathOut, sz),
1351 sz
1352 ) != 0;
1353 }
1354 if (ok)
1355 return pathOut;
1356
1357 return path;
1358#else
1359 return GetFullPath();
1360#endif
1361}
1362
1363// Return the long form of the path (returns identity on non-Windows platforms)
1364wxString wxFileName::GetLongPath() const
1365{
1366 wxString pathOut,
1367 path = GetFullPath();
1368
1369#if defined(__WIN32__) && !defined(__WXMICROWIN__)
1370 bool success = false;
1371
1372#if wxUSE_DYNAMIC_LOADER
1373 typedef DWORD (WINAPI *GET_LONG_PATH_NAME)(const wxChar *, wxChar *, DWORD);
1374
1375 static bool s_triedToLoad = false;
1376
1377 if ( !s_triedToLoad )
1378 {
1379 // suppress the errors about missing GetLongPathName[AW]
1380 wxLogNull noLog;
1381
1382 s_triedToLoad = true;
1383 wxDynamicLibrary dllKernel(_T("kernel32"));
1384 if ( dllKernel.IsLoaded() )
1385 {
1386 // may succeed or fail depending on the Windows version
1387 static GET_LONG_PATH_NAME s_pfnGetLongPathName = NULL;
1388#ifdef _UNICODE
1389 s_pfnGetLongPathName = (GET_LONG_PATH_NAME) dllKernel.GetSymbol(_T("GetLongPathNameW"));
1390#else
1391 s_pfnGetLongPathName = (GET_LONG_PATH_NAME) dllKernel.GetSymbol(_T("GetLongPathNameA"));
1392#endif
1393
1394 if ( s_pfnGetLongPathName )
1395 {
1396 DWORD dwSize = (*s_pfnGetLongPathName)(path, NULL, 0);
1397 bool ok = dwSize > 0;
1398
1399 if ( ok )
1400 {
1401 DWORD sz = (*s_pfnGetLongPathName)(path, NULL, 0);
1402 ok = sz != 0;
1403 if ( ok )
1404 {
1405 ok = (*s_pfnGetLongPathName)
1406 (
1407 path,
1408 wxStringBuffer(pathOut, sz),
1409 sz
1410 ) != 0;
1411 success = true;
1412 }
1413 }
1414 }
1415 }
1416 }
1417
1418 if (success)
1419 return pathOut;
1420#endif // wxUSE_DYNAMIC_LOADER
1421
1422 if (!success)
1423 {
1424 // The OS didn't support GetLongPathName, or some other error.
1425 // We need to call FindFirstFile on each component in turn.
1426
1427 WIN32_FIND_DATA findFileData;
1428 HANDLE hFind;
1429
1430 if ( HasVolume() )
1431 pathOut = GetVolume() +
1432 GetVolumeSeparator(wxPATH_DOS) +
1433 GetPathSeparator(wxPATH_DOS);
1434 else
1435 pathOut = wxEmptyString;
1436
1437 wxArrayString dirs = GetDirs();
1438 dirs.Add(GetFullName());
1439
1440 wxString tmpPath;
1441
1442 size_t count = dirs.GetCount();
1443 for ( size_t i = 0; i < count; i++ )
1444 {
1445 // We're using pathOut to collect the long-name path, but using a
1446 // temporary for appending the last path component which may be
1447 // short-name
1448 tmpPath = pathOut + dirs[i];
1449
1450 if ( tmpPath.empty() )
1451 continue;
1452
1453 // can't see this being necessary? MF
1454 if ( tmpPath.Last() == GetVolumeSeparator(wxPATH_DOS) )
1455 {
1456 // Can't pass a drive and root dir to FindFirstFile,
1457 // so continue to next dir
1458 tmpPath += wxFILE_SEP_PATH;
1459 pathOut = tmpPath;
1460 continue;
1461 }
1462
1463 hFind = ::FindFirstFile(tmpPath, &findFileData);
1464 if (hFind == INVALID_HANDLE_VALUE)
1465 {
1466 // Error: most likely reason is that path doesn't exist, so
1467 // append any unprocessed parts and return
1468 for ( i += 1; i < count; i++ )
1469 tmpPath += wxFILE_SEP_PATH + dirs[i];
1470
1471 return tmpPath;
1472 }
1473
1474 pathOut += findFileData.cFileName;
1475 if ( (i < (count-1)) )
1476 pathOut += wxFILE_SEP_PATH;
1477
1478 ::FindClose(hFind);
1479 }
1480 }
1481#else // !Win32
1482 pathOut = path;
1483#endif // Win32/!Win32
1484
1485 return pathOut;
1486}
1487
1488wxPathFormat wxFileName::GetFormat( wxPathFormat format )
1489{
1490 if (format == wxPATH_NATIVE)
1491 {
1492#if defined(__WXMSW__) || defined(__WXPM__) || defined(__DOS__)
1493 format = wxPATH_DOS;
1494#elif defined(__WXMAC__) && !defined(__DARWIN__)
1495 format = wxPATH_MAC;
1496#elif defined(__VMS)
1497 format = wxPATH_VMS;
1498#else
1499 format = wxPATH_UNIX;
1500#endif
1501 }
1502 return format;
1503}
1504
1505// ----------------------------------------------------------------------------
1506// path splitting function
1507// ----------------------------------------------------------------------------
1508
1509/* static */
1510void wxFileName::SplitPath(const wxString& fullpathWithVolume,
1511 wxString *pstrVolume,
1512 wxString *pstrPath,
1513 wxString *pstrName,
1514 wxString *pstrExt,
1515 wxPathFormat format)
1516{
1517 format = GetFormat(format);
1518
1519 wxString fullpath = fullpathWithVolume;
1520
1521 // under VMS the end of the path is ']', not the path separator used to
1522 // separate the components
1523 wxString sepPath = format == wxPATH_VMS ? wxString(_T(']'))
1524 : GetPathSeparators(format);
1525
1526 // special Windows UNC paths hack: transform \\share\path into share:path
1527 if ( format == wxPATH_DOS )
1528 {
1529 if ( fullpath.length() >= 4 &&
1530 fullpath[0u] == wxFILE_SEP_PATH_DOS &&
1531 fullpath[1u] == wxFILE_SEP_PATH_DOS )
1532 {
1533 fullpath.erase(0, 2);
1534
1535 size_t posFirstSlash = fullpath.find_first_of(sepPath);
1536 if ( posFirstSlash != wxString::npos )
1537 {
1538 fullpath[posFirstSlash] = wxFILE_SEP_DSK;
1539
1540 // UNC paths are always absolute, right? (FIXME)
1541 fullpath.insert(posFirstSlash + 1, 1, wxFILE_SEP_PATH_DOS);
1542 }
1543 }
1544 }
1545
1546 // We separate the volume here
1547 if ( format == wxPATH_DOS || format == wxPATH_VMS )
1548 {
1549 wxString sepVol = GetVolumeSeparator(format);
1550
1551 size_t posFirstColon = fullpath.find_first_of(sepVol);
1552 if ( posFirstColon != wxString::npos )
1553 {
1554 if ( pstrVolume )
1555 {
1556 *pstrVolume = fullpath.Left(posFirstColon);
1557 }
1558
1559 // remove the volume name and the separator from the full path
1560 fullpath.erase(0, posFirstColon + sepVol.length());
1561 }
1562 }
1563
1564 // find the positions of the last dot and last path separator in the path
1565 size_t posLastDot = fullpath.find_last_of(wxFILE_SEP_EXT);
1566 size_t posLastSlash = fullpath.find_last_of(sepPath);
1567
1568 if ( (posLastDot != wxString::npos) &&
1569 ((format == wxPATH_UNIX) || (format == wxPATH_VMS)) )
1570 {
1571 if ( (posLastDot == 0) ||
1572 (fullpath[posLastDot - 1] == sepPath[0u] ) )
1573 {
1574 // under Unix and VMS, dot may be (and commonly is) the first
1575 // character of the filename, don't treat the entire filename as
1576 // extension in this case
1577 posLastDot = wxString::npos;
1578 }
1579 }
1580
1581 // if we do have a dot and a slash, check that the dot is in the name part
1582 if ( (posLastDot != wxString::npos) &&
1583 (posLastSlash != wxString::npos) &&
1584 (posLastDot < posLastSlash) )
1585 {
1586 // the dot is part of the path, not the start of the extension
1587 posLastDot = wxString::npos;
1588 }
1589
1590 // now fill in the variables provided by user
1591 if ( pstrPath )
1592 {
1593 if ( posLastSlash == wxString::npos )
1594 {
1595 // no path at all
1596 pstrPath->Empty();
1597 }
1598 else
1599 {
1600 // take everything up to the path separator but take care to make
1601 // the path equal to something like '/', not empty, for the files
1602 // immediately under root directory
1603 size_t len = posLastSlash;
1604
1605 // this rule does not apply to mac since we do not start with colons (sep)
1606 // except for relative paths
1607 if ( !len && format != wxPATH_MAC)
1608 len++;
1609
1610 *pstrPath = fullpath.Left(len);
1611
1612 // special VMS hack: remove the initial bracket
1613 if ( format == wxPATH_VMS )
1614 {
1615 if ( (*pstrPath)[0u] == _T('[') )
1616 pstrPath->erase(0, 1);
1617 }
1618 }
1619 }
1620
1621 if ( pstrName )
1622 {
1623 // take all characters starting from the one after the last slash and
1624 // up to, but excluding, the last dot
1625 size_t nStart = posLastSlash == wxString::npos ? 0 : posLastSlash + 1;
1626 size_t count;
1627 if ( posLastDot == wxString::npos )
1628 {
1629 // take all until the end
1630 count = wxString::npos;
1631 }
1632 else if ( posLastSlash == wxString::npos )
1633 {
1634 count = posLastDot;
1635 }
1636 else // have both dot and slash
1637 {
1638 count = posLastDot - posLastSlash - 1;
1639 }
1640
1641 *pstrName = fullpath.Mid(nStart, count);
1642 }
1643
1644 if ( pstrExt )
1645 {
1646 if ( posLastDot == wxString::npos )
1647 {
1648 // no extension
1649 pstrExt->Empty();
1650 }
1651 else
1652 {
1653 // take everything after the dot
1654 *pstrExt = fullpath.Mid(posLastDot + 1);
1655 }
1656 }
1657}
1658
1659/* static */
1660void wxFileName::SplitPath(const wxString& fullpath,
1661 wxString *path,
1662 wxString *name,
1663 wxString *ext,
1664 wxPathFormat format)
1665{
1666 wxString volume;
1667 SplitPath(fullpath, &volume, path, name, ext, format);
1668
1669 if ( path )
1670 {
1671 path->Prepend(wxGetVolumeString(volume, format));
1672 }
1673}
1674
1675// ----------------------------------------------------------------------------
1676// time functions
1677// ----------------------------------------------------------------------------
1678
1679#if wxUSE_DATETIME
1680
1681bool wxFileName::SetTimes(const wxDateTime *dtAccess,
1682 const wxDateTime *dtMod,
1683 const wxDateTime *dtCreate)
1684{
1685#if defined(__WIN32__)
1686 if ( IsDir() )
1687 {
1688 // VZ: please let me know how to do this if you can
1689 wxFAIL_MSG( _T("SetTimes() not implemented for the directories") );
1690 }
1691 else // file
1692 {
1693 wxFileHandle fh(GetFullPath(), wxFileHandle::Write);
1694 if ( fh.IsOk() )
1695 {
1696 FILETIME ftAccess, ftCreate, ftWrite;
1697
1698 if ( dtCreate )
1699 ConvertWxToFileTime(&ftCreate, *dtCreate);
1700 if ( dtAccess )
1701 ConvertWxToFileTime(&ftAccess, *dtAccess);
1702 if ( dtMod )
1703 ConvertWxToFileTime(&ftWrite, *dtMod);
1704
1705 if ( ::SetFileTime(fh,
1706 dtCreate ? &ftCreate : NULL,
1707 dtAccess ? &ftAccess : NULL,
1708 dtMod ? &ftWrite : NULL) )
1709 {
1710 return true;
1711 }
1712 }
1713 }
1714#elif defined(__UNIX_LIKE__) || (defined(__DOS__) && defined(__WATCOMC__))
1715 if ( !dtAccess && !dtMod )
1716 {
1717 // can't modify the creation time anyhow, don't try
1718 return true;
1719 }
1720
1721 // if dtAccess or dtMod is not specified, use the other one (which must be
1722 // non NULL because of the test above) for both times
1723 utimbuf utm;
1724 utm.actime = dtAccess ? dtAccess->GetTicks() : dtMod->GetTicks();
1725 utm.modtime = dtMod ? dtMod->GetTicks() : dtAccess->GetTicks();
1726 if ( utime(GetFullPath().fn_str(), &utm) == 0 )
1727 {
1728 return true;
1729 }
1730#else // other platform
1731#endif // platforms
1732
1733 wxLogSysError(_("Failed to modify file times for '%s'"),
1734 GetFullPath().c_str());
1735
1736 return false;
1737}
1738
1739bool wxFileName::Touch()
1740{
1741#if defined(__UNIX_LIKE__)
1742 // under Unix touching file is simple: just pass NULL to utime()
1743 if ( utime(GetFullPath().fn_str(), NULL) == 0 )
1744 {
1745 return true;
1746 }
1747
1748 wxLogSysError(_("Failed to touch the file '%s'"), GetFullPath().c_str());
1749
1750 return false;
1751#else // other platform
1752 wxDateTime dtNow = wxDateTime::Now();
1753
1754 return SetTimes(&dtNow, &dtNow, NULL /* don't change create time */);
1755#endif // platforms
1756}
1757
1758bool wxFileName::GetTimes(wxDateTime *dtAccess,
1759 wxDateTime *dtMod,
1760 wxDateTime *dtCreate) const
1761{
1762#if defined(__WIN32__)
1763 // we must use different methods for the files and directories under
1764 // Windows as CreateFile(GENERIC_READ) doesn't work for the directories and
1765 // CreateFile(FILE_FLAG_BACKUP_SEMANTICS) works -- but only under NT and
1766 // not 9x
1767 bool ok;
1768 FILETIME ftAccess, ftCreate, ftWrite;
1769 if ( IsDir() )
1770 {
1771 // implemented in msw/dir.cpp
1772 extern bool wxGetDirectoryTimes(const wxString& dirname,
1773 FILETIME *, FILETIME *, FILETIME *);
1774
1775 // we should pass the path without the trailing separator to
1776 // wxGetDirectoryTimes()
1777 ok = wxGetDirectoryTimes(GetPath(wxPATH_GET_VOLUME),
1778 &ftAccess, &ftCreate, &ftWrite);
1779 }
1780 else // file
1781 {
1782 wxFileHandle fh(GetFullPath(), wxFileHandle::Read);
1783 if ( fh.IsOk() )
1784 {
1785 ok = ::GetFileTime(fh,
1786 dtCreate ? &ftCreate : NULL,
1787 dtAccess ? &ftAccess : NULL,
1788 dtMod ? &ftWrite : NULL) != 0;
1789 }
1790 else
1791 {
1792 ok = false;
1793 }
1794 }
1795
1796 if ( ok )
1797 {
1798 if ( dtCreate )
1799 ConvertFileTimeToWx(dtCreate, ftCreate);
1800 if ( dtAccess )
1801 ConvertFileTimeToWx(dtAccess, ftAccess);
1802 if ( dtMod )
1803 ConvertFileTimeToWx(dtMod, ftWrite);
1804
1805 return true;
1806 }
1807#elif defined(__UNIX_LIKE__) || defined(__WXMAC__) || (defined(__DOS__) && defined(__WATCOMC__))
1808 wxStructStat stBuf;
1809 if ( wxStat( GetFullPath().c_str(), &stBuf) == 0 )
1810 {
1811 if ( dtAccess )
1812 dtAccess->Set(stBuf.st_atime);
1813 if ( dtMod )
1814 dtMod->Set(stBuf.st_mtime);
1815 if ( dtCreate )
1816 dtCreate->Set(stBuf.st_ctime);
1817
1818 return true;
1819 }
1820#else // other platform
1821#endif // platforms
1822
1823 wxLogSysError(_("Failed to retrieve file times for '%s'"),
1824 GetFullPath().c_str());
1825
1826 return false;
1827}
1828
1829#endif // wxUSE_DATETIME
1830
1831#ifdef __WXMAC__
1832
1833const short kMacExtensionMaxLength = 16 ;
1834class MacDefaultExtensionRecord
1835{
1836public :
1837 MacDefaultExtensionRecord()
1838 {
1839 m_ext[0] = 0 ;
1840 m_type = m_creator = NULL ;
1841 }
1842 MacDefaultExtensionRecord( const MacDefaultExtensionRecord& from )
1843 {
1844 wxStrcpy( m_ext , from.m_ext ) ;
1845 m_type = from.m_type ;
1846 m_creator = from.m_creator ;
1847 }
1848 MacDefaultExtensionRecord( const wxChar * extension , OSType type , OSType creator )
1849 {
1850 wxStrncpy( m_ext , extension , kMacExtensionMaxLength ) ;
1851 m_ext[kMacExtensionMaxLength] = 0 ;
1852 m_type = type ;
1853 m_creator = creator ;
1854 }
1855 wxChar m_ext[kMacExtensionMaxLength] ;
1856 OSType m_type ;
1857 OSType m_creator ;
1858} ;
1859
1860#include "wx/dynarray.h"
1861WX_DECLARE_OBJARRAY(MacDefaultExtensionRecord, MacDefaultExtensionArray) ;
1862
1863bool gMacDefaultExtensionsInited = false ;
1864
1865#include "wx/arrimpl.cpp"
1866
1867WX_DEFINE_EXPORTED_OBJARRAY(MacDefaultExtensionArray) ;
1868
1869MacDefaultExtensionArray gMacDefaultExtensions ;
1870
1871static void MacEnsureDefaultExtensionsLoaded()
1872{
1873 if ( !gMacDefaultExtensionsInited )
1874 {
1875
1876 // load the default extensions
1877 MacDefaultExtensionRecord defaults[1] =
1878 {
1879 MacDefaultExtensionRecord( wxT("txt") , 'TEXT' , 'ttxt' ) ,
1880
1881 } ;
1882 // we could load the pc exchange prefs here too
1883
1884 for ( size_t i = 0 ; i < WXSIZEOF( defaults ) ; ++i )
1885 {
1886 gMacDefaultExtensions.Add( defaults[i] ) ;
1887 }
1888 gMacDefaultExtensionsInited = true ;
1889 }
1890}
1891bool wxFileName::MacSetTypeAndCreator( wxUint32 type , wxUint32 creator )
1892{
1893 FInfo fndrInfo ;
1894 FSSpec spec ;
1895 wxMacFilename2FSSpec(GetFullPath(),&spec) ;
1896 OSErr err = FSpGetFInfo( &spec , &fndrInfo ) ;
1897 wxCHECK( err == noErr , false ) ;
1898
1899 fndrInfo.fdType = type ;
1900 fndrInfo.fdCreator = creator ;
1901 FSpSetFInfo( &spec , &fndrInfo ) ;
1902 return true ;
1903}
1904
1905bool wxFileName::MacGetTypeAndCreator( wxUint32 *type , wxUint32 *creator )
1906{
1907 FInfo fndrInfo ;
1908 FSSpec spec ;
1909 wxMacFilename2FSSpec(GetFullPath(),&spec) ;
1910 OSErr err = FSpGetFInfo( &spec , &fndrInfo ) ;
1911 wxCHECK( err == noErr , false ) ;
1912
1913 *type = fndrInfo.fdType ;
1914 *creator = fndrInfo.fdCreator ;
1915 return true ;
1916}
1917
1918bool wxFileName::MacSetDefaultTypeAndCreator()
1919{
1920 wxUint32 type , creator ;
1921 if ( wxFileName::MacFindDefaultTypeAndCreator(GetExt() , &type ,
1922 &creator ) )
1923 {
1924 return MacSetTypeAndCreator( type , creator ) ;
1925 }
1926 return false;
1927}
1928
1929bool wxFileName::MacFindDefaultTypeAndCreator( const wxString& ext , wxUint32 *type , wxUint32 *creator )
1930{
1931 MacEnsureDefaultExtensionsLoaded() ;
1932 wxString extl = ext.Lower() ;
1933 for( int i = gMacDefaultExtensions.Count() - 1 ; i >= 0 ; --i )
1934 {
1935 if ( gMacDefaultExtensions.Item(i).m_ext == extl )
1936 {
1937 *type = gMacDefaultExtensions.Item(i).m_type ;
1938 *creator = gMacDefaultExtensions.Item(i).m_creator ;
1939 return true ;
1940 }
1941 }
1942 return false ;
1943}
1944
1945void wxFileName::MacRegisterDefaultTypeAndCreator( const wxString& ext , wxUint32 type , wxUint32 creator )
1946{
1947 MacEnsureDefaultExtensionsLoaded() ;
1948 MacDefaultExtensionRecord rec ;
1949 rec.m_type = type ;
1950 rec.m_creator = creator ;
1951 wxStrncpy( rec.m_ext , ext.Lower().c_str() , kMacExtensionMaxLength ) ;
1952 gMacDefaultExtensions.Add( rec ) ;
1953}
1954#endif
wxWidgets (Impactor)