compute scrollbar spacing the same way GtkScrolledWindow does it

[wxWidgets.git] / src / common / fs_mem.cpp

diff --git a/src/common/fs_mem.cpp b/src/common/fs_mem.cpp
index 30995f3d050ae1478627be5f5dee466528ffa905..5f96257100180f37ed3a5b1f55a4ed56d245f010 100644 (file)
--- a/src/common/fs_mem.cpp
+++ b/src/common/fs_mem.cpp
@@ -1,237 +1,280 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

-// Name:        fs_mem.cpp
+// Name:        src/common/fs_mem.cpp

 // Purpose:     in-memory file system
 // Author:      Vaclav Slavik
 // Purpose:     in-memory file system
 // Author:      Vaclav Slavik

+// RCS-ID:      $Id$

 // Copyright:   (c) 2000 Vaclav Slavik
 // Copyright:   (c) 2000 Vaclav Slavik

-// Licence:     wxWindows Licence
+// Licence:     wxWindows licence

 /////////////////////////////////////////////////////////////////////////////
 
 /////////////////////////////////////////////////////////////////////////////
 

-
-#ifdef __GNUG__
-#pragma implementation "fs_mem.h"
-#endif
-

 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__

-#pragma hdrstop
+    #pragma hdrstop

 #endif
 
 #if wxUSE_FILESYSTEM && wxUSE_STREAMS
 
 #endif
 
 #if wxUSE_FILESYSTEM && wxUSE_STREAMS
 

-#include "wx/image.h"
-#include "wx/bitmap.h"

 #include "wx/fs_mem.h"
 
 #include "wx/fs_mem.h"
 

-#ifdef __WXBASE__
-
-#ifndef WXPRECOMP
+#ifndef WX_PRECOMP

     #include "wx/intl.h"
     #include "wx/log.h"
     #include "wx/intl.h"
     #include "wx/log.h"

-    #include "wx/hash.h"
+    #include "wx/wxcrtvararg.h"
+    #if wxUSE_GUI
+        #include "wx/image.h"
+    #endif // wxUSE_GUI

 #endif
 
 #include "wx/mstream.h"
 
 #endif
 
 #include "wx/mstream.h"
 

-class MemFSHashObj : public wxObject
+// represents a file entry in wxMemoryFS
+class wxMemoryFSFile

 {
 {

-    public:
-
-        MemFSHashObj(const void *data, size_t len)
-        {
-            m_Data = new char[len];
-            memcpy(m_Data, data, len);
-            m_Len = len;
-            InitTime();
-        }
-
-        MemFSHashObj(wxMemoryOutputStream& stream)
-        {
-            m_Len = stream.GetSize();
-            m_Data = new char[m_Len];
-            stream.CopyTo(m_Data, m_Len);
-            InitTime();
-        }
-
-        ~MemFSHashObj()
-        {
-            delete[] m_Data;
-        }
-
-        char *m_Data;
-        size_t m_Len;
+public:
+    wxMemoryFSFile(const void *data, size_t len, const wxString& mime)
+    {
+        m_Data = new char[len];
+        memcpy(m_Data, data, len);
+        m_Len = len;
+        m_MimeType = mime;
+        InitTime();
+    }
+
+    wxMemoryFSFile(const wxMemoryOutputStream& stream, const wxString& mime)
+    {
+        m_Len = stream.GetSize();
+        m_Data = new char[m_Len];
+        stream.CopyTo(m_Data, m_Len);
+        m_MimeType = mime;
+        InitTime();
+    }
+
+    virtual ~wxMemoryFSFile()
+    {
+        delete[] m_Data;
+    }
+
+    char *m_Data;
+    size_t m_Len;
+    wxString m_MimeType;

 #if wxUSE_DATETIME
 #if wxUSE_DATETIME

-        wxDateTime m_Time;
+    wxDateTime m_Time;

 #endif // wxUSE_DATETIME
 
 #endif // wxUSE_DATETIME
 

-    DECLARE_NO_COPY_CLASS(MemFSHashObj)
-
-    private:
-        void InitTime()
-        {
+private:
+    void InitTime()
+    {

 #if wxUSE_DATETIME
 #if wxUSE_DATETIME

-            m_Time = wxDateTime::Now();
-#endif // wxUSE_DATETIME            
-        }
+        m_Time = wxDateTime::Now();
+#endif // wxUSE_DATETIME
+    }
+
+    wxDECLARE_NO_COPY_CLASS(wxMemoryFSFile);

 };
 
 };
 

