src/common/filesys.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        filesys.cpp
// Purpose:     wxFileSystem class - interface for opening files
// Author:      Vaclav Slavik
// Copyright:   (c) 1999 Vaclav Slavik
// CVS-ID:      $Id$
// Licence:     wxWindows Licence
/////////////////////////////////////////////////////////////////////////////

#ifdef __GNUG__
#pragma implementation "filesys.h"
#endif

#include "wx/wxprec.h"

#ifdef __BORLANDC__
#pragma hdrstop
#endif


#if wxUSE_FILESYSTEM

#include "wx/wfstream.h"
#include "wx/module.h"
#include "wx/filesys.h"
#include "wx/mimetype.h"
#include "wx/filename.h"
#include "wx/log.h"


//--------------------------------------------------------------------------------
// wxFileSystemHandler
//--------------------------------------------------------------------------------

IMPLEMENT_ABSTRACT_CLASS(wxFileSystemHandler, wxObject)


#if wxUSE_MIMETYPE
static wxFileTypeInfo *gs_FSMimeFallbacks = NULL;
#endif

wxString wxFileSystemHandler::GetMimeTypeFromExt(const wxString& location)
{
    wxString ext, mime;
    wxString loc = GetRightLocation(location);
    char c;
    int l = loc.Length(), l2;

    l2 = l;
    for (int i = l-1; i >= 0; i--)
    {
        c = loc[(unsigned int) i];
        if ( c == wxT('#') )
            l2 = i + 1;
        if ( c == wxT('.') )
        {
            ext = loc.Right(l2-i-1);
            break;
        }
        if ( (c == wxT('/')) || (c == wxT('\\')) || (c == wxT(':')) )
            return wxEmptyString;
    }

#if wxUSE_MIMETYPE
    static bool s_MinimalMimeEnsured = FALSE;
    if (!s_MinimalMimeEnsured) {
        wxTheMimeTypesManager->AddFallbacks(gs_FSMimeFallbacks);
        s_MinimalMimeEnsured = TRUE;
    }

    wxFileType *ft = wxTheMimeTypesManager->GetFileTypeFromExtension(ext);
    if ( !ft || !ft -> GetMimeType(&mime) )
    {
        mime = wxEmptyString;
    }

    delete ft;

    return mime;
#else
    if ( ext.IsSameAs(wxT("htm"), FALSE) || ext.IsSameAs(_T("html"), FALSE) )
        return wxT("text/html");
    if ( ext.IsSameAs(wxT("jpg"), FALSE) || ext.IsSameAs(_T("jpeg"), FALSE) )
        return wxT("image/jpeg");
    if ( ext.IsSameAs(wxT("gif"), FALSE) )
        return wxT("image/gif");
    if ( ext.IsSameAs(wxT("png"), FALSE) )
        return wxT("image/png");
    if ( ext.IsSameAs(wxT("bmp"), FALSE) )
        return wxT("image/bmp");
    return wxEmptyString;
#endif
}


wxString wxFileSystemHandler::GetProtocol(const wxString& location) const
{
    wxString s = wxEmptyString;
    int i, l = location.Length();
    bool fnd;

    fnd = FALSE;
    for (i = l-1; (i >= 0) && ((location[i] != wxT('#')) || (!fnd)); i--) {
        if ((location[i] == wxT(':')) && (i != 1 /*win: C:\path*/)) fnd = TRUE;
    }
    if (!fnd) return wxT("file");
    for (++i; (i < l) && (location[i] != wxT(':')); i++) s << location[i];
    return s;
}


wxString wxFileSystemHandler::GetLeftLocation(const wxString& location) const
{
    int i;
    bool fnd;

    fnd = FALSE;
    for (i = location.Length()-1; i >= 0; i--) {
        if ((location[i] == wxT(':')) && (i != 1 /*win: C:\path*/)) fnd = TRUE;
        else if (fnd && (location[i] == wxT('#'))) return location.Left(i);
    }
    return wxEmptyString;
}

wxString wxFileSystemHandler::GetRightLocation(const wxString& location) const
{
    int i, l = location.Length();
    int l2 = l + 1;

    for (i = l-1;
         (i >= 0) &&
         ((location[i] != wxT(':')) || (i == 1) || (location[i-2] == wxT(':')));
         i--)
    {
        if (location[i] == wxT('#')) l2 = i + 1;
    }
    if (i == 0) return wxEmptyString;
    else return location.Mid(i + 1, l2 - i - 2);
}

