src/common/fs_mem.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/common/fs_mem.cpp
   3 // Purpose:     in-memory file system
   4 // Author:      Vaclav Slavik
   5 // RCS-ID:      $Id$
   6 // Copyright:   (c) 2000 Vaclav Slavik
   7 // Licence:     wxWindows licence
   8 /////////////////////////////////////////////////////////////////////////////
   9
  10 #include "wx/wxprec.h"
  11
  12 #ifdef __BORLANDC__
  13     #pragma hdrstop
  14 #endif
  15
  16 #if wxUSE_FILESYSTEM && wxUSE_STREAMS
  17
  18 #include "wx/fs_mem.h"
  19
  20 #ifndef WX_PRECOMP
  21     #include "wx/intl.h"
  22     #include "wx/log.h"
  23     #include "wx/hash.h"
  24     #include "wx/wxcrtvararg.h"
  25     #if wxUSE_GUI
  26         #include "wx/image.h"
  27     #endif // wxUSE_GUI
  28 #endif
  29
  30 #include "wx/mstream.h"
  31
  32 class MemFSHashObj : public wxObject
  33 {
  34     public:
  35
  36         MemFSHashObj(const void *data, size_t len, const wxString& mime)
  37         {
  38             m_Data = new char[len];
  39             memcpy(m_Data, data, len);
  40             m_Len = len;
  41             m_MimeType = mime;
  42             InitTime();
  43         }
  44
  45         MemFSHashObj(const wxMemoryOutputStream& stream, const wxString& mime)
  46         {
  47             m_Len = stream.GetSize();
  48             m_Data = new char[m_Len];
  49             stream.CopyTo(m_Data, m_Len);
  50             m_MimeType = mime;
  51             InitTime();
  52         }
  53
  54         virtual ~MemFSHashObj()
  55         {
  56             delete[] m_Data;
  57         }
  58
  59         char *m_Data;
  60         size_t m_Len;
  61         wxString m_MimeType;
  62 #if wxUSE_DATETIME
  63         wxDateTime m_Time;
  64 #endif // wxUSE_DATETIME
  65
  66     DECLARE_NO_COPY_CLASS(MemFSHashObj)
  67
  68     private:
  69         void InitTime()
  70         {
  71 #if wxUSE_DATETIME
  72             m_Time = wxDateTime::Now();
  73 #endif // wxUSE_DATETIME
  74         }
  75 };
  76
  77 #if wxUSE_BASE
  78
  79
  80 //--------------------------------------------------------------------------------
  81 // wxMemoryFSHandler
  82 //--------------------------------------------------------------------------------
  83
  84
  85 wxHashTable *wxMemoryFSHandlerBase::m_Hash = NULL;
  86
  87
  88 wxMemoryFSHandlerBase::wxMemoryFSHandlerBase() : wxFileSystemHandler()
  89 {
  90 }
  91
  92
  93
  94 wxMemoryFSHandlerBase::~wxMemoryFSHandlerBase()
  95 {
  96     // as only one copy of FS handler is supposed to exist, we may silently
  97     // delete static data here. (There is no way how to remove FS handler from
  98     // wxFileSystem other than releasing _all_ handlers.)
  99
 100     if (m_Hash)
 101     {
 102         WX_CLEAR_HASH_TABLE(*m_Hash);
 103         delete m_Hash;
 104         m_Hash = NULL;
 105     }
 106 }
 107
 108
 109
 110 bool wxMemoryFSHandlerBase::CanOpen(const wxString& location)
 111 {
 112     wxString p = GetProtocol(location);
 113     return (p == wxT("memory"));
 114 }
 115
 116
 117
 118
 119 wxFSFile* wxMemoryFSHandlerBase::OpenFile(wxFileSystem& WXUNUSED(fs), const wxString& location)
 120 {
 121     if (m_Hash)
 122     {
 123         MemFSHashObj *obj = (MemFSHashObj*) m_Hash -> Get(GetRightLocation(location));
 124         if (obj == NULL)  return NULL;
 125         else return new wxFSFile(new wxMemoryInputStream(obj -> m_Data, obj -> m_Len),
 126                             location,
 127                             obj->m_MimeType,
 128                             GetAnchor(location)
 129 #if wxUSE_DATETIME
 130                             , obj -> m_Time
 131 #endif // wxUSE_DATETIME
 132                             );
 133     }
 134     else return NULL;
 135 }
 136
 137
 138
 139 wxString wxMemoryFSHandlerBase::FindFirst(const wxString& WXUNUSED(spec),
 140                                       int WXUNUSED(flags))
 141 {
 142     wxFAIL_MSG(wxT("wxMemoryFSHandlerBase::FindFirst not implemented"));
 143
 144     return wxEmptyString;
 145 }
 146
 147
 148
 149 wxString wxMemoryFSHandlerBase::FindNext()
 150 {
 151     wxFAIL_MSG(wxT("wxMemoryFSHandlerBase::FindNext not implemented"));
 152
 153     return wxEmptyString;
 154 }
 155
 156
 157 bool wxMemoryFSHandlerBase::CheckHash(const wxString& filename)
 158 {
 159     if (m_Hash == NULL)
 160     {
 161         m_Hash = new wxHashTable(wxKEY_STRING);
 162     }
 163
 164     if (m_Hash -> Get(filename) != NULL)
 165     {
 166         wxString s;
 167         s.Printf(_("Memory VFS already contains file '%s'!"), filename.c_str());
 168         wxLogError(s);
 169         return false;
 170     }
 171     else
 172         return true;
 173 }
 174
 175
 176 /*static*/
 177 void wxMemoryFSHandlerBase::AddFileWithMimeType(const wxString& filename,
 178                                                 const wxString& textdata,
 179                                                 const wxString& mimetype)
 180 {
 181     AddFileWithMimeType(filename,
 182                         (const void*) textdata.mb_str(), textdata.length(),
 183                         mimetype);
 184 }
 185
 186
 187 /*static*/
 188 void wxMemoryFSHandlerBase::AddFileWithMimeType(const wxString& filename,
 189                                                 const void *binarydata, size_t size,
 190                                                 const wxString& mimetype)
 191 {
 192     if (!CheckHash(filename)) return;
 193     m_Hash -> Put(filename, new MemFSHashObj(binarydata, size, mimetype));
 194 }
 195
 196 /*static*/
 197 void wxMemoryFSHandlerBase::AddFile(const wxString& filename,
 198                                     const wxString& textdata)
 199 {
 200     AddFileWithMimeType(filename, textdata, wxEmptyString);
 201 }
 202
 203
 204 /*static*/
 205 void wxMemoryFSHandlerBase::AddFile(const wxString& filename,
 206                                     const void *binarydata, size_t size)
 207 {
 208     AddFileWithMimeType(filename, binarydata, size, wxEmptyString);
 209 }
 210
 211
 212
 213 /*static*/ void wxMemoryFSHandlerBase::RemoveFile(const wxString& filename)
 214 {
 215     if (m_Hash == NULL ||
 216         m_Hash -> Get(filename) == NULL)
 217     {
 218         wxString s;
 219         s.Printf(_("Trying to remove file '%s' from memory VFS, but it is not loaded!"), filename.c_str());
 220         wxLogError(s);
 221     }
 222
 223     else
 224         delete m_Hash -> Delete(filename);
 225 }
 226
 227 #endif // wxUSE_BASE
 228
 229 #if wxUSE_GUI
 230
 231 #if wxUSE_IMAGE
 232 /*static*/ void
 233 wxMemoryFSHandler::AddFile(const wxString& filename,
 234                            const wxImage& image,
 235                            wxBitmapType type)
 236 {
 237     if (!CheckHash(filename)) return;
 238
 239     wxMemoryOutputStream mems;
 240     if (image.Ok() && image.SaveFile(mems, type))
 241     {
 242         m_Hash->Put
 243                 (
 244                     filename,
 245                     new MemFSHashObj
 246                         (
 247                             mems,
 248                             wxImage::FindHandler(type)->GetMimeType()
 249                         )
 250                 );
 251     }
 252     else
 253     {
 254         wxString s;
 255         s.Printf(_("Failed to store image '%s' to memory VFS!"), filename.c_str());
 256         wxPrintf(wxT("'%s'\n"), s.c_str());
 257         wxLogError(s);
 258     }
 259 }
 260
 261 /*static*/ void
 262 wxMemoryFSHandler::AddFile(const wxString& filename,
 263                            const wxBitmap& bitmap,
 264                            wxBitmapType type)
 265 {
 266 #if !defined(__WXMSW__) || wxUSE_WXDIB
 267     wxImage img = bitmap.ConvertToImage();
 268     AddFile(filename, img, type);
 269 #endif
 270 }
 271
 272 #endif // wxUSE_IMAGE
 273
 274 #endif // wxUSE_GUI
 275
 276
 277 #endif // wxUSE_FILESYSTEM && wxUSE_FS_ZIP