+#if wxUSE_BASE
+

 
 //--------------------------------------------------------------------------------
 // wxMemoryFSHandler
 //--------------------------------------------------------------------------------
 
 
 
 //--------------------------------------------------------------------------------
 // wxMemoryFSHandler
 //--------------------------------------------------------------------------------
 
 

-wxHashTable *wxMemoryFSHandlerBase::m_Hash = NULL;
+wxMemoryFSHash wxMemoryFSHandlerBase::m_Hash;

 
 
 wxMemoryFSHandlerBase::wxMemoryFSHandlerBase() : wxFileSystemHandler()
 {
 }
 
 
 
 wxMemoryFSHandlerBase::wxMemoryFSHandlerBase() : wxFileSystemHandler()
 {
 }
 

-
-

 wxMemoryFSHandlerBase::~wxMemoryFSHandlerBase()
 {
     // as only one copy of FS handler is supposed to exist, we may silently
     // delete static data here. (There is no way how to remove FS handler from
     // wxFileSystem other than releasing _all_ handlers.)
 wxMemoryFSHandlerBase::~wxMemoryFSHandlerBase()
 {
     // as only one copy of FS handler is supposed to exist, we may silently
     // delete static data here. (There is no way how to remove FS handler from
     // wxFileSystem other than releasing _all_ handlers.)

-
-    if (m_Hash)
-    {
-        delete m_Hash;
-        m_Hash = NULL;
-    }
+    WX_CLEAR_HASH_MAP(wxMemoryFSHash, m_Hash);

 }
 
 }
 

-
-

 bool wxMemoryFSHandlerBase::CanOpen(const wxString& location)
 {
 bool wxMemoryFSHandlerBase::CanOpen(const wxString& location)
 {

-    wxString p = GetProtocol(location);
-    return (p == wxT("memory"));
+    return GetProtocol(location) == "memory";

 }
 
 }
 

-
-
-
-wxFSFile* wxMemoryFSHandlerBase::OpenFile(wxFileSystem& WXUNUSED(fs), const wxString& location)
+wxFSFile * wxMemoryFSHandlerBase::OpenFile(wxFileSystem& WXUNUSED(fs),
+                                           const wxString& location)

 {
 {

-    if (m_Hash)
-    {
-        MemFSHashObj *obj = (MemFSHashObj*) m_Hash -> Get(GetRightLocation(location));
-        if (obj == NULL)  return NULL;
-        else return new wxFSFile(new wxMemoryInputStream(obj -> m_Data, obj -> m_Len),
-                            location,
-                            GetMimeTypeFromExt(location),
-                            GetAnchor(location)
+    wxMemoryFSHash::const_iterator i = m_Hash.find(GetRightLocation(location));
+    if ( i == m_Hash.end() )
+        return NULL;
+
+    const wxMemoryFSFile * const obj = i->second;
+
+    return new wxFSFile
+               (
+                    new wxMemoryInputStream(obj->m_Data, obj->m_Len),
+                    location,
+                    obj->m_MimeType,
+                    GetAnchor(location)

 #if wxUSE_DATETIME
 #if wxUSE_DATETIME

-                            , obj -> m_Time
-#endif // wxUSE_DATETIME                            
-                            );
-    }
-    else return NULL;
+                    , obj->m_Time
+#endif // wxUSE_DATETIME
+               );

 }
 
 }
 

