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 #ifdef __GNUG__
  11 #pragma implementation
  12 #endif
  13
  14 #include "wx/wxprec.h"
  15
  16 #ifdef __BORDLANDC__
  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
  28
  29
  30
  31 //--------------------------------------------------------------------------------
  32 // wxFileSystemHandler
  33 //--------------------------------------------------------------------------------
  34
  35 IMPLEMENT_ABSTRACT_CLASS(wxFileSystemHandler, wxObject)
  36
  37
  38 static wxFileTypeInfo *gs_FSMimeFallbacks = NULL;
  39
  40 wxString wxFileSystemHandler::GetMimeTypeFromExt(const wxString& location)
  41 {
  42     wxString ext = wxEmptyString, mime = wxEmptyString;
  43     wxString loc = GetRightLocation(location);
  44     char c;
  45     int l = loc.Length(), l2;
  46     wxFileType *ft;
  47
  48     l2 = l;
  49     for (int i = l-1; i >= 0; i--) {
  50         c = loc[(unsigned int) i];
  51         if (c == wxT('#')) l2 = i + 1;
  52         if (c == wxT('.')) {ext = loc.Right(l2-i-1); break;}
  53         if ((c == wxT('/')) || (c == wxT('\\')) || (c == wxT(':'))) {return wxEmptyString;}
  54     }
  55
  56     static bool s_MinimalMimeEnsured = FALSE;
  57     if (!s_MinimalMimeEnsured) {
  58         wxTheMimeTypesManager -> AddFallbacks(gs_FSMimeFallbacks);
  59         s_MinimalMimeEnsured = TRUE;
  60     }
  61
  62     ft = wxTheMimeTypesManager -> GetFileTypeFromExtension(ext);
  63     if ( !ft || !ft -> GetMimeType(&mime) ) {
  64         mime = wxEmptyString;
  65     }
  66
  67     delete ft;
  68
  69     return mime;
  70 }
  71
  72
  73
  74 wxString wxFileSystemHandler::GetProtocol(const wxString& location) const
  75 {
  76     wxString s = wxEmptyString;
  77     int i, l = location.Length();
  78     bool fnd;
  79
  80     fnd = FALSE;
  81     for (i = l-1; (i >= 0) && ((location[i] != wxT('#')) || (!fnd)); i--) {
  82         if ((location[i] == wxT(':')) && (i != 1 /*win: C:\path*/)) fnd = TRUE;
  83     }
  84     if (!fnd) return wxT("file");
  85     for (++i; (i < l) && (location[i] != wxT(':')); i++) s << location[i];
  86     return s;
  87 }
  88
  89
  90 wxString wxFileSystemHandler::GetLeftLocation(const wxString& location) const
  91 {
  92     int i;
  93     bool fnd;
  94
  95     fnd = FALSE;
  96     for (i = location.Length()-1; i >= 0; i--) {
  97         if ((location[i] == wxT(':')) && (i != 1 /*win: C:\path*/)) fnd = TRUE;
  98         else if (fnd && (location[i] == wxT('#'))) return location.Left(i);
  99     }
 100     return wxEmptyString;
 101 }
 102
 103 wxString wxFileSystemHandler::GetRightLocation(const wxString& location) const
 104 {
 105     int i, l = location.Length();
 106     int l2 = l + 1;
 107     for (i = l-1; (i >= 0) && ((location[i] != wxT(':')) || (i == 1) || (location[i-2] == wxT(':'))); i--) {if (location[i] == wxT('#')) l2 = i + 1;}
 108     if (i == 0) return wxEmptyString;
 109     else return location.Mid(i + 1, l2 - i - 2);
 110 }
 111
 112 wxString wxFileSystemHandler::GetAnchor(const wxString& location) const
 113 {
 114     char c;
 115     int l = location.Length();
 116
 117     for (int i = l-1; i >= 0; i--) {
 118         c = location[i];
 119         if (c == wxT('#')) return location.Right(l-i-1);
 120         else if ((c == wxT('.')) || (c == wxT('/')) || (c == wxT('\\')) || (c == wxT(':'))) return wxEmptyString;
 121     }
 122     return wxEmptyString;
 123 }
 124
 125
 126 wxString wxFileSystemHandler::FindFirst(const wxString& WXUNUSED(spec),
 127                                         int WXUNUSED(flags))
 128 {
 129     return wxEmptyString;
 130 }
 131
 132 wxString wxFileSystemHandler::FindNext()
 133 {
 134     return wxEmptyString;
 135 }
 136
 137 //--------------------------------------------------------------------------------
 138 // wxLocalFSHandler
 139 //--------------------------------------------------------------------------------
 140
 141 class wxLocalFSHandler : public wxFileSystemHandler
 142 {
 143     public:
 144         virtual bool CanOpen(const wxString& location);
 145         virtual wxFSFile* OpenFile(wxFileSystem& fs, const wxString& location);
 146         virtual wxString FindFirst(const wxString& spec, int flags = 0);
 147         virtual wxString FindNext();
 148 };
 149
 150
 151 bool wxLocalFSHandler::CanOpen(const wxString& location)
 152 {
 153     return GetProtocol(location) == wxT("file");
 154 }
 155
 156 wxFSFile* wxLocalFSHandler::OpenFile(wxFileSystem& WXUNUSED(fs), const wxString& location)
 157 {
 158     wxString right = GetRightLocation(location);
 159  #ifdef __WXMAC__
 160     if ( right[0] != '.' && right[0] != '/' && right.Find( '/' ) != wxNOT_FOUND ) {
 161       right = "./" + right ;
 162     }
 163     right = wxUnix2MacFilename( right ) ;
 164  #endif
 165     if (!wxFileExists(right))
 166         return (wxFSFile*) NULL;
 167
 168     return new wxFSFile(new wxFileInputStream(right),
 169                         right,
 170                         GetMimeTypeFromExt(location),
 171                         GetAnchor(location),
 172                         wxDateTime(wxFileModificationTime(right)));
 173
 174 }
 175
 176 wxString wxLocalFSHandler::FindFirst(const wxString& spec, int flags)
 177 {
 178     wxString right = GetRightLocation(spec);
 179  #ifdef __WXMAC__
 180     if ( right[0] != '.' && right[0] != '/' && right.Find( '/' ) != wxNOT_FOUND ) {
 181       right = "./" + right ;
 182     }
 183     right = wxUnix2MacFilename( right ) ;
 184  #endif
 185     return wxFindFirstFile(right, flags);
 186 }
 187
 188 wxString wxLocalFSHandler::FindNext()
 189 {
 190     return wxFindNextFile();
 191 }
 192
 193
 194
 195 //-----------------------------------------------------------------------------
 196 // wxFileSystem
 197 //-----------------------------------------------------------------------------
 198
 199 IMPLEMENT_DYNAMIC_CLASS(wxFileSystem, wxObject)
 200
 201
 202 wxList wxFileSystem::m_Handlers;
 203
 204
 205 static wxString MakeCorrectPath(const wxString& path)
 206 {
 207     wxString p(path);
 208     wxString r;
 209     int i, j, cnt;
 210
 211     cnt = p.Length();
 212     for (i = 0; i < cnt; i++)
 213       if (p.GetChar(i) == wxT('\\')) p.GetWritableChar(i) = wxT('/'); // Want to be windows-safe
 214
 215     if (p.Left(2) == wxT("./")) { p = p.Mid(2); cnt -= 2; }
 216
 217     if (cnt < 3) return p;
 218
 219     r << p.GetChar(0) << p.GetChar(1);
 220
 221     // skip trailing ../.., if any
 222     for (i = 2; i < cnt && (p.GetChar(i) == wxT('/') || p.GetChar(i) == wxT('.')); i++) r << p.GetChar(i);
 223
 224     // remove back references: translate dir1/../dir2 to dir2
 225     for (; i < cnt; i++)
 226     {
 227         r << p.GetChar(i);
 228         if (p.GetChar(i) == wxT('/') && p.GetChar(i-1) == wxT('.') && p.GetChar(i-2) == wxT('.'))
 229         {
 230             for (j = r.Length() - 2; j >= 0 && r.GetChar(j) != wxT('/') && r.GetChar(j) != wxT(':'); j--) {}
 231             if (j >= 0 && r.GetChar(j) != wxT(':'))
 232             {
 233                 for (j = j - 1; j >= 0 && r.GetChar(j) != wxT('/') && r.GetChar(j) != wxT(':'); j--) {}
 234                 r.Remove(j + 1);
 235             }
 236         }
 237     }
 238
 239     for (; i < cnt; i++) r << p.GetChar(i);
 240
 241     return r;
 242 }
 243
 244
 245 void wxFileSystem::ChangePathTo(const wxString& location, bool is_dir)
 246 {
 247     int i, pathpos = -1;
 248
 249     m_Path = MakeCorrectPath(location);
 250
 251     if (is_dir)
 252     {
 253         if (m_Path.Length() > 0 && m_Path.Last() != wxT('/') && m_Path.Last() != wxT(':'))
 254                 m_Path << wxT('/');
 255     }
 256
 257     else
 258     {
 259         for (i = m_Path.Length()-1; i >= 0; i--)
 260         {
 261             if (m_Path[(unsigned int) i] == wxT('/'))
 262                 {
 263                 if ((i > 1) && (m_Path[(unsigned int) (i-1)] == wxT('/')) && (m_Path[(unsigned int) (i-2)] == wxT(':')))
 264                         {
 265                     i -= 2;
 266                     continue;
 267                 }
 268                 else
 269                         {
 270                     pathpos = i;
 271                     break;
 272                 }
 273             }
 274             else if (m_Path[(unsigned int) i] == wxT(':')) {
 275                 pathpos = i;
 276                 break;
 277             }
 278         }
 279         if (pathpos == -1)
 280         {
 281             for (i = 0; i < (int) m_Path.Length(); i++)
 282             {
 283                 if (m_Path[(unsigned int) i] == wxT(':'))
 284                         {
 285                     m_Path.Remove(i+1);
 286                     break;
 287                 }
 288             }
 289             if (i == (int) m_Path.Length())
 290                 m_Path = wxEmptyString;
 291         }
 292         else
 293         {
 294             m_Path.Remove(pathpos+1);
 295         }
 296     }
 297 }
 298
 299
 300
 301 wxFSFile* wxFileSystem::OpenFile(const wxString& location)
 302 {
 303     wxString loc = MakeCorrectPath(location);
 304     unsigned i, ln;
 305     char meta;
 306     wxFSFile *s = NULL;
 307     wxNode *node;
 308
 309     ln = loc.Length();
 310     meta = 0;
 311     for (i = 0; i < ln; i++)
 312     {
 313         switch (loc[i])
 314         {
 315             case wxT('/') : case wxT(':') : case wxT('#') :
 316                 meta = loc[i];
 317                 break;
 318         }
 319         if (meta != 0) break;
 320     }
 321     m_LastName = wxEmptyString;
 322
 323     // try relative paths first :
 324     if (meta != wxT(':'))
 325     {
 326         node = m_Handlers.GetFirst();
 327         while (node)
 328         {
 329             wxFileSystemHandler *h = (wxFileSystemHandler*) node -> GetData();
 330             if (h->CanOpen(m_Path + loc))
 331                 {
 332                 s = h->OpenFile(*this, m_Path + loc);
 333                 if (s) { m_LastName = m_Path + loc; break; }
 334             }
 335             node = node->GetNext();
 336         }
 337     }
 338
 339     // if failed, try absolute paths :
 340     if (s == NULL)
 341     {
 342         node = m_Handlers.GetFirst();
 343         while (node)
 344         {
 345             wxFileSystemHandler *h = (wxFileSystemHandler*) node->GetData();
 346             if (h->CanOpen(loc))
 347             {
 348                 s = h->OpenFile(*this, loc);
 349                 if (s) { m_LastName = loc; break; }
 350             }
 351             node = node->GetNext();
 352         }
 353     }
 354     return (s);
 355 }
 356
 357
 358
 359 wxString wxFileSystem::FindFirst(const wxString& spec, int flags)
 360 {
 361     wxNode *node;
 362     wxString spec2(spec);
 363
 364     m_FindFileHandler = NULL;
 365
 366     for (int i = spec2.Length()-1; i >= 0; i--)
 367         if (spec2[(unsigned int) i] == wxT('\\')) spec2.GetWritableChar(i) = wxT('/'); // Want to be windows-safe
 368
 369     node = m_Handlers.GetFirst();
 370     while (node)
 371     {
 372         m_FindFileHandler = (wxFileSystemHandler*) node -> GetData();
 373         if (m_FindFileHandler -> CanOpen(m_Path + spec2))
 374             return m_FindFileHandler -> FindFirst(m_Path + spec2, flags);
 375         node = node->GetNext();
 376     }
 377
 378     node = m_Handlers.GetFirst();
 379     while (node)
 380     {
 381         m_FindFileHandler = (wxFileSystemHandler*) node -> GetData();
 382         if (m_FindFileHandler -> CanOpen(spec2))
 383             return m_FindFileHandler -> FindFirst(spec2, flags);
 384         node = node->GetNext();
 385     }
 386
 387     return wxEmptyString;
 388 }
 389
 390
 391
 392 wxString wxFileSystem::FindNext()
 393 {
 394     if (m_FindFileHandler == NULL) return wxEmptyString;
 395     else return m_FindFileHandler -> FindNext();
 396 }
 397
 398
 399
 400 void wxFileSystem::AddHandler(wxFileSystemHandler *handler)
 401 {
 402     m_Handlers.Append(handler);
 403 }
 404
 405
 406 void wxFileSystem::CleanUpHandlers()
 407 {
 408     m_Handlers.DeleteContents(TRUE);
 409     m_Handlers.Clear();
 410 }
 411
 412
 413
 414
 415 ///// Module:
 416
 417 class wxFileSystemModule : public wxModule
 418 {
 419     DECLARE_DYNAMIC_CLASS(wxFileSystemModule)
 420
 421     public:
 422         virtual bool OnInit()
 423         {
 424             wxFileSystem::AddHandler(new wxLocalFSHandler);
 425
 426             gs_FSMimeFallbacks = new wxFileTypeInfo[6];
 427             gs_FSMimeFallbacks[0] =
 428             wxFileTypeInfo("image/jpeg",
 429                            "",
 430                            "",
 431                            "JPEG image (from fallback)",
 432                            "jpg", "jpeg", NULL);
 433             gs_FSMimeFallbacks[1] =
 434             wxFileTypeInfo("image/gif",
 435                            "",
 436                            "",
 437                            "GIF image (from fallback)",
 438                            "gif", NULL);
 439             gs_FSMimeFallbacks[2] =
 440             wxFileTypeInfo("image/png",
 441                            "",
 442                            "",
 443                            "PNG image (from fallback)",
 444                            "png", NULL);
 445             gs_FSMimeFallbacks[3] =
 446             wxFileTypeInfo("image/bmp",
 447                            "",
 448                            "",
 449                            "windows bitmap image (from fallback)",
 450                            "bmp", NULL);
 451             gs_FSMimeFallbacks[4] =
 452             wxFileTypeInfo("text/html",
 453                            "",
 454                            "",
 455                            "HTML document (from fallback)",
 456                            "htm", "html", NULL);
 457             gs_FSMimeFallbacks[5] =
 458             // must terminate the table with this!
 459             wxFileTypeInfo();
 460
 461             return TRUE;
 462         }
 463         virtual void OnExit()
 464         {
 465             delete [] gs_FSMimeFallbacks;
 466             wxFileSystem::CleanUpHandlers();
 467         }
 468 };
 469
 470 IMPLEMENT_DYNAMIC_CLASS(wxFileSystemModule, wxModule)
 471
 472 #endif
 473   // wxUSE_FILESYSTEM
 474
 475
 476