src/html/winpars.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        winpars.cpp
// Purpose:     wxHtmlParser class (generic parser)
// Author:      Vaclav Slavik
// RCS-ID:      $Id$
// Copyright:   (c) 1999 Vaclav Slavik
// Licence:     wxWindows Licence
/////////////////////////////////////////////////////////////////////////////


#ifdef __GNUG__
#pragma implementation
#endif

#include "wx/wxprec.h"

#include "wx/defs.h"
#if wxUSE_HTML && wxUSE_STREAMS

#ifdef __BORDLANDC__
#pragma hdrstop
#endif

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

#include "wx/html/htmldefs.h"
#include "wx/html/winpars.h"
#include "wx/html/htmlwin.h"
#include "wx/fontmap.h"
#include "wx/log.h"


//-----------------------------------------------------------------------------
// wxHtmlWinParser
//-----------------------------------------------------------------------------


wxList wxHtmlWinParser::m_Modules;

wxHtmlWinParser::wxHtmlWinParser(wxWindow *wnd) : wxHtmlParser()
{
    m_Window = wnd;
    m_Container = NULL;
    m_DC = NULL;
    m_CharHeight = m_CharWidth = 0;
    m_UseLink = FALSE;
    m_EncConv = NULL;
    m_InputEnc = m_OutputEnc = wxFONTENCODING_DEFAULT;

    {
        int i, j, k, l, m;
        for (i = 0; i < 2; i++)
            for (j = 0; j < 2; j++)
                for (k = 0; k < 2; k++)
                    for (l = 0; l < 2; l++)
                        for (m = 0; m < 7; m++) {
                            m_FontsTable[i][j][k][l][m] = NULL;
                            m_FontsFacesTable[i][j][k][l][m] = wxEmptyString;
                            m_FontsEncTable[i][j][k][l][m] = wxFONTENCODING_DEFAULT;
                        }
#ifdef __WXMSW__
        static int default_sizes[7] = {7, 8, 10, 12, 16, 22, 30};
#elif defined(__WXMAC__)
        static int default_sizes[7] = {9, 12, 14, 18, 24, 30, 36};
#else
        static int default_sizes[7] = {10, 12, 14, 16, 19, 24, 32};
#endif
        SetFonts("", "", default_sizes);
    }

    // fill in wxHtmlParser's tables:
    wxNode *node = m_Modules.GetFirst();
    while (node) {
        wxHtmlTagsModule *mod = (wxHtmlTagsModule*) node -> GetData();
        mod -> FillHandlersTable(this);
        node = node -> GetNext();
    }
}


wxHtmlWinParser::~wxHtmlWinParser()
{
    int i, j, k, l, m;

    for (i = 0; i < 2; i++)
        for (j = 0; j < 2; j++)
            for (k = 0; k < 2; k++)
                for (l = 0; l < 2; l++)
                    for (m = 0; m < 7; m++) {
                        if (m_FontsTable[i][j][k][l][m] != NULL)
                            delete m_FontsTable[i][j][k][l][m];
                    }
    if (m_EncConv) delete m_EncConv;
}


void wxHtmlWinParser::AddModule(wxHtmlTagsModule *module)
{
    m_Modules.Append(module);
}


void wxHtmlWinParser::RemoveModule(wxHtmlTagsModule *module)
{
    m_Modules.DeleteObject(module);
}


void wxHtmlWinParser::SetFonts(wxString normal_face, wxString fixed_face, const int *sizes)
{
    int i, j, k, l, m;

    for (i = 0; i < 7; i++) m_FontsSizes[i] = sizes[i];
    m_FontFaceFixed = fixed_face;
    m_FontFaceNormal = normal_face;

    SetInputEncoding(m_InputEnc);

    for (i = 0; i < 2; i++)
        for (j = 0; j < 2; j++)
            for (k = 0; k < 2; k++)
                for (l = 0; l < 2; l++)
                    for (m = 0; m < 7; m++) {
                        if (m_FontsTable[i][j][k][l][m] != NULL) {
                            delete m_FontsTable[i][j][k][l][m];
                            m_FontsTable[i][j][k][l][m] = NULL;
                        }
                    }
}


