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