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