← Back to branch summary

~registry/dolphin-emu/triforce

« back to all changes in this revision

Viewing changes to Externals/wxWidgets3/src/common/fs_mem.cpp

  • Committer: Sérgio Benjamim
  • Date: 2015-02-13 05:54:40 UTC
  • Revision ID: sergio_br2@yahoo.com.br-20150213055440-ey2rt3sjpy27km78
Dolphin Triforce branch from code.google, commit b957980 (4.0-315).

Show diffs side-by-side

added added

removed removed

Lines of Context:
Externals/wxWidgets3/src/common/fs_mem.cpp
 
1
/////////////////////////////////////////////////////////////////////////////
 
2
// Name:        src/common/fs_mem.cpp
 
3
// Purpose:     in-memory file system
 
4
// Author:      Vaclav Slavik
 
5
// Copyright:   (c) 2000 Vaclav Slavik
 
6
// Licence:     wxWindows licence
 
7
/////////////////////////////////////////////////////////////////////////////
 
8
 
 
9
#include "wx/wxprec.h"
 
10
 
 
11
#ifdef __BORLANDC__
 
12
    #pragma hdrstop
 
13
#endif
 
14
 
 
15
#if wxUSE_FILESYSTEM && wxUSE_STREAMS
 
16
 
 
17
#include "wx/fs_mem.h"
 
18
 
 
19
#ifndef WX_PRECOMP
 
20
    #include "wx/intl.h"
 
21
    #include "wx/log.h"
 
22
    #include "wx/wxcrtvararg.h"
 
23
    #if wxUSE_GUI
 
24
        #include "wx/image.h"
 
25
    #endif // wxUSE_GUI
 
26
#endif
 
27
 
 
28
#include "wx/mstream.h"
 
29
 
 
30
// represents a file entry in wxMemoryFS
 
31
class wxMemoryFSFile
 
32
{
 
33
public:
 
34
    wxMemoryFSFile(const void *data, size_t len, const wxString& mime)
 
35
    {
 
36
        m_Data = new char[len];
 
37
        memcpy(m_Data, data, len);
 
38
        m_Len = len;
 
39
        m_MimeType = mime;
 
40
        InitTime();
 
41
    }
 
42
 
 
43
    wxMemoryFSFile(const wxMemoryOutputStream& stream, const wxString& mime)
 
44
    {
 
45
        m_Len = stream.GetSize();
 
46
        m_Data = new char[m_Len];
 
47
        stream.CopyTo(m_Data, m_Len);
 
48
        m_MimeType = mime;
 
49
        InitTime();
 
50
    }
 
51
 
 
52
    virtual ~wxMemoryFSFile()
 
53
    {
 
54
        delete[] m_Data;
 
55
    }
 
56
 
 
57
    char *m_Data;
 
58
    size_t m_Len;
 
59
    wxString m_MimeType;
 
60
#if wxUSE_DATETIME
 
61
    wxDateTime m_Time;
 
62
#endif // wxUSE_DATETIME
 
63
 
 
64
private:
 
65
    void InitTime()
 
66
    {
 
67
#if wxUSE_DATETIME
 
68
        m_Time = wxDateTime::Now();
 
69
#endif // wxUSE_DATETIME
 
70
    }
 
71
 
 
72
    wxDECLARE_NO_COPY_CLASS(wxMemoryFSFile);
 
73
};
 
74
 
 
75
#if wxUSE_BASE
 
76
 
 
77
 
 
78
//--------------------------------------------------------------------------------
 
79
// wxMemoryFSHandler
 
80
//--------------------------------------------------------------------------------
 
81
 
 
82
 
 
83
wxMemoryFSHash wxMemoryFSHandlerBase::m_Hash;
 
84
 
 
85
 
 
86
wxMemoryFSHandlerBase::wxMemoryFSHandlerBase() : wxFileSystemHandler()
 
87
{
 
88
}
 
89
 
 
90
wxMemoryFSHandlerBase::~wxMemoryFSHandlerBase()
 
91
{
 
92
    // as only one copy of FS handler is supposed to exist, we may silently
 
93
    // delete static data here. (There is no way how to remove FS handler from
 
94
    // wxFileSystem other than releasing _all_ handlers.)
 
95
    WX_CLEAR_HASH_MAP(wxMemoryFSHash, m_Hash);
 
96
}
 
97
 
 
98
bool wxMemoryFSHandlerBase::CanOpen(const wxString& location)
 
99
{
 
100
    return GetProtocol(location) == "memory";
 
101
}
 
102
 
 
103
wxFSFile * wxMemoryFSHandlerBase::OpenFile(wxFileSystem& WXUNUSED(fs),
 
104
                                           const wxString& location)
 
105
{
 
106
    wxMemoryFSHash::const_iterator i = m_Hash.find(GetRightLocation(location));
 
107
    if ( i == m_Hash.end() )
 
108
        return NULL;
 
109
 
 
110
    const wxMemoryFSFile * const obj = i->second;
 
111
 
 
112
    return new wxFSFile
 
113
               (
 
114
                    new wxMemoryInputStream(obj->m_Data, obj->m_Len),
 
115
                    location,
 
116
                    obj->m_MimeType,
 
117
                    GetAnchor(location)
 
118
#if wxUSE_DATETIME
 
119
                    , obj->m_Time
 
120
#endif // wxUSE_DATETIME
 
121
               );
 
122
}
 
123
 
 
124
wxString wxMemoryFSHandlerBase::FindFirst(const wxString& url, int flags)
 