wxString wxFileSystemHandler::GetAnchor(const wxString& location) const
{
    char c;
    int l = location.Length();

    for (int i = l-1; i >= 0; i--) {
        c = location[i];
        if (c == wxT('#')) return location.Right(l-i-1);
        else if ((c == wxT('.')) || (c == wxT('/')) || (c == wxT('\\')) || (c == wxT(':'))) return wxEmptyString;
    }
    return wxEmptyString;
}


wxString wxFileSystemHandler::FindFirst(const wxString& WXUNUSED(spec),
                                        int WXUNUSED(flags))
{
    return wxEmptyString;
}

wxString wxFileSystemHandler::FindNext()
{
    return wxEmptyString;
}

//--------------------------------------------------------------------------------
// wxLocalFSHandler
//--------------------------------------------------------------------------------


wxString wxLocalFSHandler::ms_root;

bool wxLocalFSHandler::CanOpen(const wxString& location)
{
    return GetProtocol(location) == wxT("file");
}

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;

    return new wxFSFile(new wxFFileInputStream(fullpath),
                        right,
                        GetMimeTypeFromExt(location),
                        GetAnchor(location)
#if wxUSE_DATETIME
                        ,wxDateTime(wxFileModificationTime(fullpath))
#endif // wxUSE_DATETIME
                        );
}

wxString wxLocalFSHandler::FindFirst(const wxString& spec, int flags)
{
    wxFileName fn = wxFileSystem::URLToFileName(GetRightLocation(spec));
    return wxFindFirstFile(ms_root + fn.GetFullPath(), flags);
}

wxString wxLocalFSHandler::FindNext()
{
    return wxFindNextFile();
}


//-----------------------------------------------------------------------------
// wxFileSystem
//-----------------------------------------------------------------------------

IMPLEMENT_DYNAMIC_CLASS(wxFileSystem, wxObject)
IMPLEMENT_ABSTRACT_CLASS(wxFSFile, wxObject)


wxList wxFileSystem::m_Handlers;


static wxString MakeCorrectPath(const wxString& path)
{
    wxString p(path);
    wxString r;
    int i, j, cnt;

    cnt = p.Length();
    for (i = 0; i < cnt; i++)
      if (p.GetChar(i) == wxT('\\')) p.GetWritableChar(i) = wxT('/'); // Want to be windows-safe

    if (p.Left(2) == wxT("./")) { p = p.Mid(2); cnt -= 2; }

    if (cnt < 3) return p;

    r << p.GetChar(0) << p.GetChar(1);

    // skip trailing ../.., if any
    for (i = 2; i < cnt && (p.GetChar(i) == wxT('/') || p.GetChar(i) == wxT('.')); i++) r << p.GetChar(i);

    // remove back references: translate dir1/../dir2 to dir2
    for (; i < cnt; i++)
    {
        r << p.GetChar(i);
        if (p.GetChar(i) == wxT('/') && p.GetChar(i-1) == wxT('.') && p.GetChar(i-2) == wxT('.'))
        {
            for (j = r.Length() - 2; j >= 0 && r.GetChar(j) != wxT('/') && r.GetChar(j) != wxT(':'); j--) {}
            if (j >= 0 && r.GetChar(j) != wxT(':'))
            {
                for (j = j - 1; j >= 0 && r.GetChar(j) != wxT('/') && r.GetChar(j) != wxT(':'); j--) {}
                r.Remove(j + 1);
            }
        }
    }

    for (; i < cnt; i++) r << p.GetChar(i);

    return r;
}


void wxFileSystem::ChangePathTo(const wxString& location, bool is_dir)
{
    int i, pathpos = -1;

    m_Path = MakeCorrectPath(location);

    if (is_dir)
    {
        if (m_Path.Length() > 0 && m_Path.Last() != wxT('/') && m_Path.Last() != wxT(':'))
            m_Path << wxT('/');
    }

    else
    {
        for (i = m_Path.Length()-1; i >= 0; i--)
        {
            if (m_Path[(unsigned int) i] == wxT('/'))
            {
                if ((i > 1) && (m_Path[(unsigned int) (i-1)] == wxT('/')) && (m_Path[(unsigned int) (i-2)] == wxT(':')))
                {
                    i -= 2;
                    continue;
                }
                else
                {
                    pathpos = i;
                    break;
                }
            }
            else if (m_Path[(unsigned int) i] == wxT(':')) {
                pathpos = i;
                break;
            }
        }
        if (pathpos == -1)
        {
            for (i = 0; i < (int) m_Path.Length(); i++)
            {
                if (m_Path[(unsigned int) i] == wxT(':'))
                {
                    m_Path.Remove(i+1);
                    break;
                }
            }
            if (i == (int) m_Path.Length())
                m_Path = wxEmptyString;
        }
        else
        {
            m_Path.Remove(pathpos+1);
        }
    }
}


