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