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