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
/////////////////////////////////////////////////////////////////////////////


#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
#pragma implementation "winpars.h"
#endif

#include "wx/wxprec.h"

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

#ifdef __BORLANDC__
#pragma hdrstop
#endif

#ifndef WXPRECOMP
    #include "wx/intl.h"
    #include "wx/dc.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(wxHtmlWindow *wnd) : wxHtmlParser()
{
    m_tmpStrBuf = NULL;
    m_tmpStrBufSize = 0;
    m_Window = wnd;
    m_Container = NULL;
    m_DC = NULL;
    m_CharHeight = m_CharWidth = 0;
    m_UseLink = FALSE;
#if !wxUSE_UNICODE
    m_EncConv = NULL;
    m_InputEnc = wxFONTENCODING_ISO8859_1;
    m_OutputEnc = wxFONTENCODING_DEFAULT;
#endif
    m_lastWordCell = NULL;

    {
        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;
#if !wxUSE_UNICODE
                            m_FontsEncTable[i][j][k][l][m] = wxFONTENCODING_DEFAULT;
#endif
                        }

        SetFonts(wxEmptyString, wxEmptyString, NULL);
    }

    // fill in wxHtmlParser's tables:
    wxList::compatibility_iterator 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 !wxUSE_UNICODE
    delete m_EncConv;
#endif
    delete[] m_tmpStrBuf;
}

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)
{
    static int default_sizes[7] =
        {
            wxHTML_FONT_SIZE_1,
			wxHTML_FONT_SIZE_2,
			wxHTML_FONT_SIZE_3,
			wxHTML_FONT_SIZE_4,
			wxHTML_FONT_SIZE_5,
			wxHTML_FONT_SIZE_6,
			wxHTML_FONT_SIZE_7
        };

    if (sizes == NULL) sizes = default_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;

#if !wxUSE_UNICODE
    SetInputEncoding(m_InputEnc);
#endif

    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, wxT("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( wxT("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( wxT(""), wxT("") );
    m_LinkColor.Set(0, 0, 0xFF);
    m_ActualColor.Set(0, 0, 0);
    m_Align = wxHTML_ALIGN_LEFT;
    m_tmpLastWasSpace = FALSE;
    m_lastWordCell = NULL;

    OpenContainer();
    OpenContainer();

#if !wxUSE_UNICODE
    wxString charset = ExtractCharsetInformation(source);
    if (!charset.empty())
    {
        wxFontEncoding enc = wxFontMapper::Get()->CharsetToEncoding(charset);
        if (enc != wxFONTENCODING_SYSTEM)
          SetInputEncoding(enc);
    }
#endif

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

void wxHtmlWinParser::DoneParser()
{
    m_Container = NULL;
#if !wxUSE_UNICODE
    SetInputEncoding(wxFONTENCODING_ISO8859_1); // for next call
#endif
    wxHtmlParser::DoneParser();
}

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

    CloseContainer();
    OpenContainer();

    top = m_Container;
    while (top->GetParent()) top = top->GetParent();
    top->RemoveExtraSpacing(true, true);

    return top;
}

wxFSFile *wxHtmlWinParser::OpenURL(wxHtmlURLType type,
                                   const wxString& url) const
{
    // FIXME - normalize the URL to full path before passing to
    //         OnOpeningURL!!
    if ( m_Window )
    {
        wxString myurl(url);
        wxHtmlOpeningStatus status;
        for (;;)
        {
            wxString redirect;
            status = m_Window->OnOpeningURL(type, myurl, &redirect);
            if ( status != wxHTML_REDIRECT )
                break;

            myurl = redirect;
        }

        if ( status == wxHTML_BLOCK )
            return NULL;

        return GetFS()->OpenFile(myurl);
    }

    return wxHtmlParser::OpenURL(type, url);
}

void wxHtmlWinParser::AddText(const wxChar* txt)
{
    wxHtmlCell *c;
    size_t i = 0,
           x,
           lng = wxStrlen(txt);
    register wxChar d;
    int templen = 0;
    wxChar nbsp = GetEntitiesParser()->GetCharForCode(160 /* nbsp */);

    if (lng+1 > m_tmpStrBufSize)
    {
        delete[] m_tmpStrBuf;
        m_tmpStrBuf = new wxChar[lng+1];
        m_tmpStrBufSize = lng+1;
    }
    wxChar *temp = m_tmpStrBuf;

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

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

        if (x)
        {
            temp[templen-1] = wxT(' ');
            temp[templen] = 0;
            templen = 0;
#if !wxUSE_UNICODE
            if (m_EncConv)
                m_EncConv->Convert(temp);
#endif
            size_t len = wxStrlen(temp);
            for (size_t j = 0; j < len; j++)
                if (temp[j] == nbsp)
                    temp[j] = wxT(' ');
            c = new wxHtmlWordCell(temp, *(GetDC()));
            if (m_UseLink)
                c->SetLink(m_Link);
            m_Container->InsertCell(c);
            ((wxHtmlWordCell*)c)->SetPreviousWord(m_lastWordCell);
            m_lastWordCell = (wxHtmlWordCell*)c;
            m_tmpLastWasSpace = TRUE;
        }
    }

    if (templen && (templen > 1 || temp[0] != wxT(' ')))
    {
        temp[templen] = 0;
#if !wxUSE_UNICODE
        if (m_EncConv)
            m_EncConv->Convert(temp);
#endif
        size_t len = wxStrlen(temp);
        for (size_t j = 0; j < len; j++)
            if (temp[j] == nbsp)
                temp[j] = wxT(' ');
        c = new wxHtmlWordCell(temp, *(GetDC()));
        if (m_UseLink)
            c->SetLink(m_Link);
        m_Container->InsertCell(c);
        ((wxHtmlWordCell*)c)->SetPreviousWord(m_lastWordCell);
        m_lastWordCell = (wxHtmlWordCell*)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]);