wxFSFile* wxFileSystem::OpenFile(const wxString& location)
{
    wxString loc = MakeCorrectPath(location);
    unsigned i, ln;
    char meta;
    wxFSFile *s = NULL;
    wxNode *node;

    ln = loc.Length();
    meta = 0;
    for (i = 0; i < ln; i++)
    {
        switch (loc[i])
        {
            case wxT('/') : case wxT(':') : case wxT('#') :
                meta = loc[i];
                break;
        }
        if (meta != 0) break;
    }
    m_LastName = wxEmptyString;

    // try relative paths first :
    if (meta != wxT(':'))
    {
        node = m_Handlers.GetFirst();
        while (node)
        {
            wxFileSystemHandler *h = (wxFileSystemHandler*) node -> GetData();
            if (h->CanOpen(m_Path + loc))
            {
                s = h->OpenFile(*this, m_Path + loc);
                if (s) { m_LastName = m_Path + loc; break; }
            }
            node = node->GetNext();
        }
    }

    // if failed, try absolute paths :
    if (s == NULL)
    {
        node = m_Handlers.GetFirst();
        while (node)
        {
            wxFileSystemHandler *h = (wxFileSystemHandler*) node->GetData();
            if (h->CanOpen(loc))
            {
                s = h->OpenFile(*this, loc);
                if (s) { m_LastName = loc; break; }
            }
            node = node->GetNext();
        }
    }
    return (s);
}


wxString wxFileSystem::FindFirst(const wxString& spec, int flags)
{
    wxNode *node;
    wxString spec2(spec);

    m_FindFileHandler = NULL;

    for (int i = spec2.Length()-1; i >= 0; i--)
        if (spec2[(unsigned int) i] == wxT('\\')) spec2.GetWritableChar(i) = wxT('/'); // Want to be windows-safe

    node = m_Handlers.GetFirst();
    while (node)
    {
        m_FindFileHandler = (wxFileSystemHandler*) node -> GetData();
        if (m_FindFileHandler -> CanOpen(m_Path + spec2))
            return m_FindFileHandler -> FindFirst(m_Path + spec2, flags);
        node = node->GetNext();
    }

    node = m_Handlers.GetFirst();
    while (node)
    {
        m_FindFileHandler = (wxFileSystemHandler*) node -> GetData();
        if (m_FindFileHandler -> CanOpen(spec2))
            return m_FindFileHandler -> FindFirst(spec2, flags);
        node = node->GetNext();
    }

    return wxEmptyString;
}


wxString wxFileSystem::FindNext()
{
    if (m_FindFileHandler == NULL) return wxEmptyString;
    else return m_FindFileHandler -> FindNext();
}


void wxFileSystem::AddHandler(wxFileSystemHandler *handler)
{
    m_Handlers.Append(handler);
}


void wxFileSystem::CleanUpHandlers()
{
    m_Handlers.DeleteContents(TRUE);
    m_Handlers.Clear();
}

const static wxString g_unixPathString(wxT("/"));
const static wxString g_nativePathString(wxFILE_SEP_PATH);

// Returns the native path for a file URL
wxFileName wxFileSystem::URLToFileName(const wxString& url)
{
	wxString path = url;

	if ( path.Find(wxT("file://")) == 0 )
	{
		path = path.Mid(7);
	}
    else if ( path.Find(wxT("file:")) == 0 )
	{
		path = path.Mid(5);
	}
	// Remove preceding double slash on Mac Classic
#if defined(__WXMAC__) && !defined(__UNIX__)
    else if ( path.Find(wxT("//")) == 0 )
        path = path.Mid(2);
#endif

    path.Replace(wxT("%25"), wxT("%"));
    path.Replace(wxT("%3A"), wxT(":"));

#ifdef __WXMSW__
	// file urls either start with a forward slash (local harddisk),
    // otherwise they have a servername/sharename notation,
    // which only exists on msw and corresponds to a unc
	if ( path[0u] == wxT('/') && path [1u] != wxT('/'))
	{
		path = path.Mid(1);
	}
	else if ( (url.Find(wxT("file://")) == 0) &&
              (path.Find(wxT('/')) != wxNOT_FOUND) &&
              (path.Length() > 1) && (path[1u] != wxT(':')) )
	{
		path = wxT("//") + path;
	}
#endif

	path.Replace(g_unixPathString, g_nativePathString);

	return wxFileName(path, wxPATH_NATIVE);
}