void wxHtmlWinParser::InitParser(const wxString& source)
{
    wxHtmlParser::InitParser(source);
    wxASSERT_MSG(m_DC != NULL, _T("no DC assigned to wxHtmlWinParser!!"));

    m_FontBold = m_FontItalic = m_FontUnderlined = m_FontFixed = FALSE;
    m_FontSize = 3; //default one
    CreateCurrentFont();           // we're selecting default font into
    m_DC -> GetTextExtent("H", &m_CharWidth, &m_CharHeight);
                /* NOTE : we're not using GetCharWidth/Height() because
                   of differences under X and win
                 */

    m_UseLink = FALSE;
    m_Link = wxHtmlLinkInfo("", "");
    m_LinkColor.Set(0, 0, 0xFF);
    m_ActualColor.Set(0, 0, 0);
    m_Align = wxHTML_ALIGN_LEFT;
    m_tmpLastWasSpace = FALSE;

    OpenContainer();

    OpenContainer();
    m_Container -> InsertCell(new wxHtmlColourCell(m_ActualColor));
    m_Container -> InsertCell(new wxHtmlFontCell(CreateCurrentFont()));
}


void wxHtmlWinParser::DoneParser()
{
    m_Container = NULL;
    SetInputEncoding(wxFONTENCODING_DEFAULT); // for next call
    wxHtmlParser::DoneParser();
}


wxObject* wxHtmlWinParser::GetProduct()
{
    wxHtmlContainerCell *top;

    CloseContainer();
    OpenContainer();

    top = m_Container;
    while (top -> GetParent()) top = top -> GetParent();
    return top;
}


void wxHtmlWinParser::AddText(const char* txt)
{
    wxHtmlCell *c;
    int i = 0, x, lng = strlen(txt);
    char temp[wxHTML_BUFLEN];
    register char d;
    int templen = 0;

    if (m_tmpLastWasSpace) {
        while ((i < lng) && ((txt[i] == '\n') || (txt[i] == '\r') || (txt[i] == ' ') || (txt[i] == '\t'))) i++;
    }

    while (i < lng) {
        x = 0;
        d = temp[templen++] = txt[i];
        if ((d == '\n') || (d == '\r') || (d == ' ') || (d == '\t')) {
            i++, x++;
            while ((i < lng) && ((txt[i] == '\n') || (txt[i] == '\r') || (txt[i] == ' ') || (txt[i] == '\t'))) i++, x++;
        }
        else i++;

        if (x) {
            temp[templen-1] = ' ';
            temp[templen] = 0;
            templen = 0;
            if (m_EncConv) m_EncConv -> Convert(temp);
            c = new wxHtmlWordCell(temp, *(GetDC()));
            if (m_UseLink) c -> SetLink(m_Link);
            m_Container -> InsertCell(c);
            m_tmpLastWasSpace = TRUE;
        }
    }
    if (templen) {
        temp[templen] = 0;
        if (m_EncConv) m_EncConv -> Convert(temp);
        c = new wxHtmlWordCell(temp, *(GetDC()));
        if (m_UseLink) c -> SetLink(m_Link);
        m_Container -> InsertCell(c);
        m_tmpLastWasSpace = FALSE;
    }
}


wxHtmlContainerCell* wxHtmlWinParser::OpenContainer()
{
    m_Container = new wxHtmlContainerCell(m_Container);
    m_Container -> SetAlignHor(m_Align);
    m_tmpLastWasSpace = TRUE;
        /* to avoid space being first character in paragraph */
    return m_Container;
}


wxHtmlContainerCell* wxHtmlWinParser::SetContainer(wxHtmlContainerCell *c)
{
    m_tmpLastWasSpace = TRUE;
        /* to avoid space being first character in paragraph */
    return m_Container = c;
}


wxHtmlContainerCell* wxHtmlWinParser::CloseContainer()
{
    m_Container = m_Container -> GetParent();
    return m_Container;
}


void wxHtmlWinParser::SetFontSize(int s)
{
    if (s < 1) s = 1;
    else if (s > 7) s = 7;
    m_FontSize = s;
}


