src/common/filesys.cpp

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