#if !wxUSE_UNICODE
    wxFontEncoding *encptr = &(m_FontsEncTable[fb][fi][fu][ff][fs]);
#endif

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

    if (*fontptr == NULL)
    {
        *faceptr = face;
        *fontptr = new wxFont(
                       (int) (m_FontsSizes[fs] * m_PixelScale),
                       ff ? wxMODERN : wxSWISS,
                       fi ? wxITALIC : wxNORMAL,
                       fb ? wxBOLD : wxNORMAL,
                       fu ? TRUE : FALSE, face
#if wxUSE_UNICODE
                       );
#else
                       , m_OutputEnc);
        *encptr = m_OutputEnc;
#endif
    }
    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 !wxUSE_UNICODE
    if (m_InputEnc != wxFONTENCODING_DEFAULT)
        SetInputEncoding(m_InputEnc);
#endif
}


#if !wxUSE_UNICODE
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 = wxFontMapper::Get()->IsEncodingAvailable(enc, m_FontFaceNormal);
    availfix = wxFontMapper::Get()->IsEncodingAvailable(enc, m_FontFaceFixed);
    if (availnorm && availfix)
        m_OutputEnc = enc;

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

    // at least normal face?
    else if (availnorm)
        m_OutputEnc = enc;
    else if (wxFontMapper::Get()->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_OutputEnc == wxFONTENCODING_DEFAULT)
        GetEntitiesParser()->SetEncoding(wxFONTENCODING_SYSTEM);
    else
        GetEntitiesParser()->SetEncoding(m_OutputEnc);

    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;
    }
}
#endif


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

IMPLEMENT_ABSTRACT_CLASS(wxHtmlWinTagHandler, wxHtmlTagHandler)

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

