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