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