-
-
-wxString wxMemoryFSHandlerBase::FindFirst(const wxString& WXUNUSED(spec),
-                                      int WXUNUSED(flags))
+wxString wxMemoryFSHandlerBase::FindFirst(const wxString& url, int flags)

 {
 {

-    wxFAIL_MSG(wxT("wxMemoryFSHandlerBase::FindFirst not implemented"));
+    if ( (flags & wxDIR) && !(flags & wxFILE) )
+    {
+        // we only store files, not directories, so we don't risk finding
+        // anything
+        return wxString();
+    }

 
 

-    return wxEmptyString;
-}
+    const wxString spec = GetRightLocation(url);
+    if ( spec.find_first_of("?*") == wxString::npos )
+    {
+        // simple case: there are no wildcard characters so we can return
+        // either 0 or 1 results and we can find the potential match quickly
+        return m_Hash.count(spec) ? url : wxString();
+    }
+    //else: deal with wildcards in FindNext()

 
 

+    m_findArgument = spec;
+    m_findIter = m_Hash.begin();

 
 

+    return FindNext();
+}

 
 wxString wxMemoryFSHandlerBase::FindNext()
 {
 
 wxString wxMemoryFSHandlerBase::FindNext()
 {

-    wxFAIL_MSG(wxT("wxMemoryFSHandlerBase::FindNext not implemented"));
+    // m_findArgument is used to indicate that search is in progress, we reset
+    // it to empty string after iterating over all elements
+    while ( !m_findArgument.empty() )
+    {
+        // test for the match before (possibly) clearing m_findArgument below
+        const bool found = m_findIter->first.Matches(m_findArgument);

 
 

-    return wxEmptyString;
-}
+        // advance m_findIter first as we need to do it anyhow, whether it
+        // matches or not
+        const wxMemoryFSHash::const_iterator current = m_findIter;

 
 

+        if ( ++m_findIter == m_Hash.end() )
+            m_findArgument.clear();

 
 

-bool wxMemoryFSHandlerBase::CheckHash(const wxString& filename)
-{
-    if (m_Hash == NULL)
-    {
-        m_Hash = new wxHashTable(wxKEY_STRING);
-        m_Hash -> DeleteContents(TRUE);
+        if ( found )
+            return "memory:" + current->first;

     }
 
     }
 

-    if (m_Hash -> Get(filename) != NULL)
+    return wxString();
+}
+
+bool wxMemoryFSHandlerBase::CheckDoesntExist(const wxString& filename)
+{
+    if ( m_Hash.count(filename) )

     {
     {

-        wxString s;
-        s.Printf(_("Memory VFS already contains file '%s'!"), filename.c_str());
-        wxLogError(s);
-        return FALSE;
+        wxLogError(_("Memory VFS already contains file '%s'!"), filename);
+        return false;

     }
     }

-    else
-        return TRUE;
-}

 
 

+    return true;
+}

 
 
 
 

-/*static*/ void
-wxMemoryFSHandlerBase::AddFile(const wxString& filename, wxImage& image, long type)
+/*static*/
+void wxMemoryFSHandlerBase::AddFileWithMimeType(const wxString& filename,
+                                                const wxString& textdata,
+                                                const wxString& mimetype)

 {
 {

-    if (!CheckHash(filename)) return;
+    const wxCharBuffer buf(textdata.To8BitData());

 
 

-
-    wxMemoryOutputStream mems;
-    if (image.Ok() && image.SaveFile(mems, (int)type))
-        m_Hash -> Put(filename, new MemFSHashObj(mems));
-    else
-    {
-        wxString s;
-        s.Printf(_("Failed to store image '%s' to memory VFS!"), filename.c_str());
-        wxPrintf(wxT("'%s'\n"), s.c_str());
-        wxLogError(s);
-    }
+    AddFileWithMimeType(filename, buf.data(), buf.length(), mimetype);

 }
 
 
 }
 
 