125
{
 
126
    if ( (flags & wxDIR) && !(flags & wxFILE) )
 
127
    {
 
128
        // we only store files, not directories, so we don't risk finding
 
129
        // anything
 
130
        return wxString();
 
131
    }
 
132
 
 
133
    const wxString spec = GetRightLocation(url);
 
134
    if ( spec.find_first_of("?*") == wxString::npos )
 
135
    {
 
136
        // simple case: there are no wildcard characters so we can return
 
137
        // either 0 or 1 results and we can find the potential match quickly
 
138
        return m_Hash.count(spec) ? url : wxString();
 
139
    }
 
140
    //else: deal with wildcards in FindNext()
 
141
 
 
142
    m_findArgument = spec;
 
143
    m_findIter = m_Hash.begin();
 
144
 
 
145
    return FindNext();
 
146
}
 
147
 
 
148
wxString wxMemoryFSHandlerBase::FindNext()
 
149
{
 
150
    // m_findArgument is used to indicate that search is in progress, we reset
 
151
    // it to empty string after iterating over all elements
 
152
    while ( !m_findArgument.empty() )
 
153
    {
 
154
        // test for the match before (possibly) clearing m_findArgument below
 
155
        const bool found = m_findIter->first.Matches(m_findArgument);
 
156
 
 
157
        // advance m_findIter first as we need to do it anyhow, whether it
 
158
        // matches or not
 
159
        const wxMemoryFSHash::const_iterator current = m_findIter;
 
160
 
 
161
        if ( ++m_findIter == m_Hash.end() )
 
162
            m_findArgument.clear();
 
163
 
 
164
        if ( found )
 
165
            return "memory:" + current->first;
 
166
    }
 
167
 
 
168
    return wxString();
 
169
}
 
170
 
 
171
bool wxMemoryFSHandlerBase::CheckDoesntExist(const wxString& filename)
 
172
{
 
173
    if ( m_Hash.count(filename) )
 
174
    {
 
175
        wxLogError(_("Memory VFS already contains file '%s'!"), filename);
 
176
        return false;
 
177
    }
 
178
 
 
179
    return true;
 
180
}
 
181
 
 
182
 
 
183
/*static*/
 
184
void wxMemoryFSHandlerBase::AddFileWithMimeType(const wxString& filename,
 
185
                                                const wxString& textdata,
 
186
                                                const wxString& mimetype)
 
187
{
 
188
    const wxCharBuffer buf(textdata.To8BitData());
 
189
 
 
190
    AddFileWithMimeType(filename, buf.data(), buf.length(), mimetype);
 
191
}
 
192
 
 
193
 
 
194
/*static*/
 
195
void wxMemoryFSHandlerBase::AddFileWithMimeType(const wxString& filename,
 
196
                                                const void *binarydata, size_t size,
 
197
                                                const wxString& mimetype)
 
198
{
 
199
    if ( !CheckDoesntExist(filename) )
 
200
        return;
 
201
 
 
202
    m_Hash[filename] = new wxMemoryFSFile(binarydata, size, mimetype);
 
203
}
 
204
 
 
205
/*static*/
 
206
void wxMemoryFSHandlerBase::AddFile(const wxString& filename,
 
207
                                    const wxString& textdata)
 
208
{
 
209
    AddFileWithMimeType(filename, textdata, wxEmptyString);
 
210
}
 
211
 
 
212
 
 
213
/*static*/
 
214
void wxMemoryFSHandlerBase::AddFile(const wxString& filename,
 
215
                                    const void *binarydata, size_t size)
 
216
{
 
217
    AddFileWithMimeType(filename, binarydata, size, wxEmptyString);
 
218
}
 
219
 
 
220
 
 
221
 
 
222
/*static*/ void wxMemoryFSHandlerBase::RemoveFile(const wxString& filename)
 
223
{
 
224
    wxMemoryFSHash::iterator i = m_Hash.find(filename);
 
225
    if ( i == m_Hash.end() )
 
226
    {
 
227
        wxLogError(_("Trying to remove file '%s' from memory VFS, "
 
228
                     "but it is not loaded!"),
 
229
                   filename);
 
230
        return;
 
231
    }
 
232
 
 
233
    delete i->second;
 
234
    m_Hash.erase(i);
 
235
}
 
236
 
 
237
#endif // wxUSE_BASE
 
238
 
 
239
#if wxUSE_GUI
 
240
 
 
241
#if wxUSE_IMAGE
 
242
/*static*/ void
 
243
wxMemoryFSHandler::AddFile(const wxString& filename,
 
244
                           const wxImage& image,
 
245
                           wxBitmapType type)
 
246
{
 
247
    if ( !CheckDoesntExist(filename) )
 
248
        return;
 
249
 
 
250
    wxMemoryOutputStream mems;
 
251
    if ( image.IsOk() && image.SaveFile(mems, type) )
 
252
    {
 
253
        m_Hash[filename] = new wxMemoryFSFile
 
254
                               (
 
255
                                    mems,
 
256
                                    wxImage::FindHandler(type)->GetMimeType()
 
257
                               );
 
258
    }
 
259
    else
 
260
    {
 
261
        wxLogError(_("Failed to store image '%s' to memory VFS!"), filename);
 
262
    }
 
263
}
 
264
 
 
265
/*static*/ void
 
266
wxMemoryFSHandler::AddFile(const wxString& filename,
 
267
                           const wxBitmap& bitmap,
 
268
                           wxBitmapType type)
 
269
{
 
270
    wxImage img = bitmap.ConvertToImage();
 
271
    AddFile(filename, img, type);
 
272
}
 
273
 
 
274
#endif // wxUSE_IMAGE
 
275
 
 
276
#endif // wxUSE_GUI
 
277
 
 
278
 
 
279
#endif // wxUSE_FILESYSTEM && wxUSE_FS_ZIP