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