wxFont* wxHtmlWinParser::CreateCurrentFont()
{
    int fb = GetFontBold(),
        fi = GetFontItalic(),
        fu = GetFontUnderlined(),
        ff = GetFontFixed(),
        fs = GetFontSize() - 1 /*remap from <1;7> to <0;6>*/ ;

    wxString face = ff ? m_FontFaceFixed : m_FontFaceNormal;
    wxString *faceptr = &(m_FontsFacesTable[fb][fi][fu][ff][fs]);
    wxFont **fontptr = &(m_FontsTable[fb][fi][fu][ff][fs]);
    wxFontEncoding *encptr = &(m_FontsEncTable[fb][fi][fu][ff][fs]);

    if (*fontptr != NULL && (*faceptr != face || *encptr != m_OutputEnc)) {
        delete *fontptr;
        *fontptr = NULL;
    }

    if (*fontptr == NULL) {
        *faceptr = face;
        *encptr = m_OutputEnc;
        *fontptr = new wxFont(
                       m_FontsSizes[fs] * m_PixelScale,
                       ff ? wxMODERN : wxSWISS,
                       fi ? wxITALIC : wxNORMAL,
                       fb ? wxBOLD : wxNORMAL,
                       fu ? TRUE : FALSE, face,
                       m_OutputEnc);
    }
    m_DC -> SetFont(**fontptr);
    return (*fontptr);
}


void wxHtmlWinParser::SetLink(const wxHtmlLinkInfo& link)
{
    m_Link = link;
    m_UseLink = (link.GetHref() != wxEmptyString);
}


void wxHtmlWinParser::SetFontFace(const wxString& face)
{
    if (GetFontFixed()) m_FontFaceFixed = face;
    else m_FontFaceNormal = face;

    if (m_InputEnc != wxFONTENCODING_DEFAULT)
        SetInputEncoding(m_InputEnc);
}


void wxHtmlWinParser::SetInputEncoding(wxFontEncoding enc)
{
    m_InputEnc = m_OutputEnc = wxFONTENCODING_DEFAULT;
    if (m_EncConv) {delete m_EncConv; m_EncConv = NULL;}

    if (enc == wxFONTENCODING_DEFAULT) return;

    wxFontEncoding altfix, altnorm;
    bool availfix, availnorm;

    // exact match?
    availnorm = wxTheFontMapper -> IsEncodingAvailable(enc, m_FontFaceNormal);
    availfix = wxTheFontMapper -> IsEncodingAvailable(enc, m_FontFaceFixed);
    if (availnorm && availfix)
        m_OutputEnc = enc;

    // alternatives?
    else if (wxTheFontMapper -> GetAltForEncoding(enc, &altnorm, m_FontFaceNormal, FALSE) &&
             wxTheFontMapper -> GetAltForEncoding(enc, &altfix, m_FontFaceFixed, FALSE) &&
             altnorm == altfix)
        m_OutputEnc = altnorm;

    // at least normal face?
    else if (availnorm)
        m_OutputEnc = enc;
    else if (wxTheFontMapper -> GetAltForEncoding(enc, &altnorm, m_FontFaceNormal, FALSE))
        m_OutputEnc = altnorm;

    // okay, let convert to ISO_8859-1, available always
    else
        m_OutputEnc = wxFONTENCODING_DEFAULT;

    m_InputEnc = enc;

    if (m_InputEnc == m_OutputEnc) return;

    m_EncConv = new wxEncodingConverter();
    if (!m_EncConv -> Init(m_InputEnc,
                           (m_OutputEnc == wxFONTENCODING_DEFAULT) ?
                                      wxFONTENCODING_ISO8859_1 : m_OutputEnc,
                           wxCONVERT_SUBSTITUTE))
    { // total failture :-(
        wxLogError(_("Failed to display HTML document in %s encoding"),
	           wxFontMapper::GetEncodingName(enc).c_str());
        m_InputEnc = m_OutputEnc = wxFONTENCODING_DEFAULT;
        delete m_EncConv;
        m_EncConv = NULL;
    }
}


