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