wxFSFile* wxLocalFSHandler::OpenFile(wxFileSystem& WXUNUSED(fs), const wxString& location)
{
// location has Unix path separators
wxString right = GetRightLocation(location);
wxFileName fn = wxFileSystem::URLToFileName(right);
wxString fullpath = ms_root + fn.GetFullPath();
if (!wxFileExists(fullpath))
return (wxFSFile*) NULL;
// we need to check whether we can really read from this file, otherwise
// wxFSFile is not going to work
#if wxUSE_FILE
wxFileInputStream *is = new wxFileInputStream(fullpath);
#elif wxUSE_FFILE
wxFFileInputStream *is = new wxFFileInputStream(fullpath);
#else
#error One of wxUSE_FILE or wxUSE_FFILE must be set to 1 for wxFSHandler to work
#endif
if ( !is->Ok() )
{
delete is;
return (wxFSFile*) NULL;
}
return new wxFSFile(is,
right,
GetMimeTypeFromExt(location),
GetAnchor(location)
#if wxUSE_DATETIME
,wxDateTime(wxFileModificationTime(fullpath))
#endif // wxUSE_DATETIME
);
}
wxFSFile* wxChmFSHandler::OpenFile(wxFileSystem& WXUNUSED(fs),
const wxString& location)
{
wxString right = GetRightLocation(location);
wxString left = GetLeftLocation(location);
wxInputStream *s;
int index;
if ( GetProtocol(left) != _T("file") )
{
wxLogError(_("CHM handler currently supports only local files!"));
return NULL;
}
// Work around javascript
wxString tmp = wxString(right);
if ( tmp.MakeLower().Contains(_T("javascipt")) && tmp.Contains(_T("\'")) )
{
right = right.AfterFirst(_T('\'')).BeforeLast(_T('\''));
}
// now work on the right location
if (right.Contains(_T("..")))
{
wxFileName abs(right);
abs.MakeAbsolute(_T("/"));
right = abs.GetFullPath();
}
// a workaround for absolute links to root
if ( (index=right.Index(_T("//"))) != wxNOT_FOUND )
{
right=wxString(right.Mid(index+1));
wxLogWarning(_("Link contained '//', converted to absolute link."));
}
wxFileName leftFilename = wxFileSystem::URLToFileName(left);
// Open a stream to read the content of the chm-file
s = new wxChmInputStream(leftFilename.GetFullPath(), right, true);
wxString mime = GetMimeTypeFromExt(location);
if ( s )
{
return new wxFSFile(s,
left + _T("#chm:") + right,
mime,
GetAnchor(location),
wxDateTime(wxFileModificationTime(left)));
}
delete s;
return NULL;
}
wxFSFile* wxZipFSHandler::OpenFile(wxFileSystem& WXUNUSED(fs), const wxString& location)
{
wxString right = GetRightLocation(location);
wxString left = GetLeftLocation(location);
wxZipInputStream *s;
if (right.Contains(wxT("./")))
{
if (right.GetChar(0) != wxT('/')) right = wxT('/') + right;
wxFileName rightPart(right, wxPATH_UNIX);
rightPart.Normalize(wxPATH_NORM_DOTS, wxT("/"), wxPATH_UNIX);
right = rightPart.GetFullPath(wxPATH_UNIX);
}
if (right.GetChar(0) == wxT('/')) right = right.Mid(1);
// a new wxFileSystem object is needed here to avoid infinite recursion
wxFSFile *leftFile = wxFileSystem().OpenFile(left);
if (!leftFile)
return NULL;
s = new wxZipFSInputStream(leftFile);
if (s && s->IsOk())
{
bool found = false;
while (!found)
{
wxZipEntry *ent = s->GetNextEntry();
if (!ent)
break;
if (ent->GetInternalName() == right)
found = true;
delete ent;
}
if (found)
return new wxFSFile(s,
left + wxT("#zip:") + right,
GetMimeTypeFromExt(location),
GetAnchor(location)
#if wxUSE_DATETIME
, wxDateTime(wxFileModificationTime(left))
#endif // wxUSE_DATETIME
);
}
delete s;
return NULL;
}
wxFSFile*
BuiltinHtmlHelpFSHandler::OpenFile(wxFileSystem&, const wxString& location)
{
if (location.Left(5) != _T("help:"))
return NULL;
wxString path = location.Mid(5);
wxString anchor;
if (path.Find('#',true) != wxNOT_FOUND)
{
anchor = path.AfterLast('#');
path = path.BeforeLast('#');
}
for (unsigned int i = 0; i < filelistsize; ++i)
{
if (filelist[i].path == path)
{
wxLogDebug(_T("Found found : %s"), filelist[i].path.c_str());
if (filelist[i].decompressed_data.size() == 0)
{
// decompress file data
filelist[i].decompressed_data = decompress(filelist[i].compressed_data,
filelist[i].compressed_size,
filelist[i].uncompressed_size);
}
wxMemoryInputStream* ms = new wxMemoryInputStream( filelist[i].decompressed_data.data(),
filelist[i].decompressed_data.size() );
return new wxFSFile(ms,
location,
GetMimeTypeFromExt(path),
anchor,
wxDateTime::Now());
}
}
wxLogDebug(_T("BuiltinHelp: could not serve file %s"), location.c_str());
return NULL;
}
wxFSFile* wxFilterFSHandler::OpenFile(
wxFileSystem& fs,
const wxString& location)
{
wxString right = GetRightLocation(location);
if (!right.empty())
return NULL;
wxString protocol = GetProtocol(location);
const wxFilterClassFactory *factory = wxFilterClassFactory::Find(protocol);
if (!factory)
return NULL;
wxString left = GetLeftLocation(location);
wxFSFilePtr leftFile(fs.OpenFile(left));
if (!leftFile.get())
return NULL;
wxInputStreamPtr leftStream(leftFile->DetachStream());
if (!leftStream.get() || !leftStream->IsOk())
return NULL;
wxInputStreamPtr stream(factory->NewStream(leftStream.release()));
// The way compressed streams are supposed to be served is e.g.:
// Content-type: application/postscript
// Content-encoding: gzip
// So the mime type should be just the mime type of the lhs. However check
// whether the mime type is that of this compression format (e.g.
// application/gzip). If so pop any extension and try GetMimeTypeFromExt,
// e.g. if it were '.ps.gz' pop the '.gz' and try looking up '.ps'
wxString mime = leftFile->GetMimeType();
if (factory->CanHandle(mime, wxSTREAM_MIMETYPE))
mime = GetMimeTypeFromExt(factory->PopExtension(left));
return new wxFSFile(stream.release(),
left + wxT("#") + protocol + wxT(":") + right,
mime,
GetAnchor(location)
#if wxUSE_DATETIME
, leftFile->GetModificationTime()
#endif // wxUSE_DATETIME
);
}
wxFSFile* wxInternetFSHandler::OpenFile(wxFileSystem& WXUNUSED(fs),
const wxString& location)
{
#if !wxUSE_URL
return NULL;
#else
wxString right =
GetProtocol(location) + wxT(":") + StripProtocolAnchor(location);
wxURL url(right);
if (url.GetError() == wxURL_NOERR)
{
wxInputStream *s = url.GetInputStream();
wxString content = url.GetProtocol().GetContentType();
if (content == wxEmptyString) content = GetMimeTypeFromExt(location);
if (s)
{
wxString tmpfile =
wxFileName::CreateTempFileName(wxT("wxhtml"));
{ // now copy streams content to temporary file:
wxFileOutputStream sout(tmpfile);
s->Read(sout);
}
delete s;
return new wxFSFile(new wxTemporaryFileInputStream(tmpfile),
right,
content,
GetAnchor(location)
#if wxUSE_DATETIME
, wxDateTime::Now()
#endif // wxUSE_DATETIME
);
}
}
return (wxFSFile*) NULL; // incorrect URL
#endif
}
wxFSFile* wxArchiveFSHandler::OpenFile(
wxFileSystem& WXUNUSED(fs),
const wxString& location)
{
wxString right = GetRightLocation(location);
wxString left = GetLeftLocation(location);
wxString protocol = GetProtocol(location);
wxString key = left + wxT("#") + protocol + wxT(":");
if (right.Contains(wxT("./")))
{
if (right.GetChar(0) != wxT('/')) right = wxT('/') + right;
wxFileName rightPart(right, wxPATH_UNIX);
rightPart.Normalize(wxPATH_NORM_DOTS, wxT("/"), wxPATH_UNIX);
right = rightPart.GetFullPath(wxPATH_UNIX);
}
if (right.GetChar(0) == wxT('/')) right = right.Mid(1);
if (!m_cache)
m_cache = new wxArchiveFSCache;
const wxArchiveClassFactory *factory;
factory = wxArchiveClassFactory::Find(protocol);
if (!factory)
return NULL;
wxArchiveFSCacheData *cached = m_cache->Get(key);
if (!cached)
{
wxFSFile *leftFile = m_fs.OpenFile(left);
if (!leftFile)
return NULL;
cached = m_cache->Add(key, *factory, leftFile->DetachStream());
delete leftFile;
}
wxArchiveEntry *entry = cached->Get(right);
if (!entry)
return NULL;
wxInputStream *leftStream = cached->NewStream();
if (!leftStream)
{
wxFSFile *leftFile = m_fs.OpenFile(left);
if (!leftFile)
return NULL;
leftStream = leftFile->DetachStream();
delete leftFile;
}
wxArchiveInputStream *s = factory->NewStream(leftStream);
s->OpenEntry(*entry);
if (s && s->IsOk())
{
#if WXWIN_COMPATIBILITY_2_6 && wxUSE_ZIPSTREAM
if (factory->IsKindOf(CLASSINFO(wxZipClassFactory)))
((wxZipInputStream*)s)->m_allowSeeking = true;
#endif // WXWIN_COMPATIBILITY_2_6
return new wxFSFile(s,
key + right,
GetMimeTypeFromExt(location),
GetAnchor(location)
#if wxUSE_DATETIME
, entry->GetDateTime()
#endif // wxUSE_DATETIME
);
}
delete s;
return NULL;
}