-/*static*/ void wxMemoryFSHandlerBase::AddFile(const wxString& filename, const wxString& textdata)
+/*static*/
+void wxMemoryFSHandlerBase::AddFileWithMimeType(const wxString& filename,
+                                                const void *binarydata, size_t size,
+                                                const wxString& mimetype)
+{
+    if ( !CheckDoesntExist(filename) )
+        return;
+
+    m_Hash[filename] = new wxMemoryFSFile(binarydata, size, mimetype);
+}
+
+/*static*/
+void wxMemoryFSHandlerBase::AddFile(const wxString& filename,
+                                    const wxString& textdata)

 {
 {

-    AddFile(filename, (const void*) textdata.mb_str(), textdata.Length());
+    AddFileWithMimeType(filename, textdata, wxEmptyString);

 }
 
 
 }
 
 

-/*static*/ void wxMemoryFSHandlerBase::AddFile(const wxString& filename, const void *binarydata, size_t size)
+/*static*/
+void wxMemoryFSHandlerBase::AddFile(const wxString& filename,
+                                    const void *binarydata, size_t size)

 {
 {

-    if (!CheckHash(filename)) return;
-    m_Hash -> Put(filename, new MemFSHashObj(binarydata, size));
+    AddFileWithMimeType(filename, binarydata, size, wxEmptyString);

 }
 
 
 
 /*static*/ void wxMemoryFSHandlerBase::RemoveFile(const wxString& filename)
 {
 }
 
 
 
 /*static*/ void wxMemoryFSHandlerBase::RemoveFile(const wxString& filename)
 {

-    if (m_Hash == NULL ||
-        m_Hash -> Get(filename) == NULL)
+    wxMemoryFSHash::iterator i = m_Hash.find(filename);
+    if ( i == m_Hash.end() )

     {
     {

-        wxString s;
-        s.Printf(_("Trying to remove file '%s' from memory VFS, but it is not loaded!"), filename.c_str());
-        wxLogError(s);
+        wxLogError(_("Trying to remove file '%s' from memory VFS, "
+                     "but it is not loaded!"),
+                   filename);
+        return;

     }
 
     }
 

-    else
-        delete m_Hash -> Delete(filename);
+    delete i->second;
+    m_Hash.erase(i);

 }
 
 }
 

-#endif // __WXBASE__
+#endif // wxUSE_BASE

 
 #if wxUSE_GUI
 
 
 #if wxUSE_GUI
 

-/*static*/ void wxMemoryFSHandler::AddFile(const wxString& filename, const wxBitmap& bitmap, long type)
+#if wxUSE_IMAGE
+/*static*/ void
+wxMemoryFSHandler::AddFile(const wxString& filename,
+                           const wxImage& image,
+                           wxBitmapType type)
+{
+    if ( !CheckDoesntExist(filename) )
+        return;
+
+    wxMemoryOutputStream mems;
+    if ( image.IsOk() && image.SaveFile(mems, type) )
+    {
+        m_Hash[filename] = new wxMemoryFSFile
+                               (
+                                    mems,
+                                    wxImage::FindHandler(type)->GetMimeType()
+                               );
+    }
+    else
+    {
+        wxLogError(_("Failed to store image '%s' to memory VFS!"), filename);
+    }
+}
+
+/*static*/ void
+wxMemoryFSHandler::AddFile(const wxString& filename,
+                           const wxBitmap& bitmap,
+                           wxBitmapType type)

 {
     wxImage img = bitmap.ConvertToImage();
     AddFile(filename, img, type);
 }
 
 {
     wxImage img = bitmap.ConvertToImage();
     AddFile(filename, img, type);
 }
 

-#endif
+#endif // wxUSE_IMAGE

 
 

+#endif // wxUSE_GUI

 
 

-#endif // wxUSE_FILESYSTEM && wxUSE_FS_ZIP

 
 

+#endif // wxUSE_FILESYSTEM && wxUSE_FS_ZIP