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;
    wxList::compatibility_iterator 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)
{
    wxList::compatibility_iterator 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()
{
    WX_CLEAR_LIST(wxList, m_Handlers);
}

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