[wxWidgets.git] / src / html / htmlfilter.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        filter.cpp
// Purpose:     wxHtmlFilter - input filter for translating into HTML format
// Author:      Vaclav Slavik
// Copyright:   (c) 1999 Vaclav Slavik
// Licence:     wxWindows Licence
/////////////////////////////////////////////////////////////////////////////


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

#include "wx/wxprec.h"

#if wxUSE_HTML

#ifdef __BORDLANDC__
#pragma hdrstop
#endif

#ifndef WXPRECOMP
#include "wx/wx.h"
#endif

#include "wx/html/htmlfilter.h"
#include "wx/html/htmlwin.h"


/*

There is code for several default filters:

*/

IMPLEMENT_ABSTRACT_CLASS(wxHtmlFilter, wxObject)

//--------------------------------------------------------------------------------
// wxHtmlFilterPlainText
//          filter for text/plain or uknown
//--------------------------------------------------------------------------------

IMPLEMENT_DYNAMIC_CLASS(wxHtmlFilterPlainText, wxHtmlFilter)

bool wxHtmlFilterPlainText::CanRead(const wxFSFile& file) const
{
    return TRUE;
}


wxString wxHtmlFilterPlainText::ReadFile(const wxFSFile& file) const
{
    wxInputStream *s = file.GetStream();
    char *src;
    wxString doc, doc2;

    if (s == NULL) return wxEmptyString;
    src = new char[s -> GetSize()+1];
    src[s -> GetSize()] = 0;
    s -> Read(src, s -> GetSize());
    doc = src;
    delete [] src;

    doc.Replace("<", "&lt;", TRUE);
    doc.Replace(">", "&gt;", TRUE);
    doc2 = "<HTML><BODY><PRE>\n" + doc + "\n</PRE></BODY></HTML>";
    return doc2;
}


//--------------------------------------------------------------------------------
// wxHtmlFilterImage
//          filter for image/*
//--------------------------------------------------------------------------------

class wxHtmlFilterImage : public wxHtmlFilter
{
    DECLARE_DYNAMIC_CLASS(wxHtmlFilterImage)

    public:
        virtual bool CanRead(const wxFSFile& file) const;
        virtual wxString ReadFile(const wxFSFile& file) const;
};

IMPLEMENT_DYNAMIC_CLASS(wxHtmlFilterImage, wxHtmlFilter)


bool wxHtmlFilterImage::CanRead(const wxFSFile& file) const
{
    return (file.GetMimeType().Left(6) == "image/");
}


wxString wxHtmlFilterImage::ReadFile(const wxFSFile& file) const
{
    return ("<HTML><BODY><IMG SRC=\"" + file.GetLocation() + "\"></BODY></HTML>");
}


//--------------------------------------------------------------------------------
// wxHtmlFilterPlainText
//          filter for text/plain or uknown
//--------------------------------------------------------------------------------

class wxHtmlFilterHTML : public wxHtmlFilter
{
    DECLARE_DYNAMIC_CLASS(wxHtmlFilterHTML)

    public:
        virtual bool CanRead(const wxFSFile& file) const;
        virtual wxString ReadFile(const wxFSFile& file) const;
};


IMPLEMENT_DYNAMIC_CLASS(wxHtmlFilterHTML, wxHtmlFilter)

bool wxHtmlFilterHTML::CanRead(const wxFSFile& file) const
{
//    return (file.GetMimeType() == "text/html");
// This is true in most case but some page can return:
// "text/html; char-encoding=...."
// So we use Find instead
  return (file.GetMimeType().Find(_T("text/html")) == 0);
}


wxString wxHtmlFilterHTML::ReadFile(const wxFSFile& file) const
{
    wxInputStream *s = file.GetStream();
    char *src;
    wxString doc;

    if (s == NULL) return wxEmptyString;
    src = (char*) malloc(s -> GetSize() + 1);
    src[s -> GetSize()] = 0;
    s -> Read(src, s -> GetSize());
    doc = src;
    free(src);

    return doc;
}


///// Module:

class wxHtmlFilterModule : public wxModule
{
    DECLARE_DYNAMIC_CLASS(wxHtmlFilterModule)

    public:
        virtual bool OnInit()
        {
            wxHtmlWindow::AddFilter(new wxHtmlFilterHTML);
            wxHtmlWindow::AddFilter(new wxHtmlFilterImage);
            return TRUE;
        }
        virtual void OnExit() {}
};

IMPLEMENT_DYNAMIC_CLASS(wxHtmlFilterModule, wxModule)

#endif
Commit	Line	Data
5526e819 VS	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: filter.cpp
	3	// Purpose: wxHtmlFilter - input filter for translating into HTML format
	4	// Author: Vaclav Slavik
	5	// Copyright: (c) 1999 Vaclav Slavik
	6	// Licence: wxWindows Licence
	7	/////////////////////////////////////////////////////////////////////////////
	8
	9
	10	#ifdef __GNUG__
4dcaf11a	11	#pragma implementation "htmlfilter.h"
5526e819 VS	12	#endif
5526e819 VS	13
4dcaf11a	14	#include "wx/wxprec.h"
5526e819	15
5526e819 VS	16	#if wxUSE_HTML
	17
	18	#ifdef __BORDLANDC__
	19	#pragma hdrstop
	20	#endif
	21
	22	#ifndef WXPRECOMP