// NB: This is *NOT* winpars.cpp's initialization and shutdown code!!
//     This module is an ancestor for tag handlers modules defined
//     in m_*.cpp files with TAGS_MODULE_BEGIN...TAGS_MODULE_END construct.
//
//     Do not add any winpars.cpp shutdown or initialization code to it,
//     create a new module instead!

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	#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
	12	#pragma implementation "winpars.h"
	13	#endif
	14
	15	#include "wx/wxprec.h"
	16
	17	#include "wx/defs.h"
	18	#if wxUSE_HTML && wxUSE_STREAMS
	19
	20	#ifdef __BORLANDC__
	21	#pragma hdrstop
	22	#endif
	23
	24	#ifndef WXPRECOMP
	25	#include "wx/intl.h"
	26	#include "wx/dc.h"
	27	#endif
	28
	29	#include "wx/html/htmldefs.h"
	30	#include "wx/html/winpars.h"
	31	#include "wx/html/htmlwin.h"
	32	#include "wx/fontmap.h"
	33	#include "wx/log.h"
	34
	35
	36	//-----------------------------------------------------------------------------
	37	// wxHtmlWinParser
	38	//-----------------------------------------------------------------------------
	39
	40
	41	wxList wxHtmlWinParser::m_Modules;
	42
	43	wxHtmlWinParser::wxHtmlWinParser(wxHtmlWindow *wnd) : wxHtmlParser()
	44	{
	45	m_tmpStrBuf = NULL;
	46	m_tmpStrBufSize = 0;
	47	m_Window = wnd;
	48	m_Container = NULL;
	49	m_DC = NULL;
	50	m_CharHeight = m_CharWidth = 0;
	51	m_UseLink = FALSE;
	52	#if !wxUSE_UNICODE
	53	m_EncConv = NULL;
	54	m_InputEnc = wxFONTENCODING_ISO8859_1;
	55	m_OutputEnc = wxFONTENCODING_DEFAULT;
	56	#endif
	57	m_lastWordCell = NULL;
	58
	59	{
	60	int i, j, k, l, m;
	61	for (i = 0; i < 2; i++)
	62	for (j = 0; j < 2; j++)
	63	for (k = 0; k < 2; k++)
	64	for (l = 0; l < 2; l++)
	65	for (m = 0; m < 7; m++)
	66	{
	67	m_FontsTable[i][j][k][l][m] = NULL;
	68	m_FontsFacesTable[i][j][k][l][m] = wxEmptyString;
	69	#if !wxUSE_UNICODE
	70	m_FontsEncTable[i][j][k][l][m] = wxFONTENCODING_DEFAULT;
	71	#endif
	72	}
	73
	74	SetFonts(wxEmptyString, wxEmptyString, NULL);
	75	}
	76
	77	// fill in wxHtmlParser's tables:
	78	wxList::compatibility_iterator node = m_Modules.GetFirst();
	79	while (node)
	80	{
	81	wxHtmlTagsModule mod = (wxHtmlTagsModule) node->GetData();
	82	mod->FillHandlersTable(this);
	83	node = node->GetNext();
	84	}
	85	}
	86
	87	wxHtmlWinParser::~wxHtmlWinParser()
	88	{
	89	int i, j, k, l, m;
	90
	91	for (i = 0; i < 2; i++)
	92	for (j = 0; j < 2; j++)
	93	for (k = 0; k < 2; k++)
	94	for (l = 0; l < 2; l++)
	95	for (m = 0; m < 7; m++)
	96	{
	97	if (m_FontsTable[i][j][k][l][m] != NULL)
	98	delete m_FontsTable[i][j][k][l][m];
	99	}
	100	#if !wxUSE_UNICODE
	101	delete m_EncConv;
	102	#endif
	103	delete[] m_tmpStrBuf;
	104	}
	105
	106	void wxHtmlWinParser::AddModule(wxHtmlTagsModule *module)
	107	{
	108	m_Modules.Append(module);
	109	}
	110
	111	void wxHtmlWinParser::RemoveModule(wxHtmlTagsModule *module)
	112	{
	113	m_Modules.DeleteObject(module);
	114	}
	115
	116	void wxHtmlWinParser::SetFonts(wxString normal_face, wxString fixed_face,
	117	const int *sizes)
	118	{
	119	static int default_sizes[7] =
	120	{
	121	wxHTML_FONT_SIZE_1,
	122	wxHTML_FONT_SIZE_2,
	123	wxHTML_FONT_SIZE_3,
	124	wxHTML_FONT_SIZE_4,
	125	wxHTML_FONT_SIZE_5,
	126	wxHTML_FONT_SIZE_6,
	127	wxHTML_FONT_SIZE_7
	128	};
	129
	130	if (sizes == NULL) sizes = default_sizes;
	131
	132	int i, j, k, l, m;
	133
	134	for (i = 0; i < 7; i++) m_FontsSizes[i] = sizes[i];
	135	m_FontFaceFixed = fixed_face;
	136	m_FontFaceNormal = normal_face;
	137
	138	#if !wxUSE_UNICODE
	139	SetInputEncoding(m_InputEnc);
	140	#endif
	141
	142	for (i = 0; i < 2; i++)
	143	for (j = 0; j < 2; j++)
	144	for (k = 0; k < 2; k++)
	145	for (l = 0; l < 2; l++)
	146	for (m = 0; m < 7; m++) {
	147	if (m_FontsTable[i][j][k][l][m] != NULL)
	148	{
	149	delete m_FontsTable[i][j][k][l][m];
	150	m_FontsTable[i][j][k][l][m] = NULL;
	151	}
	152	}
	153	}
	154
	155	void wxHtmlWinParser::InitParser(const wxString& source)
	156	{
	157	wxHtmlParser::InitParser(source);
	158	wxASSERT_MSG(m_DC != NULL, wxT("no DC assigned to wxHtmlWinParser!!"));
	159
	160	m_FontBold = m_FontItalic = m_FontUnderlined = m_FontFixed = FALSE;
	161	m_FontSize = 3; //default one
	162	CreateCurrentFont(); // we're selecting default font into
	163	m_DC->GetTextExtent( wxT("H"), &m_CharWidth, &m_CharHeight);
	164	/* NOTE : we're not using GetCharWidth/Height() because
	165	of differences under X and win
	166	*/
	167
	168	m_UseLink = FALSE;
	169	m_Link = wxHtmlLinkInfo( wxT(""), wxT("") );
	170	m_LinkColor.Set(0, 0, 0xFF);
	171	m_ActualColor.Set(0, 0, 0);
	172	m_Align = wxHTML_ALIGN_LEFT;
	173	m_tmpLastWasSpace = FALSE;
	174	m_lastWordCell = NULL;
	175
	176	OpenContainer();
	177	OpenContainer();
	178
	179	#if !wxUSE_UNICODE
	180	wxString charset = ExtractCharsetInformation(source);
	181	if (!charset.empty())
	182	{
	183	wxFontEncoding enc = wxFontMapper::Get()->CharsetToEncoding(charset);
	184	if (enc != wxFONTENCODING_SYSTEM)
	185	SetInputEncoding(enc);
	186	}
	187	#endif
	188
	189	m_Container->InsertCell(new wxHtmlColourCell(m_ActualColor));
	190	m_Container->InsertCell(new wxHtmlFontCell(CreateCurrentFont()));
	191	}
	192
	193	void wxHtmlWinParser::DoneParser()
	194	{
	195	m_Container = NULL;
	196	#if !wxUSE_UNICODE
	197	SetInputEncoding(wxFONTENCODING_ISO8859_1); // for next call
	198	#endif
	199	wxHtmlParser::DoneParser();
	200	}
	201
	202	wxObject* wxHtmlWinParser::GetProduct()
	203	{
	204	wxHtmlContainerCell *top;
	205
	206	CloseContainer();
	207	OpenContainer();
	208
	209	top = m_Container;
	210	while (top->GetParent()) top = top->GetParent();
	211	top->RemoveExtraSpacing(true, true);
	212
	213	return top;
	214	}
	215
	216	wxFSFile *wxHtmlWinParser::OpenURL(wxHtmlURLType type,
	217	const wxString& url) const
	218	{
	219	// FIXME - normalize the URL to full path before passing to
	220	// OnOpeningURL!!
	221	if ( m_Window )
	222	{
	223	wxString myurl(url);
	224	wxHtmlOpeningStatus status;
	225	for (;;)
	226	{
	227	wxString redirect;
	228	status = m_Window->OnOpeningURL(type, myurl, &redirect);
	229	if ( status != wxHTML_REDIRECT )
	230	break;
	231
	232	myurl = redirect;
	233	}
	234
	235	if ( status == wxHTML_BLOCK )
	236	return NULL;
	237
	238	return GetFS()->OpenFile(myurl);
	239	}
	240
	241	return wxHtmlParser::OpenURL(type, url);
	242	}
	243
	244	void wxHtmlWinParser::AddText(const wxChar* txt)
	245	{
	246	wxHtmlCell *c;
	247	size_t i = 0,
	248	x,
	249	lng = wxStrlen(txt);
	250	register wxChar d;
	251	int templen = 0;
	252	wxChar nbsp = GetEntitiesParser()->GetCharForCode(160 /* nbsp */);
	253
	254	if (lng+1 > m_tmpStrBufSize)
	255	{
	256	delete[] m_tmpStrBuf;
	257	m_tmpStrBuf = new wxChar[lng+1];
	258	m_tmpStrBufSize = lng+1;
	259	}
	260	wxChar *temp = m_tmpStrBuf;
	261
	262	if (m_tmpLastWasSpace)
	263	{
	264	while ((i < lng) &&
	265	((txt[i] == wxT('\n')) \|\| (txt[i] == wxT('\r')) \|\| (txt[i] == wxT(' ')) \|\|
	266	(txt[i] == wxT('\t')))) i++;
	267	}
	268
	269	while (i < lng)
	270	{
	271	x = 0;
	272	d = temp[templen++] = txt[i];
	273	if ((d == wxT('\n')) \|\| (d == wxT('\r')) \|\| (d == wxT(' ')) \|\| (d == wxT('\t')))
	274	{
	275	i++, x++;
	276	while ((i < lng) && ((txt[i] == wxT('\n')) \|\| (txt[i] == wxT('\r')) \|\|
	277	(txt[i] == wxT(' ')) \|\| (txt[i] == wxT('\t')))) i++, x++;
	278	}
	279	else i++;
	280
	281	if (x)
	282	{
	283	temp[templen-1] = wxT(' ');
	284	temp[templen] = 0;
	285	templen = 0;
	286	#if !wxUSE_UNICODE
	287	if (m_EncConv)
	288	m_EncConv->Convert(temp);
	289	#endif
	290	size_t len = wxStrlen(temp);
	291	for (size_t j = 0; j < len; j++)
	292	if (temp[j] == nbsp)
	293	temp[j] = wxT(' ');
	294	c = new wxHtmlWordCell(temp, *(GetDC()));
	295	if (m_UseLink)
	296	c->SetLink(m_Link);
	297	m_Container->InsertCell(c);
	298	((wxHtmlWordCell*)c)->SetPreviousWord(m_lastWordCell);
	299	m_lastWordCell = (wxHtmlWordCell*)c;
	300	m_tmpLastWasSpace = TRUE;
	301	}
	302	}
	303
	304	if (templen && (templen > 1 \|\| temp[0] != wxT(' ')))
	305	{
	306	temp[templen] = 0;
	307	#if !wxUSE_UNICODE
	308	if (m_EncConv)
	309	m_EncConv->Convert(temp);
	310	#endif
	311	size_t len = wxStrlen(temp);
	312	for (size_t j = 0; j < len; j++)
	313	if (temp[j] == nbsp)
	314	temp[j] = wxT(' ');
	315	c = new wxHtmlWordCell(temp, *(GetDC()));
	316	if (m_UseLink)
	317	c->SetLink(m_Link);
	318	m_Container->InsertCell(c);
	319	((wxHtmlWordCell*)c)->SetPreviousWord(m_lastWordCell);
	320	m_lastWordCell = (wxHtmlWordCell*)c;
	321	m_tmpLastWasSpace = FALSE;
	322	}
	323	}
	324
	325
	326
	327	wxHtmlContainerCell* wxHtmlWinParser::OpenContainer()
	328	{
	329	m_Container = new wxHtmlContainerCell(m_Container);
	330	m_Container->SetAlignHor(m_Align);
	331	m_tmpLastWasSpace = TRUE;
	332	/* to avoid space being first character in paragraph */
	333	return m_Container;
	334	}
	335
	336
	337
	338	wxHtmlContainerCell* wxHtmlWinParser::SetContainer(wxHtmlContainerCell *c)
	339	{
	340	m_tmpLastWasSpace = TRUE;
	341	/* to avoid space being first character in paragraph */
	342	return m_Container = c;
	343	}
	344
	345
	346
	347	wxHtmlContainerCell* wxHtmlWinParser::CloseContainer()
	348	{
	349	m_Container = m_Container->GetParent();
	350	return m_Container;
	351	}
	352
	353
	354	void wxHtmlWinParser::SetFontSize(int s)
	355	{
	356	if (s < 1) s = 1;
	357	else if (s > 7) s = 7;
	358	m_FontSize = s;
	359	}
	360
	361
	362
	363	wxFont* wxHtmlWinParser::CreateCurrentFont()
	364	{
	365	int fb = GetFontBold(),
	366	fi = GetFontItalic(),
	367	fu = GetFontUnderlined(),
	368	ff = GetFontFixed(),
	369	fs = GetFontSize() - 1 /remap from <1;7> to <0;6>/ ;
	370
	371	wxString face = ff ? m_FontFaceFixed : m_FontFaceNormal;
	372	wxString *faceptr = &(m_FontsFacesTable[fb][fi][fu][ff][fs]);
	373	wxFont **fontptr = &(m_FontsTable[fb][fi][fu][ff][fs]);
	374	#if !wxUSE_UNICODE
	375	wxFontEncoding *encptr = &(m_FontsEncTable[fb][fi][fu][ff][fs]);
	376	#endif
	377
	378	if (fontptr != NULL && (faceptr != face
	379	#if !wxUSE_UNICODE
	380	\|\| *encptr != m_OutputEnc
	381	#endif
	382	))
	383	{
	384	delete *fontptr;
	385	*fontptr = NULL;
	386	}
	387
	388	if (*fontptr == NULL)
	389	{
	390	*faceptr = face;
	391	*fontptr = new wxFont(
	392	(int) (m_FontsSizes[fs] * m_PixelScale),
	393	ff ? wxMODERN : wxSWISS,
	394	fi ? wxITALIC : wxNORMAL,
	395	fb ? wxBOLD : wxNORMAL,
	396	fu ? TRUE : FALSE, face
	397	#if wxUSE_UNICODE
	398	);
	399	#else
	400	, m_OutputEnc);
	401	*encptr = m_OutputEnc;
	402	#endif
	403	}
	404	m_DC->SetFont(**fontptr);
	405	return (*fontptr);
	406	}
	407
	408
	409
	410	void wxHtmlWinParser::SetLink(const wxHtmlLinkInfo& link)
	411	{
	412	m_Link = link;
	413	m_UseLink = (link.GetHref() != wxEmptyString);
	414	}
	415
	416
	417	void wxHtmlWinParser::SetFontFace(const wxString& face)
	418	{
	419	if (GetFontFixed()) m_FontFaceFixed = face;
	420	else m_FontFaceNormal = face;
	421
	422	#if !wxUSE_UNICODE
	423	if (m_InputEnc != wxFONTENCODING_DEFAULT)
	424	SetInputEncoding(m_InputEnc);
	425	#endif
	426	}
	427
	428
	429
	430	#if !wxUSE_UNICODE
	431	void wxHtmlWinParser::SetInputEncoding(wxFontEncoding enc)
	432	{
	433	m_InputEnc = m_OutputEnc = wxFONTENCODING_DEFAULT;
	434	if (m_EncConv)
	435	{
	436	delete m_EncConv;
	437	m_EncConv = NULL;
	438	}
	439
	440	if (enc == wxFONTENCODING_DEFAULT) return;
	441
	442	wxFontEncoding altfix, altnorm;
	443	bool availfix, availnorm;
	444
	445	// exact match?
	446	availnorm = wxFontMapper::Get()->IsEncodingAvailable(enc, m_FontFaceNormal);
	447	availfix = wxFontMapper::Get()->IsEncodingAvailable(enc, m_FontFaceFixed);
	448	if (availnorm && availfix)
	449	m_OutputEnc = enc;
	450
	451	// alternatives?
	452	else if (wxFontMapper::Get()->GetAltForEncoding(enc, &altnorm, m_FontFaceNormal, FALSE) &&
	453	wxFontMapper::Get()->GetAltForEncoding(enc, &altfix, m_FontFaceFixed, FALSE) &&
	454	altnorm == altfix)
	455	m_OutputEnc = altnorm;
	456
	457	// at least normal face?
	458	else if (availnorm)
	459	m_OutputEnc = enc;
	460	else if (wxFontMapper::Get()->GetAltForEncoding(enc, &altnorm, m_FontFaceNormal, FALSE))
	461	m_OutputEnc = altnorm;
	462
	463	// okay, let convert to ISO_8859-1, available always
	464	else
	465	m_OutputEnc = wxFONTENCODING_DEFAULT;
	466
	467	m_InputEnc = enc;
	468	if (m_OutputEnc == wxFONTENCODING_DEFAULT)
	469	GetEntitiesParser()->SetEncoding(wxFONTENCODING_SYSTEM);
	470	else
	471	GetEntitiesParser()->SetEncoding(m_OutputEnc);
	472
	473	if (m_InputEnc == m_OutputEnc) return;
	474
	475	m_EncConv = new wxEncodingConverter();
	476	if (!m_EncConv->Init(m_InputEnc,
	477	(m_OutputEnc == wxFONTENCODING_DEFAULT) ?
	478	wxFONTENCODING_ISO8859_1 : m_OutputEnc,
	479	wxCONVERT_SUBSTITUTE))
	480	{ // total failture :-(
	481	wxLogError(_("Failed to display HTML document in %s encoding"),
	482	wxFontMapper::GetEncodingName(enc).c_str());
	483	m_InputEnc = m_OutputEnc = wxFONTENCODING_DEFAULT;
	484	delete m_EncConv;
	485	m_EncConv = NULL;
	486	}
	487	}
	488	#endif
	489
	490
	491
	492
	493	//-----------------------------------------------------------------------------
	494	// wxHtmlWinTagHandler
	495	//-----------------------------------------------------------------------------
	496
	497	IMPLEMENT_ABSTRACT_CLASS(wxHtmlWinTagHandler, wxHtmlTagHandler)
	498
	499	//-----------------------------------------------------------------------------
	500	// wxHtmlTagsModule
	501	//-----------------------------------------------------------------------------
	502
	503	// NB: This is NOT winpars.cpp's initialization and shutdown code!!
	504	// This module is an ancestor for tag handlers modules defined
	505	// in m_*.cpp files with TAGS_MODULE_BEGIN...TAGS_MODULE_END construct.
	506	//
	507	// Do not add any winpars.cpp shutdown or initialization code to it,
	508	// create a new module instead!
	509
	510	IMPLEMENT_DYNAMIC_CLASS(wxHtmlTagsModule, wxModule)
	511
	512	bool wxHtmlTagsModule::OnInit()
	513	{
	514	wxHtmlWinParser::AddModule(this);
	515	return TRUE;
	516	}
	517
	518	void wxHtmlTagsModule::OnExit()
	519	{
	520	wxHtmlWinParser::RemoveModule(this);
	521	}
	522
	523	#endif
	524