//-----------------------------------------------------------------------------
// wxHtmlWinTagHandler
//-----------------------------------------------------------------------------

IMPLEMENT_ABSTRACT_CLASS(wxHtmlWinTagHandler, wxHtmlTagHandler)


//-----------------------------------------------------------------------------
// wxHtmlTagsModule
//-----------------------------------------------------------------------------


IMPLEMENT_DYNAMIC_CLASS(wxHtmlTagsModule, wxModule)


bool wxHtmlTagsModule::OnInit()
{
    wxHtmlWinParser::AddModule(this);
    return TRUE;
}


void wxHtmlTagsModule::OnExit()
{
    wxHtmlWinParser::RemoveModule(this);
}
#endif
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: winpars.cpp
	3	// Purpose: wxHtmlParser class (generic parser)
	4	// Author: Vaclav Slavik
	5	// RCS-ID: $Id$
	6	// Copyright: (c) 1999 Vaclav Slavik
	7	// Licence: wxWindows Licence
	8	/////////////////////////////////////////////////////////////////////////////
	9
	10
	11	#ifdef __GNUG__
	12	#pragma implementation
	13	#endif
	14
	15	#include "wx/wxprec.h"
	16
	17	#include "wx/defs.h"
	18	#if wxUSE_HTML && wxUSE_STREAMS
	19
	20	#ifdef __BORDLANDC__
	21	#pragma hdrstop
	22	#endif
	23
	24	#ifndef WXPRECOMP
	25	#include "wx/wx.h"
	26	#endif
	27
	28	#include "wx/html/htmldefs.h"
	29	#include "wx/html/winpars.h"
	30	#include "wx/html/htmlwin.h"
	31	#include "wx/fontmap.h"
	32	#include "wx/log.h"
	33
	34
	35	//-----------------------------------------------------------------------------
	36	// wxHtmlWinParser
	37	//-----------------------------------------------------------------------------
	38
	39
	40	wxList wxHtmlWinParser::m_Modules;
	41
	42	wxHtmlWinParser::wxHtmlWinParser(wxWindow *wnd) : wxHtmlParser()
	43	{
	44	m_Window = wnd;
	45	m_Container = NULL;
	46	m_DC = NULL;
	47	m_CharHeight = m_CharWidth = 0;
	48	m_UseLink = FALSE;
	49	m_EncConv = NULL;
	50	m_InputEnc = m_OutputEnc = wxFONTENCODING_DEFAULT;
	51
	52	{
	53	int i, j, k, l, m;
	54	for (i = 0; i < 2; i++)
	55	for (j = 0; j < 2; j++)
	56	for (k = 0; k < 2; k++)
	57	for (l = 0; l < 2; l++)
	58	for (m = 0; m < 7; m++) {
	59	m_FontsTable[i][j][k][l][m] = NULL;
	60	m_FontsFacesTable[i][j][k][l][m] = wxEmptyString;
	61	m_FontsEncTable[i][j][k][l][m] = wxFONTENCODING_DEFAULT;
	62	}
	63	#ifdef __WXMSW__
	64	static int default_sizes[7] = {7, 8, 10, 12, 16, 22, 30};
	65	#elif defined(__WXMAC__)
	66	static int default_sizes[7] = {9, 12, 14, 18, 24, 30, 36};
	67	#else
	68	static int default_sizes[7] = {10, 12, 14, 16, 19, 24, 32};
	69	#endif
	70	SetFonts("", "", default_sizes);
	71	}
	72
	73	// fill in wxHtmlParser's tables:
	74	wxNode *node = m_Modules.GetFirst();
	75	while (node) {
	76	wxHtmlTagsModule mod = (wxHtmlTagsModule) node -> GetData();
	77	mod -> FillHandlersTable(this);
	78	node = node -> GetNext();
	79	}
	80	}
	81
	82
	83	wxHtmlWinParser::~wxHtmlWinParser()
	84	{
	85	int i, j, k, l, m;
	86
	87	for (i = 0; i < 2; i++)
	88	for (j = 0; j < 2; j++)
	89	for (k = 0; k < 2; k++)
	90	for (l = 0; l < 2; l++)
	91	for (m = 0; m < 7; m++) {
	92	if (m_FontsTable[i][j][k][l][m] != NULL)
	93	delete m_FontsTable[i][j][k][l][m];
	94	}
	95	if (m_EncConv) delete m_EncConv;
	96	}
	97
	98
	99	void wxHtmlWinParser::AddModule(wxHtmlTagsModule *module)
	100	{
	101	m_Modules.Append(module);
	102	}
	103
	104
	105
	106	void wxHtmlWinParser::RemoveModule(wxHtmlTagsModule *module)
	107	{
	108	m_Modules.DeleteObject(module);
	109	}
	110
	111
	112
	113	void wxHtmlWinParser::SetFonts(wxString normal_face, wxString fixed_face, const int *sizes)
	114	{
	115	int i, j, k, l, m;
	116
	117	for (i = 0; i < 7; i++) m_FontsSizes[i] = sizes[i];
	118	m_FontFaceFixed = fixed_face;
	119	m_FontFaceNormal = normal_face;
	120
	121	SetInputEncoding(m_InputEnc);
	122
	123	for (i = 0; i < 2; i++)
	124	for (j = 0; j < 2; j++)
	125	for (k = 0; k < 2; k++)
	126	for (l = 0; l < 2; l++)
	127	for (m = 0; m < 7; m++) {
	128	if (m_FontsTable[i][j][k][l][m] != NULL) {
	129	delete m_FontsTable[i][j][k][l][m];
	130	m_FontsTable[i][j][k][l][m] = NULL;
	131	}
	132	}
	133	}
	134
	135
	136
	137	void wxHtmlWinParser::InitParser(const wxString& source)
	138	{
	139	wxHtmlParser::InitParser(source);
	140	wxASSERT_MSG(m_DC != NULL, _T("no DC assigned to wxHtmlWinParser!!"));
	141
	142	m_FontBold = m_FontItalic = m_FontUnderlined = m_FontFixed = FALSE;
	143	m_FontSize = 3; //default one
	144	CreateCurrentFont(); // we're selecting default font into
	145	m_DC -> GetTextExtent("H", &m_CharWidth, &m_CharHeight);
	146	/* NOTE : we're not using GetCharWidth/Height() because
	147	of differences under X and win
	148	*/
	149
	150	m_UseLink = FALSE;
	151	m_Link = wxHtmlLinkInfo("", "");
	152	m_LinkColor.Set(0, 0, 0xFF);
	153	m_ActualColor.Set(0, 0, 0);
	154	m_Align = wxHTML_ALIGN_LEFT;
	155	m_tmpLastWasSpace = FALSE;
	156
	157	OpenContainer();
	158
	159	OpenContainer();
	160	m_Container -> InsertCell(new wxHtmlColourCell(m_ActualColor));
	161	m_Container -> InsertCell(new wxHtmlFontCell(CreateCurrentFont()));
	162	}
	163
	164
	165
	166	void wxHtmlWinParser::DoneParser()
	167	{
	168	m_Container = NULL;
	169	SetInputEncoding(wxFONTENCODING_DEFAULT); // for next call
	170	wxHtmlParser::DoneParser();
	171	}
	172
	173
	174
	175	wxObject* wxHtmlWinParser::GetProduct()
	176	{
	177	wxHtmlContainerCell *top;
	178
	179	CloseContainer();
	180	OpenContainer();
	181
	182	top = m_Container;
	183	while (top -> GetParent()) top = top -> GetParent();
	184	return top;
	185	}
	186
	187
	188
	189	void wxHtmlWinParser::AddText(const char* txt)
	190	{
	191	wxHtmlCell *c;
	192	int i = 0, x, lng = strlen(txt);
	193	char temp[wxHTML_BUFLEN];
	194	register char d;
	195	int templen = 0;
	196
	197	if (m_tmpLastWasSpace) {
	198	while ((i < lng) && ((txt[i] == '\n') \|\| (txt[i] == '\r') \|\| (txt[i] == ' ') \|\| (txt[i] == '\t'))) i++;
	199	}
	200
	201	while (i < lng) {
	202	x = 0;
	203	d = temp[templen++] = txt[i];
	204	if ((d == '\n') \|\| (d == '\r') \|\| (d == ' ') \|\| (d == '\t')) {
	205	i++, x++;
	206	while ((i < lng) && ((txt[i] == '\n') \|\| (txt[i] == '\r') \|\| (txt[i] == ' ') \|\| (txt[i] == '\t'))) i++, x++;
	207	}
	208	else i++;
	209
	210	if (x) {
	211	temp[templen-1] = ' ';
	212	temp[templen] = 0;
	213	templen = 0;
	214	if (m_EncConv) m_EncConv -> Convert(temp);
	215	c = new wxHtmlWordCell(temp, *(GetDC()));
	216	if (m_UseLink) c -> SetLink(m_Link);
	217	m_Container -> InsertCell(c);
	218	m_tmpLastWasSpace = TRUE;
	219	}
	220	}
	221	if (templen) {
	222	temp[templen] = 0;
	223	if (m_EncConv) m_EncConv -> Convert(temp);
	224	c = new wxHtmlWordCell(temp, *(GetDC()));
	225	if (m_UseLink) c -> SetLink(m_Link);
	226	m_Container -> InsertCell(c);
	227	m_tmpLastWasSpace = FALSE;
	228	}
	229	}
	230
	231
	232
	233	wxHtmlContainerCell* wxHtmlWinParser::OpenContainer()
	234	{
	235	m_Container = new wxHtmlContainerCell(m_Container);
	236	m_Container -> SetAlignHor(m_Align);
	237	m_tmpLastWasSpace = TRUE;
	238	/* to avoid space being first character in paragraph */
	239	return m_Container;
	240	}
	241
	242
	243
	244	wxHtmlContainerCell* wxHtmlWinParser::SetContainer(wxHtmlContainerCell *c)
	245	{
	246	m_tmpLastWasSpace = TRUE;
	247	/* to avoid space being first character in paragraph */
	248	return m_Container = c;
	249	}
	250
	251
	252
	253	wxHtmlContainerCell* wxHtmlWinParser::CloseContainer()
	254	{
	255	m_Container = m_Container -> GetParent();
	256	return m_Container;
	257	}
	258
	259
	260	void wxHtmlWinParser::SetFontSize(int s)
	261	{
	262	if (s < 1) s = 1;
	263	else if (s > 7) s = 7;
	264	m_FontSize = s;
	265	}
	266
	267
	268
	269	wxFont* wxHtmlWinParser::CreateCurrentFont()
	270	{
	271	int fb = GetFontBold(),
	272	fi = GetFontItalic(),
	273	fu = GetFontUnderlined(),
	274	ff = GetFontFixed(),
	275	fs = GetFontSize() - 1 /remap from <1;7> to <0;6>/ ;
	276
	277	wxString face = ff ? m_FontFaceFixed : m_FontFaceNormal;
	278	wxString *faceptr = &(m_FontsFacesTable[fb][fi][fu][ff][fs]);
	279	wxFont **fontptr = &(m_FontsTable[fb][fi][fu][ff][fs]);
	280	wxFontEncoding *encptr = &(m_FontsEncTable[fb][fi][fu][ff][fs]);
	281
	282	if (fontptr != NULL && (faceptr != face \|\| *encptr != m_OutputEnc)) {
	283	delete *fontptr;
	284	*fontptr = NULL;
	285	}
	286
	287	if (*fontptr == NULL) {
	288	*faceptr = face;
	289	*encptr = m_OutputEnc;
	290	*fontptr = new wxFont(
	291	m_FontsSizes[fs] * m_PixelScale,
	292	ff ? wxMODERN : wxSWISS,
	293	fi ? wxITALIC : wxNORMAL,
	294	fb ? wxBOLD : wxNORMAL,
	295	fu ? TRUE : FALSE, face,
	296	m_OutputEnc);
	297	}
	298	m_DC -> SetFont(**fontptr);
	299	return (*fontptr);
	300	}
	301
	302
	303
	304	void wxHtmlWinParser::SetLink(const wxHtmlLinkInfo& link)
	305	{
	306	m_Link = link;
	307	m_UseLink = (link.GetHref() != wxEmptyString);
	308	}
	309
	310
	311	void wxHtmlWinParser::SetFontFace(const wxString& face)
	312	{
	313	if (GetFontFixed()) m_FontFaceFixed = face;
	314	else m_FontFaceNormal = face;
	315
	316	if (m_InputEnc != wxFONTENCODING_DEFAULT)
	317	SetInputEncoding(m_InputEnc);
	318	}
	319
	320
	321
	322	void wxHtmlWinParser::SetInputEncoding(wxFontEncoding enc)
	323	{
	324	m_InputEnc = m_OutputEnc = wxFONTENCODING_DEFAULT;
	325	if (m_EncConv) {delete m_EncConv; m_EncConv = NULL;}
	326
	327	if (enc == wxFONTENCODING_DEFAULT) return;
	328
	329	wxFontEncoding altfix, altnorm;
	330	bool availfix, availnorm;
	331
	332	// exact match?
	333	availnorm = wxTheFontMapper -> IsEncodingAvailable(enc, m_FontFaceNormal);
	334	availfix = wxTheFontMapper -> IsEncodingAvailable(enc, m_FontFaceFixed);
	335	if (availnorm && availfix)
	336	m_OutputEnc = enc;
	337
	338	// alternatives?
	339	else if (wxTheFontMapper -> GetAltForEncoding(enc, &altnorm, m_FontFaceNormal, FALSE) &&
	340	wxTheFontMapper -> GetAltForEncoding(enc, &altfix, m_FontFaceFixed, FALSE) &&
	341	altnorm == altfix)
	342	m_OutputEnc = altnorm;
	343
	344	// at least normal face?
	345	else if (availnorm)
	346	m_OutputEnc = enc;
	347	else if (wxTheFontMapper -> GetAltForEncoding(enc, &altnorm, m_FontFaceNormal, FALSE))
	348	m_OutputEnc = altnorm;
	349
	350	// okay, let convert to ISO_8859-1, available always
	351	else
	352	m_OutputEnc = wxFONTENCODING_DEFAULT;
	353
	354	m_InputEnc = enc;
	355
	356	if (m_InputEnc == m_OutputEnc) return;
	357
	358	m_EncConv = new wxEncodingConverter();
	359	if (!m_EncConv -> Init(m_InputEnc,
	360	(m_OutputEnc == wxFONTENCODING_DEFAULT) ?
	361	wxFONTENCODING_ISO8859_1 : m_OutputEnc,
	362	wxCONVERT_SUBSTITUTE))
	363	{ // total failture :-(
	364	wxLogError(_("Failed to display HTML document in %s encoding"),
	365	wxFontMapper::GetEncodingName(enc).c_str());
	366	m_InputEnc = m_OutputEnc = wxFONTENCODING_DEFAULT;
	367	delete m_EncConv;
	368	m_EncConv = NULL;
	369	}
	370	}
	371
	372
	373
	374
	375
	376	//-----------------------------------------------------------------------------
	377	// wxHtmlWinTagHandler
	378	//-----------------------------------------------------------------------------
	379
	380	IMPLEMENT_ABSTRACT_CLASS(wxHtmlWinTagHandler, wxHtmlTagHandler)
	381
	382
	383
	384	//-----------------------------------------------------------------------------
	385	// wxHtmlTagsModule
	386	//-----------------------------------------------------------------------------
	387
	388
	389	IMPLEMENT_DYNAMIC_CLASS(wxHtmlTagsModule, wxModule)
	390
	391
	392	bool wxHtmlTagsModule::OnInit()
	393	{
	394	wxHtmlWinParser::AddModule(this);
	395	return TRUE;
	396	}
	397
	398
	399
	400	void wxHtmlTagsModule::OnExit()
	401	{
	402	wxHtmlWinParser::RemoveModule(this);
	403	}
	404	#endif
	405