4dcaf11a	23	#include "wx/wx.h"
5526e819 VS	24	#endif
5526e819 VS	25
4dcaf11a RR	26	#include "wx/html/htmlfilter.h"
4dcaf11a RR	27	#include "wx/html/htmlwin.h"
5526e819 VS	28
	29
	30	/*
	31
	32	There is code for several default filters:
	33
	34	*/
	35
	36	IMPLEMENT_ABSTRACT_CLASS(wxHtmlFilter, wxObject)
	37
	38	//--------------------------------------------------------------------------------
	39	// wxHtmlFilterPlainText
	40	// filter for text/plain or uknown
	41	//--------------------------------------------------------------------------------
	42
	43	IMPLEMENT_DYNAMIC_CLASS(wxHtmlFilterPlainText, wxHtmlFilter)
	44
420ec58a	45	bool wxHtmlFilterPlainText::CanRead(const wxFSFile& file) const
5526e819 VS	46	{
	47	return TRUE;
	48	}
	49
	50
	51
420ec58a	52	wxString wxHtmlFilterPlainText::ReadFile(const wxFSFile& file) const
5526e819 VS	53	{
	54	wxInputStream *s = file.GetStream();
	55	char *src;
	56	wxString doc, doc2;
	57
	58	if (s == NULL) return wxEmptyString;
259d1674 VZ	59	src = new char[s -> GetSize()+1];
	60	src[s -> GetSize()] = 0;
	61	s -> Read(src, s -> GetSize());
5526e819	62	doc = src;
8dd71e2b	63	delete [] src;
5526e819 VS	64
	65	doc.Replace("<", "<", TRUE);
	66	doc.Replace(">", ">", TRUE);
	67	doc2 = "<HTML><BODY><PRE>\n" + doc + "\n</PRE></BODY></HTML>";
	68	return doc2;
	69	}
	70
	71
	72
	73
	74
	75	//--------------------------------------------------------------------------------
	76	// wxHtmlFilterImage
	77	// filter for image/*
	78	//--------------------------------------------------------------------------------
	79
	80	class wxHtmlFilterImage : public wxHtmlFilter
	81	{
	82	DECLARE_DYNAMIC_CLASS(wxHtmlFilterImage)
	83
	84	public:
420ec58a VS	85	virtual bool CanRead(const wxFSFile& file) const;
420ec58a VS	86	virtual wxString ReadFile(const wxFSFile& file) const;
5526e819 VS	87	};
	88
	89	IMPLEMENT_DYNAMIC_CLASS(wxHtmlFilterImage, wxHtmlFilter)
	90
	91
	92
420ec58a	93	bool wxHtmlFilterImage::CanRead(const wxFSFile& file) const
5526e819 VS	94	{
	95	return (file.GetMimeType().Left(6) == "image/");
	96	}
	97
	98
	99
420ec58a	100	wxString wxHtmlFilterImage::ReadFile(const wxFSFile& file) const
5526e819 VS	101	{
	102	return ("<HTML><BODY><IMG SRC=\"" + file.GetLocation() + "\"></BODY></HTML>");
	103	}
	104
	105
	106
	107
	108	//--------------------------------------------------------------------------------
	109	// wxHtmlFilterPlainText
	110	// filter for text/plain or uknown
	111	//--------------------------------------------------------------------------------
	112
	113	class wxHtmlFilterHTML : public wxHtmlFilter
	114	{
	115	DECLARE_DYNAMIC_CLASS(wxHtmlFilterHTML)
	116
	117	public:
420ec58a VS	118	virtual bool CanRead(const wxFSFile& file) const;
420ec58a VS	119	virtual wxString ReadFile(const wxFSFile& file) const;
5526e819 VS	120	};
	121
	122
	123	IMPLEMENT_DYNAMIC_CLASS(wxHtmlFilterHTML, wxHtmlFilter)
	124
420ec58a	125	bool wxHtmlFilterHTML::CanRead(const wxFSFile& file) const
5526e819	126	{
f61815af GL	127	// return (file.GetMimeType() == "text/html");
	128	// This is true in most case but some page can return:
	129	// "text/html; char-encoding=...."
	130	// So we use Find instead
	131	return (file.GetMimeType().Find(_T("text/html")) == 0);
5526e819 VS	132	}
	133
	134
	135
420ec58a	136	wxString wxHtmlFilterHTML::ReadFile(const wxFSFile& file) const
5526e819 VS	137	{
	138	wxInputStream *s = file.GetStream();
	139	char *src;
	140	wxString doc;
	141
	142	if (s == NULL) return wxEmptyString;
259d1674 VZ	143	src = (char*) malloc(s -> GetSize() + 1);
	144	src[s -> GetSize()] = 0;
	145	s -> Read(src, s -> GetSize());
5526e819 VS	146	doc = src;
	147	free(src);
	148
	149	return doc;
	150	}
	151
	152
	153
	154
	155	///// Module:
	156
	157	class wxHtmlFilterModule : public wxModule
	158	{
	159	DECLARE_DYNAMIC_CLASS(wxHtmlFilterModule)
	160
	161	public:
	162	virtual bool OnInit()
	163	{
	164	wxHtmlWindow::AddFilter(new wxHtmlFilterHTML);
	165	wxHtmlWindow::AddFilter(new wxHtmlFilterImage);
	166	return TRUE;
	167	}
	168	virtual void OnExit() {}
	169	};
	170
	171	IMPLEMENT_DYNAMIC_CLASS(wxHtmlFilterModule, wxModule)
	172
8dd71e2b	173	#endif