// Returns the file URL for a native path
wxString wxFileSystem::FileNameToURL(const wxFileName& filename)
{
    wxFileName fn = filename;
    fn.Normalize(wxPATH_NORM_DOTS | wxPATH_NORM_TILDE | wxPATH_NORM_ABSOLUTE);
    wxString url = fn.GetFullPath(wxPATH_NATIVE);

#ifndef __UNIX__
    // unc notation, wxMSW
    if ( url.Find(wxT("\\\\")) == 0 )
    {
        url = url.Mid(2);
    }
    else
    {
        url = wxT("/") + url;
#ifdef __WXMAC__
        url = wxT("/") + url;
#endif

    }
#endif

    url.Replace(g_nativePathString, g_unixPathString);
    url.Replace(wxT("%"), wxT("%25"));
    url.Replace(wxT(":"), wxT("%3A"));
    url = wxT("file:") + url;
    return url;
}


///// Module:

class wxFileSystemModule : public wxModule
{
    DECLARE_DYNAMIC_CLASS(wxFileSystemModule)

    public:
        virtual bool OnInit()
        {
            wxFileSystem::AddHandler(new wxLocalFSHandler);

        #if wxUSE_MIMETYPE
            gs_FSMimeFallbacks = new wxFileTypeInfo[6];
            gs_FSMimeFallbacks[0] =
            wxFileTypeInfo(_T("image/jpeg"),
                           _T(""),
                           _T(""),
                           _T("JPEG image (from fallback)"),
                           _T("jpg"), _T("jpeg"), NULL);
            gs_FSMimeFallbacks[1] =
            wxFileTypeInfo(_T("image/gif"),
                           _T(""),
                           _T(""),
                           _T("GIF image (from fallback)"),
                           _T("gif"), NULL);
            gs_FSMimeFallbacks[2] =
            wxFileTypeInfo(_T("image/png"),
                           _T(""),
                           _T(""),
                           _T("PNG image (from fallback)"),
                           _T("png"), NULL);
            gs_FSMimeFallbacks[3] =
            wxFileTypeInfo(_T("image/bmp"),
                           _T(""),
                           _T(""),
                           _T("windows bitmap image (from fallback)"),
                           _T("bmp"), NULL);
            gs_FSMimeFallbacks[4] =
            wxFileTypeInfo(_T("text/html"),
                           _T(""),
                           _T(""),
                           _T("HTML document (from fallback)"),
                           _T("htm"), _T("html"), NULL);
            gs_FSMimeFallbacks[5] =
            // must terminate the table with this!
            wxFileTypeInfo();
        #endif
            return TRUE;
        }
        virtual void OnExit()
        {
        #if wxUSE_MIMETYPE
            delete [] gs_FSMimeFallbacks;
        #endif
            wxFileSystem::CleanUpHandlers();
        }
};

IMPLEMENT_DYNAMIC_CLASS(wxFileSystemModule, wxModule)

#endif
  // wxUSE_FILESYSTEM
