/[pcsx2_0.9.7]/trunk/3rdparty/wxWidgets/src/common/filefn.cpp
ViewVC logotype

Annotation of /trunk/3rdparty/wxWidgets/src/common/filefn.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 31 - (hide annotations) (download)
Tue Sep 7 03:24:11 2010 UTC (10 years, 4 months ago) by william
File size: 58094 byte(s)
committing r3113 initial commit again...
1 william 31 /////////////////////////////////////////////////////////////////////////////
2     // Name: src/common/filefn.cpp
3     // Purpose: File- and directory-related functions
4     // Author: Julian Smart
5     // Modified by:
6     // Created: 29/01/98
7     // RCS-ID: $Id: filefn.cpp 58220 2009-01-19 11:40:24Z VZ $
8     // Copyright: (c) 1998 Julian Smart
9     // Licence: wxWindows licence
10     /////////////////////////////////////////////////////////////////////////////
11    
12     // ============================================================================
13     // declarations
14     // ============================================================================
15    
16     // ----------------------------------------------------------------------------
17     // headers
18     // ----------------------------------------------------------------------------
19    
20     // For compilers that support precompilation, includes "wx.h".
21     #include "wx/wxprec.h"
22    
23     #ifdef __BORLANDC__
24     #pragma hdrstop
25     #endif
26    
27     #include "wx/filefn.h"
28    
29     #ifndef WX_PRECOMP
30     #include "wx/intl.h"
31     #include "wx/log.h"
32     #include "wx/utils.h"
33     #endif
34    
35     #include "wx/file.h"
36     #include "wx/filename.h"
37     #include "wx/dir.h"
38    
39     #include "wx/tokenzr.h"
40    
41     // there are just too many of those...
42     #ifdef __VISUALC__
43     #pragma warning(disable:4706) // assignment within conditional expression
44     #endif // VC++
45    
46     #include <ctype.h>
47     #include <stdio.h>
48     #include <stdlib.h>
49     #include <string.h>
50     #if !wxONLY_WATCOM_EARLIER_THAN(1,4)
51     #if !(defined(_MSC_VER) && (_MSC_VER > 800))
52     #include <errno.h>
53     #endif
54     #endif
55    
56     #if defined(__WXMAC__)
57     #include "wx/mac/private.h" // includes mac headers
58     #endif
59    
60     #ifdef __WINDOWS__
61     #include "wx/msw/private.h"
62     #include "wx/msw/mslu.h"
63    
64     // sys/cygwin.h is needed for cygwin_conv_to_full_win32_path()
65     //
66     // note that it must be included after <windows.h>
67     #ifdef __GNUWIN32__
68     #ifdef __CYGWIN__
69     #include <sys/cygwin.h>
70     #endif
71     #endif // __GNUWIN32__
72    
73     // io.h is needed for _get_osfhandle()
74     // Already included by filefn.h for many Windows compilers
75     #if defined __MWERKS__ || defined __CYGWIN__
76     #include <io.h>
77     #endif
78     #endif // __WINDOWS__
79    
80     #if defined(__VMS__)
81     #include <fab.h>
82     #endif
83    
84     // TODO: Borland probably has _wgetcwd as well?
85     #ifdef _MSC_VER
86     #define HAVE_WGETCWD
87     #endif
88    
89     // ----------------------------------------------------------------------------
90     // constants
91     // ----------------------------------------------------------------------------
92    
93     #ifndef _MAXPATHLEN
94     #define _MAXPATHLEN 1024
95     #endif
96    
97     #ifdef __WXMAC__
98     # include "MoreFilesX.h"
99     #endif
100    
101     // ----------------------------------------------------------------------------
102     // private globals
103     // ----------------------------------------------------------------------------
104    
105     // MT-FIXME: get rid of this horror and all code using it
106     static wxChar wxFileFunctionsBuffer[4*_MAXPATHLEN];
107    
108     #if defined(__VISAGECPP__) && __IBMCPP__ >= 400
109     //
110     // VisualAge C++ V4.0 cannot have any external linkage const decs
111     // in headers included by more than one primary source
112     //
113     const int wxInvalidOffset = -1;
114     #endif
115    
116     // ----------------------------------------------------------------------------
117     // macros
118     // ----------------------------------------------------------------------------
119    
120     // translate the filenames before passing them to OS functions
121     #define OS_FILENAME(s) (s.fn_str())
122    
123     // ============================================================================
124     // implementation
125     // ============================================================================
126    
127     // ----------------------------------------------------------------------------
128     // wrappers around standard POSIX functions
129     // ----------------------------------------------------------------------------
130    
131     #ifdef wxNEED_WX_UNISTD_H
132    
133     WXDLLEXPORT int wxStat( const wxChar *file_name, wxStructStat *buf )
134     {
135     return stat( wxConvFile.cWX2MB( file_name ), buf );
136     }
137    
138     WXDLLEXPORT int wxLstat( const wxChar *file_name, wxStructStat *buf )
139     {
140     return lstat( wxConvFile.cWX2MB( file_name ), buf );
141     }
142    
143     WXDLLEXPORT int wxAccess( const wxChar *pathname, int mode )
144     {
145     return access( wxConvFile.cWX2MB( pathname ), mode );
146     }
147    
148     WXDLLEXPORT int wxOpen( const wxChar *pathname, int flags, mode_t mode )
149     {
150     return open( wxConvFile.cWX2MB( pathname ), flags, mode );
151     }
152    
153     #endif // wxNEED_WX_UNISTD_H
154    
155     #if wxUSE_UNICODE && defined __BORLANDC__ \
156     && __BORLANDC__ >= 0x550 && __BORLANDC__ <= 0x551
157    
158     // BCC 5.5 and 5.5.1 have a bug in _wopen where files are created read only
159     // regardless of the mode parameter. This hack works around the problem by
160     // setting the mode with _wchmod.
161     //
162     int wxOpen(const wchar_t *pathname, int flags, mode_t mode)
163     {
164     int moreflags = 0;
165    
166     // we only want to fix the mode when the file is actually created, so
167     // when creating first try doing it O_EXCL so we can tell if the file
168     // was already there.
169     if ((flags & O_CREAT) && !(flags & O_EXCL) && (mode & wxS_IWUSR) != 0)
170     moreflags = O_EXCL;
171    
172     int fd = _wopen(pathname, flags | moreflags, mode);
173    
174     // the file was actually created and needs fixing
175     if (fd != -1 && (flags & O_CREAT) != 0 && (mode & wxS_IWUSR) != 0)
176     {
177     close(fd);
178     _wchmod(pathname, mode);
179     fd = _wopen(pathname, flags & ~(O_EXCL | O_CREAT));
180     }
181     // the open failed, but it may have been because the added O_EXCL stopped
182     // the opening of an existing file, so try again without.
183     else if (fd == -1 && moreflags != 0)
184     {
185     fd = _wopen(pathname, flags & ~O_CREAT);
186     }
187    
188     return fd;
189     }
190    
191     #endif
192    
193     // ----------------------------------------------------------------------------
194     // wxPathList
195     // ----------------------------------------------------------------------------
196    
197     bool wxPathList::Add(const wxString& path)
198     {
199     // add a path separator to force wxFileName to interpret it always as a directory
200     // (i.e. if we are called with '/home/user' we want to consider it a folder and
201     // not, as wxFileName would consider, a filename).
202     wxFileName fn(path + wxFileName::GetPathSeparator());
203    
204     // add only normalized relative/absolute paths
205     // NB: we won't do wxPATH_NORM_DOTS in order to avoid problems when trying to
206     // normalize paths which starts with ".." (which can be normalized only if
207     // we use also wxPATH_NORM_ABSOLUTE - which we don't want to use).
208     if (!fn.Normalize(wxPATH_NORM_TILDE|wxPATH_NORM_LONG|wxPATH_NORM_ENV_VARS))
209     return false;
210    
211     wxString toadd = fn.GetPath();
212     if (Index(toadd) == wxNOT_FOUND)
213     wxArrayString::Add(toadd); // do not add duplicates
214    
215     return true;
216     }
217    
218     void wxPathList::Add(const wxArrayString &arr)
219     {
220     for (size_t j=0; j < arr.GetCount(); j++)
221     Add(arr[j]);
222     }
223    
224     // Add paths e.g. from the PATH environment variable
225     void wxPathList::AddEnvList (const wxString& WXUNUSED_IN_WINCE(envVariable))
226     {
227     // No environment variables on WinCE
228     #ifndef __WXWINCE__
229    
230     // The space has been removed from the tokenizers, otherwise a
231     // path such as "C:\Program Files" would be split into 2 paths:
232     // "C:\Program" and "Files"; this is true for both Windows and Unix.
233    
234     static const wxChar PATH_TOKS[] =
235     #if defined(__WINDOWS__) || defined(__OS2__)
236     wxT(";"); // Don't separate with colon in DOS (used for drive)
237     #else
238     wxT(":;");
239     #endif
240    
241     wxString val;
242     if ( wxGetEnv(envVariable, &val) )
243     {
244     // split into an array of string the value of the env var
245     wxArrayString arr = wxStringTokenize(val, PATH_TOKS);
246     WX_APPEND_ARRAY(*this, arr);
247     }
248     #endif // !__WXWINCE__
249     }
250    
251     // Given a full filename (with path), ensure that that file can
252     // be accessed again USING FILENAME ONLY by adding the path
253     // to the list if not already there.
254     bool wxPathList::EnsureFileAccessible (const wxString& path)
255     {
256     return Add(wxPathOnly(path));
257     }
258    
259     #if WXWIN_COMPATIBILITY_2_6
260     bool wxPathList::Member (const wxString& path) const
261     {
262     return Index(path) != wxNOT_FOUND;
263     }
264     #endif
265    
266     wxString wxPathList::FindValidPath (const wxString& file) const
267     {
268     // normalize the given string as it could be a path + a filename
269     // and not only a filename
270     wxFileName fn(file);
271     wxString strend;
272    
273     // NB: normalize without making absolute otherwise calling this function with
274     // e.g. "b/c.txt" would result in removing the directory 'b' and the for loop
275     // below would only add to the paths of this list the 'c.txt' part when doing
276     // the existence checks...
277     // NB: we don't use wxPATH_NORM_DOTS here, too (see wxPathList::Add for more info)
278     if (!fn.Normalize(wxPATH_NORM_TILDE|wxPATH_NORM_LONG|wxPATH_NORM_ENV_VARS))
279     return wxEmptyString;
280    
281     wxASSERT_MSG(!fn.IsDir(), wxT("Cannot search for directories; only for files"));
282     if (fn.IsAbsolute())
283     strend = fn.GetFullName(); // search for the file name and ignore the path part
284     else
285     strend = fn.GetFullPath();
286    
287     for (size_t i=0; i<GetCount(); i++)
288     {
289     wxString strstart = Item(i);
290     if (!strstart.IsEmpty() && strstart.Last() != wxFileName::GetPathSeparator())
291     strstart += wxFileName::GetPathSeparator();
292    
293     if (wxFileExists(strstart + strend))
294     return strstart + strend; // Found!
295     }
296    
297     return wxEmptyString; // Not found
298     }
299    
300     wxString wxPathList::FindAbsoluteValidPath (const wxString& file) const
301     {
302     wxString f = FindValidPath(file);
303     if ( f.empty() || wxIsAbsolutePath(f) )
304     return f;
305    
306     wxString buf = ::wxGetCwd();
307    
308     if ( !wxEndsWithPathSeparator(buf) )
309     {
310     buf += wxFILE_SEP_PATH;
311     }
312     buf += f;
313    
314     return buf;
315     }
316    
317     // ----------------------------------------------------------------------------
318     // miscellaneous global functions (TOFIX!)
319     // ----------------------------------------------------------------------------
320    
321     static inline wxChar* MYcopystring(const wxString& s)
322     {
323     wxChar* copy = new wxChar[s.length() + 1];
324     return wxStrcpy(copy, s.c_str());
325     }
326    
327     static inline wxChar* MYcopystring(const wxChar* s)
328     {
329     wxChar* copy = new wxChar[wxStrlen(s) + 1];
330     return wxStrcpy(copy, s);
331     }
332    
333    
334     bool
335     wxFileExists (const wxString& filename)
336     {
337     #if defined(__WXPALMOS__)
338     return false;
339     #elif defined(__WIN32__) && !defined(__WXMICROWIN__)
340     // we must use GetFileAttributes() instead of the ANSI C functions because
341     // it can cope with network (UNC) paths unlike them
342     DWORD ret = ::GetFileAttributes(filename);
343    
344     return (ret != (DWORD)-1) && !(ret & FILE_ATTRIBUTE_DIRECTORY);
345     #else // !__WIN32__
346     #ifndef S_ISREG
347     #define S_ISREG(mode) ((mode) & S_IFREG)
348     #endif
349     wxStructStat st;
350     #ifndef wxNEED_WX_UNISTD_H
351     return (wxStat( filename.fn_str() , &st) == 0 && S_ISREG(st.st_mode))
352     #ifdef __OS2__
353     || (errno == EACCES) // if access is denied something with that name
354     // exists and is opened in exclusive mode.
355     #endif
356     ;
357     #else
358     return wxStat( filename , &st) == 0 && S_ISREG(st.st_mode);
359     #endif
360     #endif // __WIN32__/!__WIN32__
361     }
362    
363     bool
364     wxIsAbsolutePath (const wxString& filename)
365     {
366     if (!filename.empty())
367     {
368     #if defined(__WXMAC__) && !defined(__DARWIN__)
369     // Classic or Carbon CodeWarrior like
370     // Carbon with Apple DevTools is Unix like
371    
372     // This seems wrong to me, but there is no fix. since
373     // "MacOS:MyText.txt" is absolute whereas "MyDir:MyText.txt"
374     // is not. Or maybe ":MyDir:MyText.txt" has to be used? RR.
375     if (filename.Find(':') != wxNOT_FOUND && filename[0] != ':')
376     return true ;
377     #else
378     // Unix like or Windows
379     if (filename[0] == wxT('/'))
380     return true;
381     #endif
382     #ifdef __VMS__
383     if ((filename[0] == wxT('[') && filename[1] != wxT('.')))
384     return true;
385     #endif
386     #if defined(__WINDOWS__) || defined(__OS2__)
387     // MSDOS like
388     if (filename[0] == wxT('\\') || (wxIsalpha (filename[0]) && filename[1] == wxT(':')))
389     return true;
390     #endif
391     }
392     return false ;
393     }
394    
395     /*
396     * Strip off any extension (dot something) from end of file,
397     * IF one exists. Inserts zero into buffer.
398     *
399     */
400    
401     void wxStripExtension(wxChar *buffer)
402     {
403     int len = wxStrlen(buffer);
404     int i = len-1;
405     while (i > 0)
406     {
407     if (buffer[i] == wxT('.'))
408     {
409     buffer[i] = 0;
410     break;
411     }
412     i --;
413     }
414     }
415    
416     void wxStripExtension(wxString& buffer)
417     {
418     //RN: Be careful about the handling the case where
419     //buffer.length() == 0
420     for(size_t i = buffer.length() - 1; i != wxString::npos; --i)
421     {
422     if (buffer.GetChar(i) == wxT('.'))
423     {
424     buffer = buffer.Left(i);
425     break;
426     }
427     }
428     }
429    
430     // Destructive removal of /./ and /../ stuff
431     wxChar *wxRealPath (wxChar *path)
432     {
433     #ifdef __WXMSW__
434     static const wxChar SEP = wxT('\\');
435     wxUnix2DosFilename(path);
436     #else
437     static const wxChar SEP = wxT('/');
438     #endif
439     if (path[0] && path[1]) {
440     /* MATTHEW: special case "/./x" */
441     wxChar *p;
442     if (path[2] == SEP && path[1] == wxT('.'))
443     p = &path[0];
444     else
445     p = &path[2];
446     for (; *p; p++)
447     {
448     if (*p == SEP)
449     {
450     if (p[1] == wxT('.') && p[2] == wxT('.') && (p[3] == SEP || p[3] == wxT('\0')))
451     {
452     wxChar *q;
453     for (q = p - 1; q >= path && *q != SEP; q--)
454     {
455     // Empty
456     }
457    
458     if (q[0] == SEP && (q[1] != wxT('.') || q[2] != wxT('.') || q[3] != SEP)
459     && (q - 1 <= path || q[-1] != SEP))
460     {
461     wxStrcpy (q, p + 3);
462     if (path[0] == wxT('\0'))
463     {
464     path[0] = SEP;
465     path[1] = wxT('\0');
466     }
467     #if defined(__WXMSW__) || defined(__OS2__)
468     /* Check that path[2] is NULL! */
469     else if (path[1] == wxT(':') && !path[2])
470     {
471     path[2] = SEP;
472     path[3] = wxT('\0');
473     }
474     #endif
475     p = q - 1;
476     }
477     }
478     else if (p[1] == wxT('.') && (p[2] == SEP || p[2] == wxT('\0')))
479     wxStrcpy (p, p + 2);
480     }
481     }
482     }
483     return path;
484     }
485    
486     wxString wxRealPath(const wxString& path)
487     {
488     wxChar *buf1=MYcopystring(path);
489     wxChar *buf2=wxRealPath(buf1);
490     wxString buf(buf2);
491     delete [] buf1;
492     return buf;
493     }
494    
495    
496     // Must be destroyed
497     wxChar *wxCopyAbsolutePath(const wxString& filename)
498     {
499     if (filename.empty())
500     return (wxChar *) NULL;
501    
502     if (! wxIsAbsolutePath(wxExpandPath(wxFileFunctionsBuffer, filename)))
503     {
504     wxString buf = ::wxGetCwd();
505     wxChar ch = buf.Last();
506     #ifdef __WXMSW__
507     if (ch != wxT('\\') && ch != wxT('/'))
508     buf << wxT("\\");
509     #else
510     if (ch != wxT('/'))
511     buf << wxT("/");
512     #endif
513     buf << wxFileFunctionsBuffer;
514     buf = wxRealPath( buf );
515     return MYcopystring( buf );
516     }
517     return MYcopystring( wxFileFunctionsBuffer );
518     }
519    
520     /*-
521     Handles:
522     ~/ => home dir
523     ~user/ => user's home dir
524     If the environment variable a = "foo" and b = "bar" then:
525     Unix:
526     $a => foo
527     $a$b => foobar
528     $a.c => foo.c
529     xxx$a => xxxfoo
530     ${a}! => foo!
531     $(b)! => bar!
532     \$a => \$a
533     MSDOS:
534     $a ==> $a
535     $(a) ==> foo
536     $(a)$b ==> foo$b
537     $(a)$(b)==> foobar
538     test.$$ ==> test.$$
539     */
540    
541     /* input name in name, pathname output to buf. */
542    
543     wxChar *wxExpandPath(wxChar *buf, const wxChar *name)
544     {
545     register wxChar *d, *s, *nm;
546     wxChar lnm[_MAXPATHLEN];
547     int q;
548    
549     // Some compilers don't like this line.
550     // const wxChar trimchars[] = wxT("\n \t");
551    
552     wxChar trimchars[4];
553     trimchars[0] = wxT('\n');
554     trimchars[1] = wxT(' ');
555     trimchars[2] = wxT('\t');
556     trimchars[3] = 0;
557    
558     #ifdef __WXMSW__
559     const wxChar SEP = wxT('\\');
560     #else
561     const wxChar SEP = wxT('/');
562     #endif
563     buf[0] = wxT('\0');
564     if (name == NULL || *name == wxT('\0'))
565     return buf;
566     nm = MYcopystring(name); // Make a scratch copy
567     wxChar *nm_tmp = nm;
568    
569     /* Skip leading whitespace and cr */
570     while (wxStrchr((wxChar *)trimchars, *nm) != NULL)
571     nm++;
572     /* And strip off trailing whitespace and cr */
573     s = nm + (q = wxStrlen(nm)) - 1;
574     while (q-- && wxStrchr((wxChar *)trimchars, *s) != NULL)
575     *s = wxT('\0');
576    
577     s = nm;
578     d = lnm;
579     #ifdef __WXMSW__
580     q = FALSE;
581     #else
582     q = nm[0] == wxT('\\') && nm[1] == wxT('~');
583     #endif
584    
585     /* Expand inline environment variables */
586     #ifdef __VISAGECPP__
587     while (*d)
588     {
589     *d++ = *s;
590     if(*s == wxT('\\'))
591     {
592     *(d - 1) = *++s;
593     if (*d)
594     {
595     s++;
596     continue;
597     }
598     else
599     break;
600     }
601     else
602     #else
603     while ((*d++ = *s) != 0) {
604     # ifndef __WXMSW__
605     if (*s == wxT('\\')) {
606     if ((*(d - 1) = *++s)!=0) {
607     s++;
608     continue;
609     } else
610     break;
611     } else
612     # endif
613     #endif
614     // No env variables on WinCE
615     #ifndef __WXWINCE__
616     #ifdef __WXMSW__
617     if (*s++ == wxT('$') && (*s == wxT('{') || *s == wxT(')')))
618     #else
619     if (*s++ == wxT('$'))
620     #endif
621     {
622     register wxChar *start = d;
623     register int braces = (*s == wxT('{') || *s == wxT('('));
624     register wxChar *value;
625     while ((*d++ = *s) != 0)
626     if (braces ? (*s == wxT('}') || *s == wxT(')')) : !(wxIsalnum(*s) || *s == wxT('_')) )
627     break;
628     else
629     s++;
630     *--d = 0;
631     value = wxGetenv(braces ? start + 1 : start);
632     if (value) {
633     for ((d = start - 1); (*d++ = *value++) != 0;)
634     {
635     // Empty
636     }
637    
638     d--;
639     if (braces && *s)
640     s++;
641     }
642     }
643     #endif
644     // __WXWINCE__
645     }
646    
647     /* Expand ~ and ~user */
648     nm = lnm;
649     if (nm[0] == wxT('~') && !q)
650     {
651     /* prefix ~ */
652     if (nm[1] == SEP || nm[1] == 0)
653     { /* ~/filename */
654     // FIXME: wxGetUserHome could return temporary storage in Unicode mode
655     if ((s = WXSTRINGCAST wxGetUserHome(wxEmptyString)) != NULL) {
656     if (*++nm)
657     nm++;
658     }
659     } else
660     { /* ~user/filename */
661     register wxChar *nnm;
662     register wxChar *home;
663     for (s = nm; *s && *s != SEP; s++)
664     {
665     // Empty
666     }
667     int was_sep; /* MATTHEW: Was there a separator, or NULL? */
668     was_sep = (*s == SEP);
669     nnm = *s ? s + 1 : s;
670     *s = 0;
671     // FIXME: wxGetUserHome could return temporary storage in Unicode mode
672     if ((home = WXSTRINGCAST wxGetUserHome(wxString(nm + 1))) == NULL)
673     {
674     if (was_sep) /* replace only if it was there: */
675     *s = SEP;
676     s = NULL;
677     }
678     else
679     {
680     nm = nnm;
681     s = home;
682     }
683     }
684     }
685    
686     d = buf;
687     if (s && *s) { /* MATTHEW: s could be NULL if user '~' didn't exist */
688     /* Copy home dir */
689     while (wxT('\0') != (*d++ = *s++))
690     /* loop */;
691     // Handle root home
692     if (d - 1 > buf && *(d - 2) != SEP)
693     *(d - 1) = SEP;
694     }
695     s = nm;
696     while ((*d++ = *s++) != 0)
697     {
698     // Empty
699     }
700     delete[] nm_tmp; // clean up alloc
701     /* Now clean up the buffer */
702     return wxRealPath(buf);
703     }
704    
705     /* Contract Paths to be build upon an environment variable
706     component:
707    
708     example: "/usr/openwin/lib", OPENWINHOME --> ${OPENWINHOME}/lib
709    
710     The call wxExpandPath can convert these back!
711     */
712     wxChar *
713     wxContractPath (const wxString& filename,
714     const wxString& WXUNUSED_IN_WINCE(envname),
715     const wxString& user)
716     {
717     static wxChar dest[_MAXPATHLEN];
718    
719     if (filename.empty())
720     return (wxChar *) NULL;
721    
722     wxStrcpy (dest, WXSTRINGCAST filename);
723     #ifdef __WXMSW__
724     wxUnix2DosFilename(dest);
725     #endif
726    
727     // Handle environment
728     const wxChar *val;
729     #ifndef __WXWINCE__
730     wxChar *tcp;
731     if (!envname.empty() && (val = wxGetenv (WXSTRINGCAST envname)) != NULL &&
732     (tcp = wxStrstr (dest, val)) != NULL)
733     {
734     wxStrcpy (wxFileFunctionsBuffer, tcp + wxStrlen (val));
735     *tcp++ = wxT('$');
736     *tcp++ = wxT('{');
737     wxStrcpy (tcp, WXSTRINGCAST envname);
738     wxStrcat (tcp, wxT("}"));
739     wxStrcat (tcp, wxFileFunctionsBuffer);
740     }
741     #endif
742    
743     // Handle User's home (ignore root homes!)
744     val = wxGetUserHome (user);
745     if (!val)
746     return dest;
747    
748     const size_t len = wxStrlen(val);
749     if (len <= 2)
750     return dest;
751    
752     if (wxStrncmp(dest, val, len) == 0)
753     {
754     wxStrcpy(wxFileFunctionsBuffer, wxT("~"));
755     if (!user.empty())
756     wxStrcat(wxFileFunctionsBuffer, (const wxChar*) user);
757     wxStrcat(wxFileFunctionsBuffer, dest + len);
758     wxStrcpy (dest, wxFileFunctionsBuffer);
759     }
760    
761     return dest;
762     }
763    
764     // Return just the filename, not the path (basename)
765     wxChar *wxFileNameFromPath (wxChar *path)
766     {
767     wxString p = path;
768     wxString n = wxFileNameFromPath(p);
769    
770     return path + p.length() - n.length();
771     }
772    
773     wxString wxFileNameFromPath (const wxString& path)
774     {
775     wxString name, ext;
776     wxFileName::SplitPath(path, NULL, &name, &ext);
777    
778     wxString fullname = name;
779     if ( !ext.empty() )
780     {
781     fullname << wxFILE_SEP_EXT << ext;
782     }
783    
784     return fullname;
785     }
786    
787     // Return just the directory, or NULL if no directory
788     wxChar *
789     wxPathOnly (wxChar *path)
790     {
791     if (path && *path)
792     {
793     static wxChar buf[_MAXPATHLEN];
794    
795     // Local copy
796     wxStrcpy (buf, path);
797    
798     int l = wxStrlen(path);
799     int i = l - 1;
800    
801     // Search backward for a backward or forward slash
802     while (i > -1)
803     {
804     #if defined(__WXMAC__) && !defined(__DARWIN__)
805     // Classic or Carbon CodeWarrior like
806     // Carbon with Apple DevTools is Unix like
807     if (path[i] == wxT(':') )
808     {
809     buf[i] = 0;
810     return buf;
811     }
812     #else
813     // Unix like or Windows
814     if (path[i] == wxT('/') || path[i] == wxT('\\'))
815     {
816     buf[i] = 0;
817     return buf;
818     }
819     #endif
820     #ifdef __VMS__
821     if (path[i] == wxT(']'))
822     {
823     buf[i+1] = 0;
824     return buf;
825     }
826     #endif
827     i --;
828     }
829    
830     #if defined(__WXMSW__) || defined(__OS2__)
831     // Try Drive specifier
832     if (wxIsalpha (buf[0]) && buf[1] == wxT(':'))
833     {
834     // A:junk --> A:. (since A:.\junk Not A:\junk)
835     buf[2] = wxT('.');
836     buf[3] = wxT('\0');
837     return buf;
838     }
839     #endif
840     }
841     return (wxChar *) NULL;
842     }
843    
844     // Return just the directory, or NULL if no directory
845     wxString wxPathOnly (const wxString& path)
846     {
847     if (!path.empty())
848     {
849     wxChar buf[_MAXPATHLEN];
850    
851     // Local copy
852     wxStrcpy (buf, WXSTRINGCAST path);
853    
854     int l = path.length();
855     int i = l - 1;
856    
857     // Search backward for a backward or forward slash
858     while (i > -1)
859     {
860     #if defined(__WXMAC__) && !defined(__DARWIN__)
861     // Classic or Carbon CodeWarrior like
862     // Carbon with Apple DevTools is Unix like
863     if (path[i] == wxT(':') )
864     {
865     buf[i] = 0;
866     return wxString(buf);
867     }
868     #else
869     // Unix like or Windows
870     if (path[i] == wxT('/') || path[i] == wxT('\\'))
871     {
872     // Don't return an empty string
873     if (i == 0)
874     i ++;
875     buf[i] = 0;
876     return wxString(buf);
877     }
878     #endif
879     #ifdef __VMS__
880     if (path[i] == wxT(']'))
881     {
882     buf[i+1] = 0;
883     return wxString(buf);
884     }
885     #endif
886     i --;
887     }
888    
889     #if defined(__WXMSW__) || defined(__OS2__)
890     // Try Drive specifier
891     if (wxIsalpha (buf[0]) && buf[1] == wxT(':'))
892     {
893     // A:junk --> A:. (since A:.\junk Not A:\junk)
894     buf[2] = wxT('.');
895     buf[3] = wxT('\0');
896     return wxString(buf);
897     }
898     #endif
899     }
900     return wxEmptyString;
901     }
902    
903     // Utility for converting delimiters in DOS filenames to UNIX style
904     // and back again - or we get nasty problems with delimiters.
905     // Also, convert to lower case, since case is significant in UNIX.
906    
907     #if defined(__WXMAC__)
908    
909     #if TARGET_API_MAC_OSX
910     #define kDefaultPathStyle kCFURLPOSIXPathStyle
911     #else
912     #define kDefaultPathStyle kCFURLHFSPathStyle
913     #endif
914    
915     wxString wxMacFSRefToPath( const FSRef *fsRef , CFStringRef additionalPathComponent )
916     {
917     CFURLRef fullURLRef;
918     fullURLRef = CFURLCreateFromFSRef(NULL, fsRef);
919     if ( additionalPathComponent )
920     {
921     CFURLRef parentURLRef = fullURLRef ;
922     fullURLRef = CFURLCreateCopyAppendingPathComponent(NULL, parentURLRef,
923     additionalPathComponent,false);
924     CFRelease( parentURLRef ) ;
925     }
926     CFStringRef cfString = CFURLCopyFileSystemPath(fullURLRef, kDefaultPathStyle);
927     CFRelease( fullURLRef ) ;
928     CFMutableStringRef cfMutableString = CFStringCreateMutableCopy(NULL, 0, cfString);
929     CFRelease( cfString );
930     CFStringNormalize(cfMutableString,kCFStringNormalizationFormC);
931     return wxMacCFStringHolder(cfMutableString).AsString();
932     }
933    
934     OSStatus wxMacPathToFSRef( const wxString&path , FSRef *fsRef )
935     {
936     OSStatus err = noErr ;
937     CFMutableStringRef cfMutableString = CFStringCreateMutableCopy(NULL, 0, wxMacCFStringHolder(path));
938     CFStringNormalize(cfMutableString,kCFStringNormalizationFormD);
939     CFURLRef url = CFURLCreateWithFileSystemPath(kCFAllocatorDefault, cfMutableString , kDefaultPathStyle, false);
940     CFRelease( cfMutableString );
941     if ( NULL != url )
942     {
943     if ( CFURLGetFSRef(url, fsRef) == false )
944     err = fnfErr ;
945     CFRelease( url ) ;
946     }
947     else
948     {
949     err = fnfErr ;
950     }
951     return err ;
952     }
953    
954     wxString wxMacHFSUniStrToString( ConstHFSUniStr255Param uniname )
955     {
956     CFStringRef cfname = CFStringCreateWithCharacters( kCFAllocatorDefault,
957     uniname->unicode,
958     uniname->length );
959     CFMutableStringRef cfMutableString = CFStringCreateMutableCopy(NULL, 0, cfname);
960     CFRelease( cfname );
961     CFStringNormalize(cfMutableString,kCFStringNormalizationFormC);
962     return wxMacCFStringHolder(cfMutableString).AsString() ;
963     }
964    
965     #ifndef __LP64__
966    
967     wxString wxMacFSSpec2MacFilename( const FSSpec *spec )
968     {
969     FSRef fsRef ;
970     if ( FSpMakeFSRef( spec , &fsRef) == noErr )
971     {
972     return wxMacFSRefToPath( &fsRef ) ;
973     }
974     return wxEmptyString ;
975     }
976    
977     void wxMacFilename2FSSpec( const wxString& path , FSSpec *spec )
978     {
979     OSStatus err = noErr ;
980     FSRef fsRef ;
981     wxMacPathToFSRef( path , &fsRef ) ;
982     err = FSRefMakeFSSpec( &fsRef , spec ) ;
983     }
984     #endif
985    
986     #endif // __WXMAC__
987    
988     void
989     wxDos2UnixFilename (wxChar *s)
990     {
991     if (s)
992     while (*s)
993     {
994     if (*s == _T('\\'))
995     *s = _T('/');
996     #ifdef __WXMSW__
997     else
998     *s = (wxChar)wxTolower (*s); // Case INDEPENDENT
999     #endif
1000     s++;
1001     }
1002     }
1003    
1004     void
1005     #if defined(__WXMSW__) || defined(__OS2__)
1006     wxUnix2DosFilename (wxChar *s)
1007     #else
1008     wxUnix2DosFilename (wxChar *WXUNUSED(s) )
1009     #endif
1010     {
1011     // Yes, I really mean this to happen under DOS only! JACS
1012     #if defined(__WXMSW__) || defined(__OS2__)
1013     if (s)
1014     while (*s)
1015     {
1016     if (*s == wxT('/'))
1017     *s = wxT('\\');
1018     s++;
1019     }
1020     #endif
1021     }
1022    
1023     // Concatenate two files to form third
1024     bool
1025     wxConcatFiles (const wxString& file1, const wxString& file2, const wxString& file3)
1026     {
1027     #if wxUSE_FILE
1028    
1029     wxFile in1(file1), in2(file2);
1030     wxTempFile out(file3);
1031    
1032     if ( !in1.IsOpened() || !in2.IsOpened() || !out.IsOpened() )
1033     return false;
1034    
1035     ssize_t ofs;
1036     unsigned char buf[1024];
1037    
1038     for( int i=0; i<2; i++)
1039     {
1040     wxFile *in = i==0 ? &in1 : &in2;
1041     do{
1042     if ( (ofs = in->Read(buf,WXSIZEOF(buf))) == wxInvalidOffset ) return false;
1043     if ( ofs > 0 )
1044     if ( !out.Write(buf,ofs) )
1045     return false;
1046     } while ( ofs == (ssize_t)WXSIZEOF(buf) );
1047     }
1048    
1049     return out.Commit();
1050    
1051     #else
1052    
1053     wxUnusedVar(file1);
1054     wxUnusedVar(file2);
1055     wxUnusedVar(file3);
1056     return false;
1057    
1058     #endif
1059     }
1060    
1061     // Copy files
1062     bool
1063     wxCopyFile (const wxString& file1, const wxString& file2, bool overwrite)
1064     {
1065     #if defined(__WIN32__) && !defined(__WXMICROWIN__)
1066     // CopyFile() copies file attributes and modification time too, so use it
1067     // instead of our code if available
1068     //
1069     // NB: 3rd parameter is bFailIfExists i.e. the inverse of overwrite
1070     if ( !::CopyFile(file1, file2, !overwrite) )
1071     {
1072     wxLogSysError(_("Failed to copy the file '%s' to '%s'"),
1073     file1.c_str(), file2.c_str());
1074    
1075     return false;
1076     }
1077     #elif defined(__OS2__)
1078     if ( ::DosCopy((PSZ)file1.c_str(), (PSZ)file2.c_str(), overwrite ? DCPY_EXISTING : 0) != 0 )
1079     return false;
1080     #elif defined(__PALMOS__)
1081     // TODO with http://www.palmos.com/dev/support/docs/protein_books/Memory_Databases_Files/
1082     return false;
1083     #elif wxUSE_FILE // !Win32
1084    
1085     wxStructStat fbuf;
1086     // get permissions of file1
1087     if ( wxStat( file1.c_str(), &fbuf) != 0 )
1088     {
1089     // the file probably doesn't exist or we haven't the rights to read
1090     // from it anyhow
1091     wxLogSysError(_("Impossible to get permissions for file '%s'"),
1092     file1.c_str());
1093     return false;
1094     }
1095    
1096     // open file1 for reading
1097     wxFile fileIn(file1, wxFile::read);
1098     if ( !fileIn.IsOpened() )
1099     return false;
1100    
1101     // remove file2, if it exists. This is needed for creating
1102     // file2 with the correct permissions in the next step
1103     if ( wxFileExists(file2) && (!overwrite || !wxRemoveFile(file2)))
1104     {
1105     wxLogSysError(_("Impossible to overwrite the file '%s'"),
1106     file2.c_str());
1107     return false;
1108     }
1109    
1110     // reset the umask as we want to create the file with exactly the same
1111     // permissions as the original one
1112     wxCHANGE_UMASK(0);
1113    
1114     // create file2 with the same permissions than file1 and open it for
1115     // writing
1116    
1117     wxFile fileOut;
1118     if ( !fileOut.Create(file2, overwrite, fbuf.st_mode & 0777) )
1119     return false;
1120    
1121     // copy contents of file1 to file2
1122     char buf[4096];
1123     size_t count;
1124     for ( ;; )
1125     {
1126     count = fileIn.Read(buf, WXSIZEOF(buf));
1127     if ( fileIn.Error() )
1128     return false;
1129    
1130     // end of file?
1131     if ( !count )
1132     break;
1133    
1134     if ( fileOut.Write(buf, count) < count )
1135     return false;
1136     }
1137    
1138     // we can expect fileIn to be closed successfully, but we should ensure
1139     // that fileOut was closed as some write errors (disk full) might not be
1140     // detected before doing this
1141     if ( !fileIn.Close() || !fileOut.Close() )
1142     return false;
1143    
1144     #if !defined(__VISAGECPP__) && !defined(__WXMAC__) || defined(__UNIX__)
1145     // no chmod in VA. Should be some permission API for HPFS386 partitions
1146     // however
1147     if ( chmod(OS_FILENAME(file2), fbuf.st_mode) != 0 )
1148     {
1149     wxLogSysError(_("Impossible to set permissions for the file '%s'"),
1150     file2.c_str());
1151     return false;
1152     }
1153     #endif // OS/2 || Mac
1154    
1155     #else // !Win32 && ! wxUSE_FILE
1156    
1157     // impossible to simulate with wxWidgets API
1158     wxUnusedVar(file1);
1159     wxUnusedVar(file2);
1160     wxUnusedVar(overwrite);
1161     return false;
1162    
1163     #endif // __WXMSW__ && __WIN32__
1164    
1165     return true;
1166     }
1167    
1168     bool
1169     wxRenameFile(const wxString& file1, const wxString& file2, bool overwrite)
1170     {
1171     if ( !overwrite && wxFileExists(file2) )
1172     {
1173     wxLogSysError
1174     (
1175     _("Failed to rename the file '%s' to '%s' because the destination file already exists."),
1176     file1.c_str(), file2.c_str()
1177     );
1178    
1179     return false;
1180     }
1181    
1182     #if !defined(__WXWINCE__) && !defined(__WXPALMOS__)
1183     // Normal system call
1184     if ( wxRename (file1, file2) == 0 )
1185     return true;
1186     #endif
1187    
1188     // Try to copy
1189     if (wxCopyFile(file1, file2, overwrite)) {
1190     wxRemoveFile(file1);
1191     return true;
1192     }
1193     // Give up
1194     return false;
1195     }
1196    
1197     bool wxRemoveFile(const wxString& file)
1198     {
1199     #if defined(__VISUALC__) \
1200     || defined(__BORLANDC__) \
1201     || defined(__WATCOMC__) \
1202     || defined(__DMC__) \
1203     || defined(__GNUWIN32__) \
1204     || (defined(__MWERKS__) && defined(__MSL__))
1205     int res = wxRemove(file);
1206     #elif defined(__WXMAC__)
1207     int res = unlink(wxFNCONV(file));
1208     #elif defined(__WXPALMOS__)
1209     int res = 1;
1210     // TODO with VFSFileDelete()
1211     #else
1212     int res = unlink(OS_FILENAME(file));
1213     #endif
1214    
1215     return res == 0;
1216     }
1217    
1218     bool wxMkdir(const wxString& dir, int perm)
1219     {
1220     #if defined(__WXPALMOS__)
1221     return false;
1222     #elif defined(__WXMAC__) && !defined(__UNIX__)
1223     return (mkdir( wxFNCONV(dir) , 0 ) == 0);
1224     #else // !Mac
1225     const wxChar *dirname = dir.c_str();
1226    
1227     // assume mkdir() has 2 args on non Windows-OS/2 platforms and on Windows too
1228     // for the GNU compiler
1229     #if (!(defined(__WXMSW__) || defined(__OS2__) || defined(__DOS__))) || (defined(__GNUWIN32__) && !defined(__MINGW32__)) || defined(__WINE__) || defined(__WXMICROWIN__)
1230     #if defined(MSVCRT)
1231     wxUnusedVar(perm);
1232     if ( mkdir(wxFNCONV(dirname)) != 0 )
1233     #else
1234     if ( mkdir(wxFNCONV(dirname), perm) != 0 )
1235     #endif
1236     #elif defined(__OS2__)
1237     wxUnusedVar(perm);
1238     if (::DosCreateDir((PSZ)dirname, NULL) != 0) // enhance for EAB's??
1239     #elif defined(__DOS__)
1240     #if defined(__WATCOMC__)
1241     (void)perm;
1242     if ( wxMkDir(wxFNSTRINGCAST wxFNCONV(dirname)) != 0 )
1243     #elif defined(__DJGPP__)
1244     if ( mkdir(wxFNCONV(dirname), perm) != 0 )
1245     #else
1246     #error "Unsupported DOS compiler!"
1247     #endif
1248     #else // !MSW, !DOS and !OS/2 VAC++
1249     wxUnusedVar(perm);
1250     #ifdef __WXWINCE__
1251     if ( !CreateDirectory(dirname, NULL) )
1252     #else
1253     if ( wxMkDir(dir.fn_str()) != 0 )
1254     #endif
1255     #endif // !MSW/MSW
1256     {
1257     wxLogSysError(_("Directory '%s' couldn't be created"), dirname);
1258    
1259     return false;
1260     }
1261    
1262     return true;
1263     #endif // Mac/!Mac
1264     }
1265    
1266     bool wxRmdir(const wxString& dir, int WXUNUSED(flags))
1267     {
1268     #if defined(__VMS__)
1269     return false; //to be changed since rmdir exists in VMS7.x
1270     #elif defined(__OS2__)
1271     return (::DosDeleteDir((PSZ)dir.c_str()) == 0);
1272     #elif defined(__WXWINCE__)
1273     return (RemoveDirectory(dir) != 0);
1274     #elif defined(__WXPALMOS__)
1275     // TODO with VFSFileRename()
1276     return false;
1277     #else
1278     return (wxRmDir(OS_FILENAME(dir)) == 0);
1279     #endif
1280     }
1281    
1282     // does the path exists? (may have or not '/' or '\\' at the end)
1283     bool wxDirExists(const wxChar *pszPathName)
1284     {
1285     wxString strPath(pszPathName);
1286    
1287     #if defined(__WINDOWS__) || defined(__OS2__)
1288     // Windows fails to find directory named "c:\dir\" even if "c:\dir" exists,
1289     // so remove all trailing backslashes from the path - but don't do this for
1290     // the paths "d:\" (which are different from "d:") nor for just "\"
1291     while ( wxEndsWithPathSeparator(strPath) )
1292     {
1293     size_t len = strPath.length();
1294     if ( len == 1 || (len == 3 && strPath[len - 2] == _T(':')) )
1295     break;
1296    
1297     strPath.Truncate(len - 1);
1298     }
1299     #endif // __WINDOWS__
1300    
1301     #ifdef __OS2__
1302     // OS/2 can't handle "d:", it wants either "d:\" or "d:."
1303     if (strPath.length() == 2 && strPath[1u] == _T(':'))
1304     strPath << _T('.');
1305     #endif
1306    
1307     #if defined(__WXPALMOS__)
1308     return false;
1309     #elif defined(__WIN32__) && !defined(__WXMICROWIN__)
1310     // stat() can't cope with network paths
1311     DWORD ret = ::GetFileAttributes(strPath);
1312    
1313     return (ret != (DWORD)-1) && (ret & FILE_ATTRIBUTE_DIRECTORY);
1314     #elif defined(__OS2__)
1315     FILESTATUS3 Info = {{0}};
1316     APIRET rc = ::DosQueryPathInfo((PSZ)(WXSTRINGCAST strPath), FIL_STANDARD,
1317     (void*) &Info, sizeof(FILESTATUS3));
1318    
1319     return ((rc == NO_ERROR) && (Info.attrFile & FILE_DIRECTORY)) ||
1320     (rc == ERROR_SHARING_VIOLATION);
1321     // If we got a sharing violation, there must be something with this name.
1322     #else // !__WIN32__
1323    
1324     wxStructStat st;
1325     #ifndef __VISAGECPP__
1326     return wxStat(strPath.c_str(), &st) == 0 && ((st.st_mode & S_IFMT) == S_IFDIR);
1327     #else
1328     // S_IFMT not supported in VA compilers.. st_mode is a 2byte value only
1329     return wxStat(pszPathName, &st) == 0 && (st.st_mode == S_IFDIR);
1330     #endif
1331    
1332     #endif // __WIN32__/!__WIN32__
1333     }
1334    
1335     // Get a temporary filename, opening and closing the file.
1336     wxChar *wxGetTempFileName(const wxString& prefix, wxChar *buf)
1337     {
1338     wxString filename;
1339     if ( !wxGetTempFileName(prefix, filename) )
1340     return NULL;
1341    
1342     if ( buf )
1343     wxStrcpy(buf, filename);
1344     else
1345     buf = MYcopystring(filename);
1346    
1347     return buf;
1348     }
1349    
1350     bool wxGetTempFileName(const wxString& prefix, wxString& buf)
1351     {
1352     #if wxUSE_FILE
1353     buf = wxFileName::CreateTempFileName(prefix);
1354    
1355     return !buf.empty();
1356     #else // !wxUSE_FILE
1357     wxUnusedVar(prefix);
1358     wxUnusedVar(buf);
1359    
1360     return false;
1361     #endif // wxUSE_FILE/!wxUSE_FILE
1362     }
1363    
1364     // Get first file name matching given wild card.
1365    
1366     static wxDir *gs_dir = NULL;
1367     static wxString gs_dirPath;
1368    
1369     wxString wxFindFirstFile(const wxChar *spec, int flags)
1370     {
1371     wxSplitPath(spec, &gs_dirPath, NULL, NULL);
1372     if ( gs_dirPath.empty() )
1373     gs_dirPath = wxT(".");
1374     if ( !wxEndsWithPathSeparator(gs_dirPath ) )
1375     gs_dirPath << wxFILE_SEP_PATH;
1376    
1377     if (gs_dir)
1378     delete gs_dir;
1379     gs_dir = new wxDir(gs_dirPath);
1380    
1381     if ( !gs_dir->IsOpened() )
1382     {
1383     wxLogSysError(_("Can not enumerate files '%s'"), spec);
1384     return wxEmptyString;
1385     }
1386    
1387     int dirFlags;
1388     switch (flags)
1389     {
1390     case wxDIR: dirFlags = wxDIR_DIRS; break;
1391     case wxFILE: dirFlags = wxDIR_FILES; break;
1392     default: dirFlags = wxDIR_DIRS | wxDIR_FILES; break;
1393     }
1394    
1395     wxString result;
1396     gs_dir->GetFirst(&result, wxFileNameFromPath(wxString(spec)), dirFlags);
1397     if ( result.empty() )
1398     {
1399     wxDELETE(gs_dir);
1400     return result;
1401     }
1402    
1403     return gs_dirPath + result;
1404     }
1405    
1406     wxString wxFindNextFile()
1407     {
1408     wxASSERT_MSG( gs_dir, wxT("You must call wxFindFirstFile before!") );
1409    
1410     wxString result;
1411     gs_dir->GetNext(&result);
1412    
1413     if ( result.empty() )
1414     {
1415     wxDELETE(gs_dir);
1416     return result;
1417     }
1418    
1419     return gs_dirPath + result;
1420     }
1421    
1422    
1423     // Get current working directory.
1424     // If buf is NULL, allocates space using new, else copies into buf.
1425     // wxGetWorkingDirectory() is obsolete, use wxGetCwd()
1426     // wxDoGetCwd() is their common core to be moved
1427     // to wxGetCwd() once wxGetWorkingDirectory() will be removed.
1428     // Do not expose wxDoGetCwd in headers!
1429    
1430     wxChar *wxDoGetCwd(wxChar *buf, int sz)
1431     {
1432     #if defined(__WXPALMOS__)
1433     // TODO
1434     if(buf && sz>0) buf[0] = _T('\0');
1435     return buf;
1436     #elif defined(__WXWINCE__)
1437     // TODO
1438     if(buf && sz>0) buf[0] = _T('\0');
1439     return buf;
1440     #else
1441     if ( !buf )
1442     {
1443     buf = new wxChar[sz + 1];
1444     }
1445    
1446     bool ok wxDUMMY_INITIALIZE(false);
1447    
1448     // for the compilers which have Unicode version of _getcwd(), call it
1449     // directly, for the others call the ANSI version and do the translation
1450     #if !wxUSE_UNICODE
1451     #define cbuf buf
1452     #else // wxUSE_UNICODE
1453     bool needsANSI = true;
1454    
1455     #if !defined(HAVE_WGETCWD) || wxUSE_UNICODE_MSLU
1456     char cbuf[_MAXPATHLEN];
1457     #endif
1458    
1459     #ifdef HAVE_WGETCWD
1460     #if wxUSE_UNICODE_MSLU
1461     if ( wxGetOsVersion() != wxOS_WINDOWS_9X )
1462     #else
1463     char *cbuf = NULL; // never really used because needsANSI will always be false
1464     #endif
1465     {
1466     ok = _wgetcwd(buf, sz) != NULL;
1467     needsANSI = false;
1468     }
1469     #endif
1470    
1471     if ( needsANSI )
1472     #endif // wxUSE_UNICODE
1473     {
1474     #if defined(_MSC_VER) || defined(__MINGW32__)
1475     ok = _getcwd(cbuf, sz) != NULL;
1476     #elif defined(__WXMAC__) && !defined(__DARWIN__)
1477     char lbuf[1024] ;
1478     if ( getcwd( lbuf , sizeof( lbuf ) ) )
1479     {
1480     wxString res( lbuf , *wxConvCurrent ) ;
1481     wxStrcpy( buf , res ) ;
1482     ok = true;
1483     }
1484     else
1485     ok = false ;
1486     #elif defined(__OS2__)
1487     APIRET rc;
1488     ULONG ulDriveNum = 0;
1489     ULONG ulDriveMap = 0;
1490     rc = ::DosQueryCurrentDisk(&ulDriveNum, &ulDriveMap);
1491     ok = rc == 0;
1492     if (ok)
1493     {
1494     sz -= 3;
1495     rc = ::DosQueryCurrentDir( 0 // current drive
1496     ,(PBYTE)cbuf + 3
1497     ,(PULONG)&sz
1498     );
1499     cbuf[0] = char('A' + (ulDriveNum - 1));
1500     cbuf[1] = ':';
1501     cbuf[2] = '\\';
1502     ok = rc == 0;
1503     }
1504     #else // !Win32/VC++ !Mac !OS2
1505     ok = getcwd(cbuf, sz) != NULL;
1506     #endif // platform
1507    
1508     #if wxUSE_UNICODE && !(defined(__WXMAC__) && !defined(__DARWIN__))
1509     // finally convert the result to Unicode if needed
1510     wxConvFile.MB2WC(buf, cbuf, sz);
1511     #endif // wxUSE_UNICODE
1512     }
1513    
1514     if ( !ok )
1515     {
1516     wxLogSysError(_("Failed to get the working directory"));
1517    
1518     // VZ: the old code used to return "." on error which didn't make any
1519     // sense at all to me - empty string is a better error indicator
1520     // (NULL might be even better but I'm afraid this could lead to
1521     // problems with the old code assuming the return is never NULL)
1522     buf[0] = _T('\0');
1523     }
1524     else // ok, but we might need to massage the path into the right format
1525     {
1526     #ifdef __DJGPP__
1527     // VS: DJGPP is a strange mix of DOS and UNIX API and returns paths
1528     // with / deliminers. We don't like that.
1529     for (wxChar *ch = buf; *ch; ch++)
1530     {
1531     if (*ch == wxT('/'))
1532     *ch = wxT('\\');
1533     }
1534     #endif // __DJGPP__
1535    
1536     // MBN: we hope that in the case the user is compiling a GTK+/Motif app,
1537     // he needs Unix as opposed to Win32 pathnames
1538     #if defined( __CYGWIN__ ) && defined( __WINDOWS__ )
1539     // another example of DOS/Unix mix (Cygwin)
1540     wxString pathUnix = buf;
1541     #if wxUSE_UNICODE
1542     char bufA[_MAXPATHLEN];
1543     cygwin_conv_to_full_win32_path(pathUnix.mb_str(wxConvFile), bufA);
1544     wxConvFile.MB2WC(buf, bufA, sz);
1545     #else
1546     cygwin_conv_to_full_win32_path(pathUnix, buf);
1547     #endif // wxUSE_UNICODE
1548     #endif // __CYGWIN__
1549     }
1550    
1551     return buf;
1552    
1553     #if !wxUSE_UNICODE
1554     #undef cbuf
1555     #endif
1556    
1557     #endif
1558     // __WXWINCE__
1559     }
1560    
1561     #if WXWIN_COMPATIBILITY_2_6
1562     wxChar *wxGetWorkingDirectory(wxChar *buf, int sz)
1563     {
1564     return wxDoGetCwd(buf,sz);
1565     }
1566     #endif // WXWIN_COMPATIBILITY_2_6
1567    
1568     wxString wxGetCwd()
1569     {
1570     wxString str;
1571     wxDoGetCwd(wxStringBuffer(str, _MAXPATHLEN), _MAXPATHLEN);
1572     return str;
1573     }
1574    
1575     bool wxSetWorkingDirectory(const wxString& d)
1576     {
1577     #if defined(__OS2__)
1578     if (d[1] == ':')
1579     {
1580     ::DosSetDefaultDisk(1 + wxToupper(d[0]) - _T('A'));
1581     // do not call DosSetCurrentDir when just changing drive,
1582     // since it requires e.g. "d:." instead of "d:"!
1583     if (d.length() == 2)
1584     return true;
1585     }
1586     return (::DosSetCurrentDir((PSZ)d.c_str()) == 0);
1587     #elif defined(__UNIX__) || defined(__WXMAC__) || defined(__DOS__)
1588     return (chdir(wxFNSTRINGCAST d.fn_str()) == 0);
1589     #elif defined(__WINDOWS__)
1590    
1591     #ifdef __WIN32__
1592     #ifdef __WXWINCE__
1593     // No equivalent in WinCE
1594     wxUnusedVar(d);
1595     return false;
1596     #else
1597     return (bool)(SetCurrentDirectory(d) != 0);
1598     #endif
1599     #else
1600     // Must change drive, too.
1601     bool isDriveSpec = ((strlen(d) > 1) && (d[1] == ':'));
1602     if (isDriveSpec)
1603     {
1604     wxChar firstChar = d[0];
1605    
1606     // To upper case
1607     if (firstChar > 90)
1608     firstChar = firstChar - 32;
1609    
1610     // To a drive number
1611     unsigned int driveNo = firstChar - 64;
1612     if (driveNo > 0)
1613     {
1614     unsigned int noDrives;
1615     _dos_setdrive(driveNo, &noDrives);
1616     }
1617     }
1618     bool success = (chdir(WXSTRINGCAST d) == 0);
1619    
1620     return success;
1621     #endif
1622    
1623     #endif
1624     }
1625    
1626     // Get the OS directory if appropriate (such as the Windows directory).
1627     // On non-Windows platform, probably just return the empty string.
1628     wxString wxGetOSDirectory()
1629     {
1630     #ifdef __WXWINCE__
1631     return wxString(wxT("\\Windows"));
1632     #elif defined(__WINDOWS__) && !defined(__WXMICROWIN__)
1633     wxChar buf[256];
1634     GetWindowsDirectory(buf, 256);
1635     return wxString(buf);
1636     #elif defined(__WXMAC__)
1637     return wxMacFindFolder(kOnSystemDisk, 'macs', false);
1638     #else
1639     return wxEmptyString;
1640     #endif
1641     }
1642    
1643     bool wxEndsWithPathSeparator(const wxChar *pszFileName)
1644     {
1645     size_t len = wxStrlen(pszFileName);
1646    
1647     return len && wxIsPathSeparator(pszFileName[len - 1]);
1648     }
1649    
1650     // find a file in a list of directories, returns false if not found
1651     bool wxFindFileInPath(wxString *pStr, const wxChar *pszPath, const wxChar *pszFile)
1652     {
1653     // we assume that it's not empty
1654     wxCHECK_MSG( !wxIsEmpty(pszFile), false,
1655     _T("empty file name in wxFindFileInPath"));
1656    
1657     // skip path separator in the beginning of the file name if present
1658     if ( wxIsPathSeparator(*pszFile) )
1659     pszFile++;
1660    
1661     // copy the path (strtok will modify it)
1662     wxChar *szPath = new wxChar[wxStrlen(pszPath) + 1];
1663     wxStrcpy(szPath, pszPath);
1664    
1665     wxString strFile;
1666     wxChar *pc, *save_ptr;
1667     for ( pc = wxStrtok(szPath, wxPATH_SEP, &save_ptr);
1668     pc != NULL;
1669     pc = wxStrtok((wxChar *) NULL, wxPATH_SEP, &save_ptr) )
1670     {
1671     // search for the file in this directory
1672     strFile = pc;
1673     if ( !wxEndsWithPathSeparator(pc) )
1674     strFile += wxFILE_SEP_PATH;
1675     strFile += pszFile;
1676    
1677     if ( wxFileExists(strFile) ) {
1678     *pStr = strFile;
1679     break;
1680     }
1681     }
1682    
1683     // suppress warning about unused variable save_ptr when wxStrtok() is a
1684     // macro which throws away its third argument
1685     save_ptr = pc;
1686    
1687     delete [] szPath;
1688    
1689     return pc != NULL; // if true => we breaked from the loop
1690     }
1691    
1692     void WXDLLEXPORT wxSplitPath(const wxChar *pszFileName,
1693     wxString *pstrPath,
1694     wxString *pstrName,
1695     wxString *pstrExt)
1696     {
1697     // it can be empty, but it shouldn't be NULL
1698     wxCHECK_RET( pszFileName, wxT("NULL file name in wxSplitPath") );
1699    
1700     wxFileName::SplitPath(pszFileName, pstrPath, pstrName, pstrExt);
1701     }
1702    
1703     #if wxUSE_DATETIME
1704    
1705     time_t WXDLLEXPORT wxFileModificationTime(const wxString& filename)
1706     {
1707     wxDateTime mtime;
1708     if ( !wxFileName(filename).GetTimes(NULL, &mtime, NULL) )
1709     return (time_t)-1;
1710    
1711     return mtime.GetTicks();
1712     }
1713    
1714     #endif // wxUSE_DATETIME
1715    
1716    
1717     // Parses the filterStr, returning the number of filters.
1718     // Returns 0 if none or if there's a problem.
1719     // filterStr is in the form: "All files (*.*)|*.*|JPEG Files (*.jpeg)|*.jpeg"
1720    
1721     int WXDLLEXPORT wxParseCommonDialogsFilter(const wxString& filterStr,
1722     wxArrayString& descriptions,
1723     wxArrayString& filters)
1724     {
1725     descriptions.Clear();
1726     filters.Clear();
1727    
1728     wxString str(filterStr);
1729    
1730     wxString description, filter;
1731     int pos = 0;
1732     while( pos != wxNOT_FOUND )
1733     {
1734     pos = str.Find(wxT('|'));
1735     if ( pos == wxNOT_FOUND )
1736     {
1737     // if there are no '|'s at all in the string just take the entire
1738     // string as filter and make description empty for later autocompletion
1739     if ( filters.IsEmpty() )
1740     {
1741     descriptions.Add(wxEmptyString);
1742     filters.Add(filterStr);
1743     }
1744     else
1745     {
1746     wxFAIL_MSG( _T("missing '|' in the wildcard string!") );
1747     }
1748    
1749     break;
1750     }
1751    
1752     description = str.Left(pos);
1753     str = str.Mid(pos + 1);
1754     pos = str.Find(wxT('|'));
1755     if ( pos == wxNOT_FOUND )
1756     {
1757     filter = str;
1758     }
1759     else
1760     {
1761     filter = str.Left(pos);
1762     str = str.Mid(pos + 1);
1763     }
1764    
1765     descriptions.Add(description);
1766     filters.Add(filter);
1767     }
1768    
1769     #if defined(__WXMOTIF__)
1770     // split it so there is one wildcard per entry
1771     for( size_t i = 0 ; i < descriptions.GetCount() ; i++ )
1772     {
1773     pos = filters[i].Find(wxT(';'));
1774     if (pos != wxNOT_FOUND)
1775     {
1776     // first split only filters
1777     descriptions.Insert(descriptions[i],i+1);
1778     filters.Insert(filters[i].Mid(pos+1),i+1);
1779     filters[i]=filters[i].Left(pos);
1780    
1781     // autoreplace new filter in description with pattern:
1782     // C/C++ Files(*.cpp;*.c;*.h)|*.cpp;*.c;*.h
1783     // cause split into:
1784     // C/C++ Files(*.cpp)|*.cpp
1785     // C/C++ Files(*.c;*.h)|*.c;*.h
1786     // and next iteration cause another split into:
1787     // C/C++ Files(*.cpp)|*.cpp
1788     // C/C++ Files(*.c)|*.c
1789     // C/C++ Files(*.h)|*.h
1790     for ( size_t k=i;k<i+2;k++ )
1791     {
1792     pos = descriptions[k].Find(filters[k]);
1793     if (pos != wxNOT_FOUND)
1794     {
1795     wxString before = descriptions[k].Left(pos);
1796     wxString after = descriptions[k].Mid(pos+filters[k].Len());
1797     pos = before.Find(_T('('),true);
1798     if (pos>before.Find(_T(')'),true))
1799     {
1800     before = before.Left(pos+1);
1801     before << filters[k];
1802     pos = after.Find(_T(')'));
1803     int pos1 = after.Find(_T('('));
1804     if (pos != wxNOT_FOUND && (pos<pos1 || pos1==wxNOT_FOUND))
1805     {
1806     before << after.Mid(pos);
1807     descriptions[k] = before;
1808     }
1809     }
1810     }
1811     }
1812     }
1813     }
1814     #endif
1815    
1816     // autocompletion
1817     for( size_t j = 0 ; j < descriptions.GetCount() ; j++ )
1818     {
1819     if ( descriptions[j].empty() && !filters[j].empty() )
1820     {
1821     descriptions[j].Printf(_("Files (%s)"), filters[j].c_str());
1822     }
1823     }
1824    
1825     return filters.GetCount();
1826     }
1827    
1828     #if defined(__WINDOWS__) && !(defined(__UNIX__) || defined(__OS2__))
1829     static bool wxCheckWin32Permission(const wxString& path, DWORD access)
1830     {
1831     // quoting the MSDN: "To obtain a handle to a directory, call the
1832     // CreateFile function with the FILE_FLAG_BACKUP_SEMANTICS flag", but this
1833     // doesn't work under Win9x/ME but then it's not needed there anyhow
1834     bool isdir = wxDirExists(path);
1835     if ( isdir && wxGetOsVersion() == wxOS_WINDOWS_9X )
1836     {
1837     // FAT directories always allow all access, even if they have the
1838     // readonly flag set
1839     return true;
1840     }
1841    
1842     HANDLE h = ::CreateFile
1843     (
1844     path.c_str(),
1845     access,
1846     FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
1847     NULL,
1848     OPEN_EXISTING,
1849     isdir ? FILE_FLAG_BACKUP_SEMANTICS : 0,
1850     NULL
1851     );
1852     if ( h != INVALID_HANDLE_VALUE )
1853     CloseHandle(h);
1854    
1855     return h != INVALID_HANDLE_VALUE;
1856     }
1857     #endif // __WINDOWS__
1858    
1859     bool wxIsWritable(const wxString &path)
1860     {
1861     #if defined( __UNIX__ ) || defined(__OS2__)
1862     // access() will take in count also symbolic links
1863     return wxAccess(path.c_str(), W_OK) == 0;
1864     #elif defined( __WINDOWS__ )
1865     return wxCheckWin32Permission(path, GENERIC_WRITE);
1866     #else
1867     wxUnusedVar(path);
1868     // TODO
1869     return false;
1870     #endif
1871     }
1872    
1873     bool wxIsReadable(const wxString &path)
1874     {
1875     #if defined( __UNIX__ ) || defined(__OS2__)
1876     // access() will take in count also symbolic links
1877     return wxAccess(path.c_str(), R_OK) == 0;
1878     #elif defined( __WINDOWS__ )
1879     return wxCheckWin32Permission(path, GENERIC_READ);
1880     #else
1881     wxUnusedVar(path);
1882     // TODO
1883     return false;
1884     #endif
1885     }
1886    
1887     bool wxIsExecutable(const wxString &path)
1888     {
1889     #if defined( __UNIX__ ) || defined(__OS2__)
1890     // access() will take in count also symbolic links
1891     return wxAccess(path.c_str(), X_OK) == 0;
1892     #elif defined( __WINDOWS__ )
1893     return wxCheckWin32Permission(path, GENERIC_EXECUTE);
1894     #else
1895     wxUnusedVar(path);
1896     // TODO
1897     return false;
1898     #endif
1899     }
1900    
1901     // Return the type of an open file
1902     //
1903     // Some file types on some platforms seem seekable but in fact are not.
1904     // The main use of this function is to allow such cases to be detected
1905     // (IsSeekable() is implemented as wxGetFileKind() == wxFILE_KIND_DISK).
1906     //
1907     // This is important for the archive streams, which benefit greatly from
1908     // being able to seek on a stream, but which will produce corrupt archives
1909     // if they unknowingly seek on a non-seekable stream.
1910     //
1911     // wxFILE_KIND_DISK is a good catch all return value, since other values
1912     // disable features of the archive streams. Some other value must be returned
1913     // for a file type that appears seekable but isn't.
1914     //
1915     // Known examples:
1916     // * Pipes on Windows
1917     // * Files on VMS with a record format other than StreamLF
1918     //
1919     wxFileKind wxGetFileKind(int fd)
1920     {
1921     #if defined __WXMSW__ && !defined __WXWINCE__ && defined wxGetOSFHandle
1922     switch (::GetFileType(wxGetOSFHandle(fd)) & ~FILE_TYPE_REMOTE)
1923     {
1924     case FILE_TYPE_CHAR:
1925     return wxFILE_KIND_TERMINAL;
1926     case FILE_TYPE_DISK:
1927     return wxFILE_KIND_DISK;
1928     case FILE_TYPE_PIPE:
1929     return wxFILE_KIND_PIPE;
1930     }
1931    
1932     return wxFILE_KIND_UNKNOWN;
1933    
1934     #elif defined(__UNIX__)
1935     if (isatty(fd))
1936     return wxFILE_KIND_TERMINAL;
1937    
1938     struct stat st;
1939     fstat(fd, &st);
1940    
1941     if (S_ISFIFO(st.st_mode))
1942     return wxFILE_KIND_PIPE;
1943     if (!S_ISREG(st.st_mode))
1944     return wxFILE_KIND_UNKNOWN;
1945    
1946     #if defined(__VMS__)
1947     if (st.st_fab_rfm != FAB$C_STMLF)
1948     return wxFILE_KIND_UNKNOWN;
1949     #endif
1950    
1951     return wxFILE_KIND_DISK;
1952    
1953     #else
1954     #define wxFILEKIND_STUB
1955     (void)fd;
1956     return wxFILE_KIND_DISK;
1957     #endif
1958     }
1959    
1960     wxFileKind wxGetFileKind(FILE *fp)
1961     {
1962     // Note: The watcom rtl dll doesn't have fileno (the static lib does).
1963     // Should be fixed in version 1.4.
1964     #if defined(wxFILEKIND_STUB) || wxONLY_WATCOM_EARLIER_THAN(1,4)
1965     (void)fp;
1966     return wxFILE_KIND_DISK;
1967     #elif defined(__WINDOWS__) && !defined(__CYGWIN__) && !defined(__WATCOMC__) && !defined(__WINE__)
1968     return fp ? wxGetFileKind(_fileno(fp)) : wxFILE_KIND_UNKNOWN;
1969     #else
1970     return fp ? wxGetFileKind(fileno(fp)) : wxFILE_KIND_UNKNOWN;
1971     #endif
1972     }
1973    
1974    
1975     //------------------------------------------------------------------------
1976     // wild character routines
1977     //------------------------------------------------------------------------
1978    
1979     bool wxIsWild( const wxString& pattern )
1980     {
1981     wxString tmp = pattern;
1982     wxChar *pat = WXSTRINGCAST(tmp);
1983     while (*pat)
1984     {
1985     switch (*pat++)
1986     {
1987     case wxT('?'): case wxT('*'): case wxT('['): case wxT('{'):
1988     return true;
1989     case wxT('\\'):
1990     if (!*pat++)
1991     return false;
1992     }
1993     }
1994     return false;
1995     }
1996    
1997     /*
1998     * Written By Douglas A. Lewis <dalewis@cs.Buffalo.EDU>
1999     *
2000     * The match procedure is public domain code (from ircII's reg.c)
2001     * but modified to suit our tastes (RN: No "%" syntax I guess)
2002     */
2003    
2004     bool wxMatchWild( const wxString& pat, const wxString& text, bool dot_special )
2005     {
2006     if (text.empty())
2007     {
2008     /* Match if both are empty. */
2009     return pat.empty();
2010     }
2011    
2012     const wxChar *m = pat.c_str(),
2013     *n = text.c_str(),
2014     *ma = NULL,
2015     *na = NULL;
2016     int just = 0,
2017     acount = 0,
2018     count = 0;
2019    
2020     if (dot_special && (*n == wxT('.')))
2021     {
2022     /* Never match so that hidden Unix files
2023     * are never found. */
2024     return false;
2025     }
2026    
2027     for (;;)
2028     {
2029     if (*m == wxT('*'))
2030     {
2031     ma = ++m;
2032     na = n;
2033     just = 1;
2034     acount = count;
2035     }
2036     else if (*m == wxT('?'))
2037     {
2038     m++;
2039     if (!*n++)
2040     return false;
2041     }
2042     else
2043     {
2044     if (*m == wxT('\\'))
2045     {
2046     m++;
2047     /* Quoting "nothing" is a bad thing */
2048     if (!*m)
2049     return false;
2050     }
2051     if (!*m)
2052     {
2053     /*
2054     * If we are out of both strings or we just
2055     * saw a wildcard, then we can say we have a
2056     * match
2057     */
2058     if (!*n)
2059     return true;
2060     if (just)
2061     return true;
2062     just = 0;
2063     goto not_matched;
2064     }
2065     /*
2066     * We could check for *n == NULL at this point, but
2067     * since it's more common to have a character there,
2068     * check to see if they match first (m and n) and
2069     * then if they don't match, THEN we can check for
2070     * the NULL of n
2071     */
2072     just = 0;
2073     if (*m == *n)
2074     {
2075     m++;
2076     count++;
2077     n++;
2078     }
2079     else
2080     {
2081    
2082     not_matched:
2083    
2084     /*
2085     * If there are no more characters in the
2086     * string, but we still need to find another
2087     * character (*m != NULL), then it will be
2088     * impossible to match it
2089     */
2090     if (!*n)
2091     return false;
2092    
2093     if (ma)
2094     {
2095     m = ma;
2096     n = ++na;
2097     count = acount;
2098     }
2099     else
2100     return false;
2101     }
2102     }
2103     }
2104     }
2105    
2106     #ifdef __VISUALC__
2107     #pragma warning(default:4706) // assignment within conditional expression
2108     #endif // VC++

  ViewVC Help
Powered by ViewVC 1.1.22