src/common/filesys.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/common/filesys.cpp
   3 // Purpose:     wxFileSystem class - interface for opening files
   4 // Author:      Vaclav Slavik
   5 // Copyright:   (c) 1999 Vaclav Slavik
   6 // CVS-ID:      $Id$
   7 // Licence:     wxWindows licence
   8 /////////////////////////////////////////////////////////////////////////////
   9
  10 #include "wx/wxprec.h"
  11
  12 #ifdef __BORLANDC__
  13     #pragma hdrstop
  14 #endif
  15
  16
  17 #if wxUSE_FILESYSTEM
  18
  19 #include "wx/filesys.h"
  20
  21 #ifndef WX_PRECOMP
  22     #include "wx/log.h"
  23     #include "wx/module.h"
  24 #endif
  25
  26 #include "wx/wfstream.h"
  27 #include "wx/mimetype.h"
  28 #include "wx/filename.h"
  29 #include "wx/tokenzr.h"
  30 #include "wx/uri.h"
  31 #include "wx/private/fileback.h"
  32
  33 // ----------------------------------------------------------------------------
  34 // wxFSFile
  35 // ----------------------------------------------------------------------------
  36
  37 const wxString& wxFSFile::GetMimeType() const
  38 {
  39     if ( m_MimeType.empty() && !m_Location.empty() )
  40     {
  41         wxConstCast(this, wxFSFile)->m_MimeType =
  42             wxFileSystemHandler::GetMimeTypeFromExt(m_Location);
  43     }
  44
  45     return m_MimeType;
  46 }
  47
  48 // ----------------------------------------------------------------------------
  49 // wxFileSystemHandler
  50 // ----------------------------------------------------------------------------
  51
  52 IMPLEMENT_ABSTRACT_CLASS(wxFileSystemHandler, wxObject)
  53
  54
  55 /* static */
  56 wxString wxFileSystemHandler::GetMimeTypeFromExt(const wxString& location)
  57 {
  58     wxString ext, mime;
  59     wxString loc = GetRightLocation(location);
  60     wxChar c;
  61     int l = loc.length(), l2;
  62
  63     l2 = l;
  64     for (int i = l-1; i >= 0; i--)
  65     {
  66         c = loc[(unsigned int) i];
  67         if ( c == wxT('#') )
  68             l2 = i + 1;
  69         if ( c == wxT('.') )
  70         {
  71             ext = loc.Right(l2-i-1);
  72             break;
  73         }
  74         if ( (c == wxT('/')) || (c == wxT('\\')) || (c == wxT(':')) )
  75             return wxEmptyString;
  76     }
  77
  78 #if wxUSE_MIMETYPE
  79     static bool s_MinimalMimeEnsured = false;
  80     if (!s_MinimalMimeEnsured)
  81     {
  82         static const wxFileTypeInfo fallbacks[] =
  83         {
  84             wxFileTypeInfo(_T("image/jpeg"),
  85                            wxEmptyString,
  86                            wxEmptyString,
  87                            _T("JPEG image (from fallback)"),
  88                            _T("jpg"), _T("jpeg"), _T("JPG"), _T("JPEG"), wxNullPtr),
  89             wxFileTypeInfo(_T("image/gif"),
  90                            wxEmptyString,
  91                            wxEmptyString,
  92                            _T("GIF image (from fallback)"),
  93                            _T("gif"), _T("GIF"), wxNullPtr),
  94             wxFileTypeInfo(_T("image/png"),
  95                            wxEmptyString,
  96                            wxEmptyString,
  97                            _T("PNG image (from fallback)"),
  98                            _T("png"), _T("PNG"), wxNullPtr),
  99             wxFileTypeInfo(_T("image/bmp"),
 100                            wxEmptyString,
 101                            wxEmptyString,
 102                            _T("windows bitmap image (from fallback)"),
 103                            _T("bmp"), _T("BMP"), wxNullPtr),
 104             wxFileTypeInfo(_T("text/html"),
 105                            wxEmptyString,
 106                            wxEmptyString,
 107                            _T("HTML document (from fallback)"),
 108                            _T("htm"), _T("html"), _T("HTM"), _T("HTML"), wxNullPtr),
 109             // must terminate the table with this!
 110             wxFileTypeInfo()
 111         };
 112         wxTheMimeTypesManager->AddFallbacks(fallbacks);
 113         s_MinimalMimeEnsured = true;
 114     }
 115
 116     wxFileType *ft = wxTheMimeTypesManager->GetFileTypeFromExtension(ext);
 117     if ( !ft || !ft -> GetMimeType(&mime) )
 118     {
 119         mime = wxEmptyString;
 120     }
 121
 122     delete ft;
 123
 124     return mime;
 125 #else
 126     if ( ext.IsSameAs(wxT("htm"), false) || ext.IsSameAs(_T("html"), false) )
 127         return wxT("text/html");
 128     if ( ext.IsSameAs(wxT("jpg"), false) || ext.IsSameAs(_T("jpeg"), false) )
 129         return wxT("image/jpeg");
 130     if ( ext.IsSameAs(wxT("gif"), false) )
 131         return wxT("image/gif");
 132     if ( ext.IsSameAs(wxT("png"), false) )
 133         return wxT("image/png");
 134     if ( ext.IsSameAs(wxT("bmp"), false) )
 135         return wxT("image/bmp");
 136     return wxEmptyString;
 137 #endif
 138 }
 139
 140
 141
 142 /* static */
 143 wxString wxFileSystemHandler::GetProtocol(const wxString& location)
 144 {
 145     wxString s = wxEmptyString;
 146     int i, l = location.length();
 147     bool fnd = false;
 148
 149     for (i = l-1; (i >= 0) && ((location[i] != wxT('#')) || (!fnd)); i--) {
 150         if ((location[i] == wxT(':')) && (i != 1 /*win: C:\path*/)) fnd = true;
 151     }
 152     if (!fnd) return wxT("file");
 153     for (++i; (i < l) && (location[i] != wxT(':')); i++) s << location[i];
 154     return s;
 155 }
 156
 157
 158 /* static */
 159 wxString wxFileSystemHandler::GetLeftLocation(const wxString& location)
 160 {
 161     int i;
 162     bool fnd = false;
 163
 164     for (i = location.length()-1; i >= 0; i--) {
 165         if ((location[i] == wxT(':')) && (i != 1 /*win: C:\path*/)) fnd = true;
 166         else if (fnd && (location[i] == wxT('#'))) return location.Left(i);
 167     }
 168     return wxEmptyString;
 169 }
 170
 171 /* static */
 172 wxString wxFileSystemHandler::GetRightLocation(const wxString& location)
 173 {
 174     int i, l = location.length();
 175     int l2 = l + 1;
 176
 177     for (i = l-1;
 178          (i >= 0) &&
 179          ((location[i] != wxT(':')) || (i == 1) || (location[i-2] == wxT(':')));
 180          i--)
 181     {
 182         if (location[i] == wxT('#')) l2 = i + 1;
 183     }
 184     if (i == 0) return wxEmptyString;
 185     else return location.Mid(i + 1, l2 - i - 2);
 186 }
 187
 188 /* static */
 189 wxString wxFileSystemHandler::GetAnchor(const wxString& location)
 190 {
 191     wxChar c;
 192     int l = location.length();
 193
 194     for (int i = l-1; i >= 0; i--) {
 195         c = location[i];
 196         if (c == wxT('#'))
 197             return location.Right(l-i-1);
 198         else if ((c == wxT('/')) || (c == wxT('\\')) || (c == wxT(':')))
 199             return wxEmptyString;
 200     }
 201     return wxEmptyString;
 202 }
 203
 204
 205 wxString wxFileSystemHandler::FindFirst(const wxString& WXUNUSED(spec),
 206                                         int WXUNUSED(flags))
 207 {
 208     return wxEmptyString;
 209 }
 210
 211 wxString wxFileSystemHandler::FindNext()
 212 {
 213     return wxEmptyString;
 214 }
 215
 216 //--------------------------------------------------------------------------------
 217 // wxLocalFSHandler
 218 //--------------------------------------------------------------------------------
 219
 220
 221 wxString wxLocalFSHandler::ms_root;
 222
 223 bool wxLocalFSHandler::CanOpen(const wxString& location)
 224 {
 225     return GetProtocol(location) == wxT("file");
 226 }
 227
 228 wxFSFile* wxLocalFSHandler::OpenFile(wxFileSystem& WXUNUSED(fs), const wxString& location)
 229 {
 230     // location has Unix path separators
 231     wxString right = GetRightLocation(location);
 232     wxFileName fn = wxFileSystem::URLToFileName(right);
 233     wxString fullpath = ms_root + fn.GetFullPath();
 234
 235     if (!wxFileExists(fullpath))
 236         return (wxFSFile*) NULL;
 237
 238     // we need to check whether we can really read from this file, otherwise
 239     // wxFSFile is not going to work
 240 #if wxUSE_FFILE
 241     wxFFileInputStream *is = new wxFFileInputStream(fullpath);
 242 #elif wxUSE_FILE
 243     wxFileInputStream *is = new wxFileInputStream(fullpath);
 244 #else
 245 #error One of wxUSE_FILE or wxUSE_FFILE must be set to 1 for wxFSHandler to work
 246 #endif
 247     if ( !is->Ok() )
 248     {
 249         delete is;
 250         return (wxFSFile*) NULL;
 251     }
 252
 253     return new wxFSFile(is,
 254                         right,
 255                         wxEmptyString,
 256                         GetAnchor(location)
 257 #if wxUSE_DATETIME
 258                         ,wxDateTime(wxFileModificationTime(fullpath))
 259 #endif // wxUSE_DATETIME
 260                         );
 261 }
 262
 263 wxString wxLocalFSHandler::FindFirst(const wxString& spec, int flags)
 264 {
 265     wxFileName fn = wxFileSystem::URLToFileName(GetRightLocation(spec));
 266     return wxFindFirstFile(ms_root + fn.GetFullPath(), flags);
 267 }
 268
 269 wxString wxLocalFSHandler::FindNext()
 270 {
 271     return wxFindNextFile();
 272 }
 273
 274
 275
 276 //-----------------------------------------------------------------------------
 277 // wxFileSystem
 278 //-----------------------------------------------------------------------------
 279
 280 IMPLEMENT_DYNAMIC_CLASS(wxFileSystem, wxObject)
 281 IMPLEMENT_ABSTRACT_CLASS(wxFSFile, wxObject)
 282
 283
 284 wxList wxFileSystem::m_Handlers;
 285
 286
 287 wxFileSystem::~wxFileSystem()
 288 {
 289     WX_CLEAR_HASH_MAP(wxFSHandlerHash, m_LocalHandlers)
 290 }
 291
 292
 293 static wxString MakeCorrectPath(const wxString& path)
 294 {
 295     wxString p(path);
 296     wxString r;
 297     int i, j, cnt;
 298
 299     cnt = p.length();
 300     for (i = 0; i < cnt; i++)
 301       if (p.GetChar(i) == wxT('\\')) p.GetWritableChar(i) = wxT('/'); // Want to be windows-safe
 302
 303     if (p.Left(2) == wxT("./")) { p = p.Mid(2); cnt -= 2; }
 304
 305     if (cnt < 3) return p;
 306
 307     r << p.GetChar(0) << p.GetChar(1);
 308
 309     // skip trailing ../.., if any
 310     for (i = 2; i < cnt && (p.GetChar(i) == wxT('/') || p.GetChar(i) == wxT('.')); i++) r << p.GetChar(i);
 311
 312     // remove back references: translate dir1/../dir2 to dir2
 313     for (; i < cnt; i++)
 314     {
 315         r << p.GetChar(i);
 316         if (p.GetChar(i) == wxT('/') && p.GetChar(i-1) == wxT('.') && p.GetChar(i-2) == wxT('.'))
 317         {
 318             for (j = r.length() - 2; j >= 0 && r.GetChar(j) != wxT('/') && r.GetChar(j) != wxT(':'); j--) {}
 319             if (j >= 0 && r.GetChar(j) != wxT(':'))
 320             {
 321                 for (j = j - 1; j >= 0 && r.GetChar(j) != wxT('/') && r.GetChar(j) != wxT(':'); j--) {}
 322                 r.Remove(j + 1);
 323             }
 324         }
 325     }
 326
 327     for (; i < cnt; i++) r << p.GetChar(i);
 328
 329     return r;
 330 }
 331
 332
 333 void wxFileSystem::ChangePathTo(const wxString& location, bool is_dir)
 334 {
 335     int i, pathpos = -1;
 336
 337     m_Path = MakeCorrectPath(location);
 338
 339     if (is_dir)
 340     {
 341         if (m_Path.length() > 0 && m_Path.Last() != wxT('/') && m_Path.Last() != wxT(':'))
 342             m_Path << wxT('/');
 343     }
 344
 345     else
 346     {
 347         for (i = m_Path.length()-1; i >= 0; i--)
 348         {
 349             if (m_Path[(unsigned int) i] == wxT('/'))
 350             {
 351                 if ((i > 1) && (m_Path[(unsigned int) (i-1)] == wxT('/')) && (m_Path[(unsigned int) (i-2)] == wxT(':')))
 352                 {
 353                     i -= 2;
 354                     continue;
 355                 }
 356                 else
 357                 {
 358                     pathpos = i;
 359                     break;
 360                 }
 361             }
 362             else if (m_Path[(unsigned int) i] == wxT(':')) {
 363                 pathpos = i;
 364                 break;
 365             }
 366         }
 367         if (pathpos == -1)
 368         {
 369             for (i = 0; i < (int) m_Path.length(); i++)
 370             {
 371                 if (m_Path[(unsigned int) i] == wxT(':'))
 372                 {
 373                     m_Path.Remove(i+1);
 374                     break;
 375                 }
 376             }
 377             if (i == (int) m_Path.length())
 378                 m_Path = wxEmptyString;
 379         }
 380         else
 381         {
 382             m_Path.Remove(pathpos+1);
 383         }
 384     }
 385 }
 386
 387
 388
 389 wxFileSystemHandler *wxFileSystem::MakeLocal(wxFileSystemHandler *h)
 390 {
 391     wxClassInfo *classinfo = h->GetClassInfo();
 392
 393     if (classinfo->IsDynamic())
 394     {
 395         wxFileSystemHandler*& local = m_LocalHandlers[classinfo];
 396         if (!local)
 397             local = (wxFileSystemHandler*)classinfo->CreateObject();
 398         return local;
 399     }
 400     else
 401     {
 402         return h;
 403     }
 404 }
 405
 406
 407
 408 wxFSFile* wxFileSystem::OpenFile(const wxString& location, int flags)
 409 {
 410     if ((flags & wxFS_READ) == 0)
 411         return NULL;
 412
 413     wxString loc = MakeCorrectPath(location);
 414     unsigned i, ln;
 415     wxChar meta;
 416     wxFSFile *s = NULL;
 417     wxList::compatibility_iterator node;
 418
 419     ln = loc.length();
 420     meta = 0;
 421     for (i = 0; i < ln; i++)
 422     {
 423         switch ( loc[i].GetValue() )
 424         {
 425             case wxT('/') : case wxT(':') : case wxT('#') :
 426                 meta = loc[i];
 427                 break;
 428         }
 429         if (meta != 0) break;
 430     }
 431     m_LastName = wxEmptyString;
 432
 433     // try relative paths first :
 434     if (meta != wxT(':'))
 435     {
 436         node = m_Handlers.GetFirst();
 437         while (node)
 438         {
 439             wxFileSystemHandler *h = (wxFileSystemHandler*) node -> GetData();
 440             if (h->CanOpen(m_Path + loc))
 441             {
 442                 s = MakeLocal(h)->OpenFile(*this, m_Path + loc);
 443                 if (s) { m_LastName = m_Path + loc; break; }
 444             }
 445             node = node->GetNext();
 446         }
 447     }
 448
 449     // if failed, try absolute paths :
 450     if (s == NULL)
 451     {
 452         node = m_Handlers.GetFirst();
 453         while (node)
 454         {
 455             wxFileSystemHandler *h = (wxFileSystemHandler*) node->GetData();
 456             if (h->CanOpen(loc))
 457             {
 458                 s = MakeLocal(h)->OpenFile(*this, loc);
 459                 if (s) { m_LastName = loc; break; }
 460             }
 461             node = node->GetNext();
 462         }
 463     }
 464
 465     if (s && (flags & wxFS_SEEKABLE) != 0 && !s->GetStream()->IsSeekable())
 466     {
 467         wxBackedInputStream *stream;
 468         stream = new wxBackedInputStream(s->DetachStream());
 469         stream->FindLength();
 470         s->SetStream(stream);
 471     }
 472
 473     return (s);
 474 }
 475
 476
 477
 478 wxString wxFileSystem::FindFirst(const wxString& spec, int flags)
 479 {
 480     wxList::compatibility_iterator node;
 481     wxString spec2(spec);
 482
 483     m_FindFileHandler = NULL;
 484
 485     for (int i = spec2.length()-1; i >= 0; i--)
 486         if (spec2[(unsigned int) i] == wxT('\\')) spec2.GetWritableChar(i) = wxT('/'); // Want to be windows-safe
 487
 488     node = m_Handlers.GetFirst();
 489     while (node)
 490     {
 491         wxFileSystemHandler *h = (wxFileSystemHandler*) node -> GetData();
 492         if (h -> CanOpen(m_Path + spec2))
 493         {
 494             m_FindFileHandler = MakeLocal(h);
 495             return m_FindFileHandler -> FindFirst(m_Path + spec2, flags);
 496         }
 497         node = node->GetNext();
 498     }
 499
 500     node = m_Handlers.GetFirst();
 501     while (node)
 502     {
 503         wxFileSystemHandler *h = (wxFileSystemHandler*) node -> GetData();
 504         if (h -> CanOpen(spec2))
 505         {
 506             m_FindFileHandler = MakeLocal(h);
 507             return m_FindFileHandler -> FindFirst(spec2, flags);
 508         }
 509         node = node->GetNext();
 510     }
 511
 512     return wxEmptyString;
 513 }
 514
 515
 516
 517 wxString wxFileSystem::FindNext()
 518 {
 519     if (m_FindFileHandler == NULL) return wxEmptyString;
 520     else return m_FindFileHandler -> FindNext();
 521 }
 522
 523 bool wxFileSystem::FindFileInPath(wxString *pStr,
 524                                   const wxString& path,
 525                                   const wxString& basename)
 526 {
 527     // we assume that it's not empty
 528     wxCHECK_MSG( !basename.empty(), false,
 529                 _T("empty file name in wxFileSystem::FindFileInPath"));
 530
 531     wxString name;
 532     // skip path separator in the beginning of the file name if present
 533     if ( wxIsPathSeparator(basename[0u]) )
 534         name = basename.substr(1);
 535     else
 536         name = basename;
 537
 538     wxStringTokenizer tokenizer(path, wxPATH_SEP);
 539     while ( tokenizer.HasMoreTokens() )
 540     {
 541         wxString strFile = tokenizer.GetNextToken();
 542         if ( !wxEndsWithPathSeparator(strFile) )
 543             strFile += wxFILE_SEP_PATH;
 544         strFile += name;
 545
 546         wxFSFile *file = OpenFile(strFile);
 547         if ( file )
 548         {
 549             delete file;
 550             *pStr = strFile;
 551             return true;
 552         }
 553     }
 554
 555     return false;
 556 }
 557
 558 void wxFileSystem::AddHandler(wxFileSystemHandler *handler)
 559 {
 560     // prepend the handler to the beginning of the list because handlers added
 561     // last should have the highest priority to allow overriding them
 562     m_Handlers.Insert((size_t)0, handler);
 563 }
 564
 565 wxFileSystemHandler* wxFileSystem::RemoveHandler(wxFileSystemHandler *handler)
 566 {
 567     // if handler has already been removed (or deleted)
 568     // we return NULL. This is by design in case
 569     // CleanUpHandlers() is called before RemoveHandler
 570     // is called, as we cannot control the order
 571     // which modules are unloaded
 572     if (!m_Handlers.DeleteObject(handler))
 573         return NULL;
 574
 575     return handler;
 576 }
 577
 578
 579 bool wxFileSystem::HasHandlerForPath(const wxString &location)
 580 {
 581     for ( wxList::compatibility_iterator node = m_Handlers.GetFirst();
 582            node; node = node->GetNext() )
 583     {
 584         wxFileSystemHandler *h = (wxFileSystemHandler*) node->GetData();
 585         if (h->CanOpen(location))
 586             return true;
 587     }
 588
 589     return false;
 590 }
 591
 592 void wxFileSystem::CleanUpHandlers()
 593 {
 594     WX_CLEAR_LIST(wxList, m_Handlers);
 595 }
 596
 597 static const wxString g_unixPathString(wxT("/"));
 598 static const wxString g_nativePathString(wxFILE_SEP_PATH);
 599
 600 // Returns the native path for a file URL
 601 wxFileName wxFileSystem::URLToFileName(const wxString& url)
 602 {
 603     wxString path = url;
 604
 605     if ( path.Find(wxT("file://")) == 0 )
 606     {
 607         path = path.Mid(7);
 608     }
 609     else if ( path.Find(wxT("file:")) == 0 )
 610     {
 611         path = path.Mid(5);
 612     }
 613     // Remove preceding double slash on Mac Classic
 614 #if defined(__WXMAC__) && !defined(__UNIX__)
 615     else if ( path.Find(wxT("//")) == 0 )
 616         path = path.Mid(2);
 617 #endif
 618
 619     path = wxURI::Unescape(path);
 620
 621 #ifdef __WXMSW__
 622     // file urls either start with a forward slash (local harddisk),
 623     // otherwise they have a servername/sharename notation,
 624     // which only exists on msw and corresponds to a unc
 625     if ( path[0u] == wxT('/') && path [1u] != wxT('/'))
 626     {
 627         path = path.Mid(1);
 628     }
 629     else if ( (url.Find(wxT("file://")) == 0) &&
 630               (path.Find(wxT('/')) != wxNOT_FOUND) &&
 631               (path.length() > 1) && (path[1u] != wxT(':')) )
 632     {
 633         path = wxT("//") + path;
 634     }
 635 #endif
 636
 637     path.Replace(g_unixPathString, g_nativePathString);
 638
 639     return wxFileName(path, wxPATH_NATIVE);
 640 }
 641
 642 // Returns the file URL for a native path
 643 wxString wxFileSystem::FileNameToURL(const wxFileName& filename)
 644 {
 645     wxFileName fn = filename;
 646     fn.Normalize(wxPATH_NORM_DOTS | wxPATH_NORM_TILDE | wxPATH_NORM_ABSOLUTE);
 647     wxString url = fn.GetFullPath(wxPATH_NATIVE);
 648
 649 #ifndef __UNIX__
 650     // unc notation, wxMSW
 651     if ( url.Find(wxT("\\\\")) == 0 )
 652     {
 653         url = wxT("//") + url.Mid(2);
 654     }
 655     else
 656     {
 657         url = wxT("/") + url;
 658 #ifdef __WXMAC__
 659         url = wxT("/") + url;
 660 #endif
 661
 662     }
 663 #endif
 664
 665     url.Replace(g_nativePathString, g_unixPathString);
 666     url.Replace(wxT("%"), wxT("%25")); // '%'s must be replaced first!
 667     url.Replace(wxT("#"), wxT("%23"));
 668
 669     // notice that all colons *must* be encoded in the paths used by
 670     // wxFileSystem even though this makes URLs produced by this method
 671     // unusable with IE under Windows as it requires "file:///c:/foo.bar" and
 672     // doesn't accept "file:///c%3a/foo.bar" -- but then we never made any
 673     // guarantees about general suitability of the strings returned by this
 674     // method, they must work with wxFileSystem only and not encoding the colon
 675     // breaks handling of "http://wherever/whatever.zip#zip:filename.ext" URLs
 676     // so we really can't do this without heavy changes to the parsing code
 677     // here, in particular in GetRightLocation()
 678     url.Replace(wxT(":"), wxT("%3A"));
 679     url = wxT("file:") + url;
 680     return url;
 681 }
 682
 683
 684 ///// Module:
 685
 686 class wxFileSystemModule : public wxModule
 687 {
 688     DECLARE_DYNAMIC_CLASS(wxFileSystemModule)
 689
 690     public:
 691         wxFileSystemModule() :
 692             wxModule(),
 693             m_handler(NULL)
 694         {
 695         }
 696
 697         virtual bool OnInit()
 698         {
 699             m_handler = new wxLocalFSHandler;
 700             wxFileSystem::AddHandler(m_handler);
 701             return true;
 702         }
 703         virtual void OnExit()
 704         {
 705             delete wxFileSystem::RemoveHandler(m_handler);
 706
 707             wxFileSystem::CleanUpHandlers();
 708         }
 709
 710     private:
 711         wxFileSystemHandler* m_handler;
 712
 713 };
 714
 715 IMPLEMENT_DYNAMIC_CLASS(wxFileSystemModule, wxModule)
 716
 717 #endif
 718   // wxUSE_FILESYSTEM