Commit	Line	Data
	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 "filesys.h"
	12	#endif
	13
	14	#include "wx/wxprec.h"
	15
	16	#ifdef __BORLANDC__
	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	#include "wx/filename.h"
	28	#include "wx/log.h"
	29
	30
	31
	32	//--------------------------------------------------------------------------------
	33	// wxFileSystemHandler
	34	//--------------------------------------------------------------------------------
	35
	36	IMPLEMENT_ABSTRACT_CLASS(wxFileSystemHandler, wxObject)
	37
	38
	39	#if wxUSE_MIMETYPE
	40	static wxFileTypeInfo *gs_FSMimeFallbacks = NULL;
	41	#endif
	42
	43	wxString wxFileSystemHandler::GetMimeTypeFromExt(const wxString& location)
	44	{
	45	wxString ext, mime;
	46	wxString loc = GetRightLocation(location);
	47	char c;
	48	int l = loc.Length(), l2;
	49
	50	l2 = l;
	51	for (int i = l-1; i >= 0; i--)
	52	{
	53	c = loc[(unsigned int) i];
	54	if ( c == wxT('#') )
	55	l2 = i + 1;
	56	if ( c == wxT('.') )
	57	{
	58	ext = loc.Right(l2-i-1);
	59	break;
	60	}
	61	if ( (c == wxT('/')) \|\| (c == wxT('\\')) \|\| (c == wxT(':')) )
	62	return wxEmptyString;
	63	}
	64
	65	#if wxUSE_MIMETYPE
	66	static bool s_MinimalMimeEnsured = FALSE;
	67	if (!s_MinimalMimeEnsured) {
	68	wxTheMimeTypesManager->AddFallbacks(gs_FSMimeFallbacks);
	69	s_MinimalMimeEnsured = TRUE;
	70	}
	71
	72	wxFileType *ft = wxTheMimeTypesManager->GetFileTypeFromExtension(ext);
	73	if ( !ft \|\| !ft -> GetMimeType(&mime) )
	74	{
	75	mime = wxEmptyString;
	76	}
	77
	78	delete ft;
	79
	80	return mime;
	81	#else
	82	if ( ext.IsSameAs(wxT("htm"), FALSE) \|\| ext.IsSameAs(_T("html"), FALSE) )
	83	return wxT("text/html");
	84	if ( ext.IsSameAs(wxT("jpg"), FALSE) \|\| ext.IsSameAs(_T("jpeg"), FALSE) )
	85	return wxT("image/jpeg");
	86	if ( ext.IsSameAs(wxT("gif"), FALSE) )
	87	return wxT("image/gif");
	88	if ( ext.IsSameAs(wxT("png"), FALSE) )
	89	return wxT("image/png");
	90	if ( ext.IsSameAs(wxT("bmp"), FALSE) )
	91	return wxT("image/bmp");
	92	return wxEmptyString;
	93	#endif
	94	}
	95
	96
	97
	98	wxString wxFileSystemHandler::GetProtocol(const wxString& location) const
	99	{
	100	wxString s = wxEmptyString;
	101	int i, l = location.Length();
	102	bool fnd;
	103
	104	fnd = FALSE;
	105	for (i = l-1; (i >= 0) && ((location[i] != wxT('#')) \|\| (!fnd)); i--) {
	106	if ((location[i] == wxT(':')) && (i != 1 /win: C:\path/)) fnd = TRUE;
	107	}
	108	if (!fnd) return wxT("file");
	109	for (++i; (i < l) && (location[i] != wxT(':')); i++) s << location[i];
	110	return s;
	111	}
	112
	113
	114	wxString wxFileSystemHandler::GetLeftLocation(const wxString& location) const
	115	{
	116	int i;
	117	bool fnd;
	118
	119	fnd = FALSE;
	120	for (i = location.Length()-1; i >= 0; i--) {
	121	if ((location[i] == wxT(':')) && (i != 1 /win: C:\path/)) fnd = TRUE;
	122	else if (fnd && (location[i] == wxT('#'))) return location.Left(i);
	123	}
	124	return wxEmptyString;
	125	}
	126
	127	wxString wxFileSystemHandler::GetRightLocation(const wxString& location) const
	128	{
	129	int i, l = location.Length();
	130	int l2 = l + 1;
	131
	132	for (i = l-1;
	133	(i >= 0) &&
	134	((location[i] != wxT(':')) \|\| (i == 1) \|\| (location[i-2] == wxT(':')));
	135	i--)
	136	{
	137	if (location[i] == wxT('#')) l2 = i + 1;
	138	}
	139	if (i == 0) return wxEmptyString;
	140	else return location.Mid(i + 1, l2 - i - 2);
	141	}
	142
	143	wxString wxFileSystemHandler::GetAnchor(const wxString& location) const
	144	{
	145	char c;
	146	int l = location.Length();
	147
	148	for (int i = l-1; i >= 0; i--) {
	149	c = location[i];
	150	if (c == wxT('#')) return location.Right(l-i-1);
	151	else if ((c == wxT('.')) \|\| (c == wxT('/')) \|\| (c == wxT('\\')) \|\| (c == wxT(':'))) return wxEmptyString;
	152	}
	153	return wxEmptyString;
	154	}
	155
	156
	157	wxString wxFileSystemHandler::FindFirst(const wxString& WXUNUSED(spec),
	158	int WXUNUSED(flags))
	159	{
	160	return wxEmptyString;
	161	}
	162
	163	wxString wxFileSystemHandler::FindNext()
	164	{
	165	return wxEmptyString;
	166	}
	167
	168	//--------------------------------------------------------------------------------
	169	// wxLocalFSHandler
	170	//--------------------------------------------------------------------------------
	171
	172
	173	wxString wxLocalFSHandler::ms_root;
	174
	175	bool wxLocalFSHandler::CanOpen(const wxString& location)
	176	{
	177	return GetProtocol(location) == wxT("file");
	178	}
	179
	180	wxFSFile* wxLocalFSHandler::OpenFile(wxFileSystem& WXUNUSED(fs), const wxString& location)
	181	{
	182	// location has Unix path separators
	183	wxString right = GetRightLocation(location);
	184	wxFileName fn = wxFileSystem::URLToFileName(right);
	185	wxString fullpath = ms_root + fn.GetFullPath();
	186
	187	if (!wxFileExists(fullpath))
	188	return (wxFSFile*) NULL;
	189
	190	return new wxFSFile(new wxFFileInputStream(fullpath),
	191	right,
	192	GetMimeTypeFromExt(location),
	193	GetAnchor(location)
	194	#if wxUSE_DATETIME
	195	,wxDateTime(wxFileModificationTime(fullpath))
	196	#endif // wxUSE_DATETIME
	197	);
	198	}
	199
	200	wxString wxLocalFSHandler::FindFirst(const wxString& spec, int flags)
	201	{
	202	wxFileName fn = wxFileSystem::URLToFileName(GetRightLocation(spec));
	203	return wxFindFirstFile(ms_root + fn.GetFullPath(), flags);
	204	}
	205
	206	wxString wxLocalFSHandler::FindNext()
	207	{
	208	return wxFindNextFile();
	209	}
	210
	211
	212
	213	//-----------------------------------------------------------------------------
	214	// wxFileSystem
	215	//-----------------------------------------------------------------------------
	216
	217	IMPLEMENT_DYNAMIC_CLASS(wxFileSystem, wxObject)
	218	IMPLEMENT_ABSTRACT_CLASS(wxFSFile, wxObject)
	219
	220
	221	wxList wxFileSystem::m_Handlers;
	222
	223
	224	static wxString MakeCorrectPath(const wxString& path)
	225	{
	226	wxString p(path);
	227	wxString r;
	228	int i, j, cnt;
	229
	230	cnt = p.Length();
	231	for (i = 0; i < cnt; i++)
	232	if (p.GetChar(i) == wxT('\\')) p.GetWritableChar(i) = wxT('/'); // Want to be windows-safe
	233
	234	if (p.Left(2) == wxT("./")) { p = p.Mid(2); cnt -= 2; }
	235
	236	if (cnt < 3) return p;
	237
	238	r << p.GetChar(0) << p.GetChar(1);
	239
	240	// skip trailing ../.., if any
	241	for (i = 2; i < cnt && (p.GetChar(i) == wxT('/') \|\| p.GetChar(i) == wxT('.')); i++) r << p.GetChar(i);
	242
	243	// remove back references: translate dir1/../dir2 to dir2
	244	for (; i < cnt; i++)
	245	{
	246	r << p.GetChar(i);
	247	if (p.GetChar(i) == wxT('/') && p.GetChar(i-1) == wxT('.') && p.GetChar(i-2) == wxT('.'))
	248	{
	249	for (j = r.Length() - 2; j >= 0 && r.GetChar(j) != wxT('/') && r.GetChar(j) != wxT(':'); j--) {}
	250	if (j >= 0 && r.GetChar(j) != wxT(':'))
	251	{
	252	for (j = j - 1; j >= 0 && r.GetChar(j) != wxT('/') && r.GetChar(j) != wxT(':'); j--) {}
	253	r.Remove(j + 1);
	254	}
	255	}
	256	}
	257
	258	for (; i < cnt; i++) r << p.GetChar(i);
	259
	260	return r;
	261	}
	262
	263
	264	void wxFileSystem::ChangePathTo(const wxString& location, bool is_dir)
	265	{
	266	int i, pathpos = -1;
	267
	268	m_Path = MakeCorrectPath(location);
	269
	270	if (is_dir)
	271	{
	272	if (m_Path.Length() > 0 && m_Path.Last() != wxT('/') && m_Path.Last() != wxT(':'))
	273	m_Path << wxT('/');
	274	}
	275
	276	else
	277	{
	278	for (i = m_Path.Length()-1; i >= 0; i--)
	279	{
	280	if (m_Path[(unsigned int) i] == wxT('/'))
	281	{
	282	if ((i > 1) && (m_Path[(unsigned int) (i-1)] == wxT('/')) && (m_Path[(unsigned int) (i-2)] == wxT(':')))
	283	{
	284	i -= 2;
	285	continue;
	286	}
	287	else
	288	{
	289	pathpos = i;
	290	break;
	291	}
	292	}
	293	else if (m_Path[(unsigned int) i] == wxT(':')) {
	294	pathpos = i;
	295	break;
	296	}
	297	}
	298	if (pathpos == -1)
	299	{
	300	for (i = 0; i < (int) m_Path.Length(); i++)
	301	{
	302	if (m_Path[(unsigned int) i] == wxT(':'))
	303	{
	304	m_Path.Remove(i+1);
	305	break;
	306	}
	307	}
	308	if (i == (int) m_Path.Length())
	309	m_Path = wxEmptyString;
	310	}
	311	else
	312	{
	313	m_Path.Remove(pathpos+1);
	314	}
	315	}
	316	}
	317
	318
	319
	320	wxFSFile* wxFileSystem::OpenFile(const wxString& location)
	321	{
	322	wxString loc = MakeCorrectPath(location);
	323	unsigned i, ln;
	324	char meta;
	325	wxFSFile *s = NULL;
	326	wxNode *node;
	327
	328	ln = loc.Length();
	329	meta = 0;
	330	for (i = 0; i < ln; i++)
	331	{
	332	switch (loc[i])
	333	{
	334	case wxT('/') : case wxT(':') : case wxT('#') :
	335	meta = loc[i];
	336	break;
	337	}
	338	if (meta != 0) break;
	339	}
	340	m_LastName = wxEmptyString;
	341
	342	// try relative paths first :
	343	if (meta != wxT(':'))
	344	{
	345	node = m_Handlers.GetFirst();
	346	while (node)
	347	{
	348	wxFileSystemHandler h = (wxFileSystemHandler) node -> GetData();
	349	if (h->CanOpen(m_Path + loc))
	350	{
	351	s = h->OpenFile(*this, m_Path + loc);
	352	if (s) { m_LastName = m_Path + loc; break; }
	353	}
	354	node = node->GetNext();
	355	}
	356	}
	357
	358	// if failed, try absolute paths :
	359	if (s == NULL)
	360	{
	361	node = m_Handlers.GetFirst();
	362	while (node)
	363	{
	364	wxFileSystemHandler h = (wxFileSystemHandler) node->GetData();
	365	if (h->CanOpen(loc))
	366	{
	367	s = h->OpenFile(*this, loc);
	368	if (s) { m_LastName = loc; break; }
	369	}
	370	node = node->GetNext();
	371	}
	372	}
	373	return (s);
	374	}
	375
	376
	377
	378	wxString wxFileSystem::FindFirst(const wxString& spec, int flags)
	379	{
	380	wxNode *node;
	381	wxString spec2(spec);
	382
	383	m_FindFileHandler = NULL;
	384
	385	for (int i = spec2.Length()-1; i >= 0; i--)
	386	if (spec2[(unsigned int) i] == wxT('\\')) spec2.GetWritableChar(i) = wxT('/'); // Want to be windows-safe
	387
	388	node = m_Handlers.GetFirst();
	389	while (node)
	390	{
	391	m_FindFileHandler = (wxFileSystemHandler*) node -> GetData();
	392	if (m_FindFileHandler -> CanOpen(m_Path + spec2))
	393	return m_FindFileHandler -> FindFirst(m_Path + spec2, flags);
	394	node = node->GetNext();
	395	}
	396
	397	node = m_Handlers.GetFirst();
	398	while (node)
	399	{
	400	m_FindFileHandler = (wxFileSystemHandler*) node -> GetData();
	401	if (m_FindFileHandler -> CanOpen(spec2))
	402	return m_FindFileHandler -> FindFirst(spec2, flags);
	403	node = node->GetNext();
	404	}
	405
	406	return wxEmptyString;
	407	}
	408
	409
	410
	411	wxString wxFileSystem::FindNext()
	412	{
	413	if (m_FindFileHandler == NULL) return wxEmptyString;
	414	else return m_FindFileHandler -> FindNext();
	415	}
	416
	417
	418
	419	void wxFileSystem::AddHandler(wxFileSystemHandler *handler)
	420	{
	421	m_Handlers.Append(handler);
	422	}
	423
	424
	425	void wxFileSystem::CleanUpHandlers()
	426	{
	427	m_Handlers.DeleteContents(TRUE);
	428	m_Handlers.Clear();
	429	}
	430
	431	const static wxString g_unixPathString(wxT("/"));
	432	const static wxString g_nativePathString(wxFILE_SEP_PATH);
	433
	434	// Returns the native path for a file URL
	435	wxFileName wxFileSystem::URLToFileName(const wxString& url)
	436	{
	437	wxString path = url;
	438
	439	if ( path.Find(wxT("file://")) == 0 )
	440	{
	441	path = path.Mid(7);
	442	}
	443	else if ( path.Find(wxT("file:")) == 0 )
	444	{
	445	path = path.Mid(5);
	446	}
	447	// Remove preceding double slash on Mac Classic
	448	#if defined(__WXMAC__) && !defined(__UNIX__)
	449	else if ( path.Find(wxT("//")) == 0 )
	450	path = path.Mid(2);
	451	#endif
	452
	453	path.Replace(wxT("%25"), wxT("%"));
	454	path.Replace(wxT("%3A"), wxT(":"));
	455
	456	#ifdef __WXMSW__
	457	// file urls either start with a forward slash (local harddisk),
	458	// otherwise they have a servername/sharename notation,
	459	// which only exists on msw and corresponds to a unc
	460	if ( path[0u] == wxT('/') && path [1u] != wxT('/'))
	461	{
	462	path = path.Mid(1);
	463	}
	464	else if ( (url.Find(wxT("file://")) == 0) &&
	465	(path.Find(wxT('/')) != wxNOT_FOUND) &&
	466	(path.Length() > 1) && (path[1u] != wxT(':')) )
	467	{
	468	path = wxT("//") + path;
	469	}
	470	#endif
	471
	472	path.Replace(g_unixPathString, g_nativePathString);
	473
	474	return wxFileName(path, wxPATH_NATIVE);
	475	}
	476
	477	// Returns the file URL for a native path
	478	wxString wxFileSystem::FileNameToURL(const wxFileName& filename)
	479	{
	480	wxFileName fn = filename;
	481	fn.Normalize(wxPATH_NORM_DOTS \| wxPATH_NORM_TILDE \| wxPATH_NORM_ABSOLUTE);
	482	wxString url = fn.GetFullPath(wxPATH_NATIVE);
	483
	484	#ifndef __UNIX__
	485	// unc notation, wxMSW
	486	if ( url.Find(wxT("\\\\")) == 0 )
	487	{
	488	url = url.Mid(2);
	489	}
	490	else
	491	{
	492	url = wxT("/") + url;
	493	#ifdef __WXMAC__
	494	url = wxT("/") + url;
	495	#endif
	496
	497	}
	498	#endif
	499
	500	url.Replace(g_nativePathString, g_unixPathString);
	501	url.Replace(wxT("%"), wxT("%25"));
	502	url.Replace(wxT(":"), wxT("%3A"));
	503	url = wxT("file:") + url;
	504	return url;
	505	}
	506
	507
	508	///// Module:
	509
	510	class wxFileSystemModule : public wxModule
	511	{
	512	DECLARE_DYNAMIC_CLASS(wxFileSystemModule)
	513
	514	public:
	515	virtual bool OnInit()
	516	{
	517	wxFileSystem::AddHandler(new wxLocalFSHandler);
	518
	519	#if wxUSE_MIMETYPE
	520	gs_FSMimeFallbacks = new wxFileTypeInfo[6];
	521	gs_FSMimeFallbacks[0] =
	522	wxFileTypeInfo(_T("image/jpeg"),
	523	_T(""),
	524	_T(""),
	525	_T("JPEG image (from fallback)"),
	526	_T("jpg"), _T("jpeg"), NULL);
	527	gs_FSMimeFallbacks[1] =
	528	wxFileTypeInfo(_T("image/gif"),
	529	_T(""),
	530	_T(""),
	531	_T("GIF image (from fallback)"),
	532	_T("gif"), NULL);
	533	gs_FSMimeFallbacks[2] =
	534	wxFileTypeInfo(_T("image/png"),
	535	_T(""),
	536	_T(""),
	537	_T("PNG image (from fallback)"),
	538	_T("png"), NULL);
	539	gs_FSMimeFallbacks[3] =
	540	wxFileTypeInfo(_T("image/bmp"),
	541	_T(""),
	542	_T(""),
	543	_T("windows bitmap image (from fallback)"),
	544	_T("bmp"), NULL);
	545	gs_FSMimeFallbacks[4] =
	546	wxFileTypeInfo(_T("text/html"),
	547	_T(""),
	548	_T(""),
	549	_T("HTML document (from fallback)"),
	550	_T("htm"), _T("html"), NULL);
	551	gs_FSMimeFallbacks[5] =
	552	// must terminate the table with this!
	553	wxFileTypeInfo();
	554	#endif
	555	return TRUE;
	556	}
	557	virtual void OnExit()
	558	{
	559	#if wxUSE_MIMETYPE
	560	delete [] gs_FSMimeFallbacks;
	561	#endif
	562	wxFileSystem::CleanUpHandlers();
	563	}
	564	};
	565
	566	IMPLEMENT_DYNAMIC_CLASS(wxFileSystemModule, wxModule)
	567
	568	#endif
	569	// wxUSE_FILESYSTEM
	570
	571
	572