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

/////////////////////////////////////////////////////////////////////////////
// Name:        htmltag.cpp
// Purpose:     wxHtmlTag class (represents single tag)
// 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

#ifdef __BORDLANDC__
#pragma hdrstop
#endif

#ifndef WXPRECOMP
#endif

#include "wx/html/htmltag.h"
#include "wx/html/htmlpars.h"
#include "wx/colour.h"
#include <stdio.h> // for vsscanf
#include <stdarg.h>


//-----------------------------------------------------------------------------
// wxHtmlTagsCache
//-----------------------------------------------------------------------------

struct wxHtmlCacheItem
{
    // this is "pos" value passed to wxHtmlTag's constructor.
    // it is position of '<' character of the tag
    int Key;

    // end positions for the tag:
    // end1 is '<' of ending tag,
    // end2 is '>' or both are
    // -1 if there is no ending tag for this one...
    // or -2 if this is ending tag  </...>
    int End1, End2;

    // name of this tag
    wxChar *Name;
};


IMPLEMENT_CLASS(wxHtmlTagsCache,wxObject)

#define CACHE_INCREMENT  64

wxHtmlTagsCache::wxHtmlTagsCache(const wxString& source)
{
    const wxChar *src = source.c_str();
    int i, tg, pos, stpos;
    int lng = source.Length();
    wxChar dummy[256];

    m_Cache = NULL;
    m_CacheSize = 0;
    m_CachePos = 0;

    pos = 0;
    while (pos < lng) 
    {
        if (src[pos] == wxT('<'))   // tag found:
        {
            if (m_CacheSize % CACHE_INCREMENT == 0)
                m_Cache = (wxHtmlCacheItem*) realloc(m_Cache, (m_CacheSize + CACHE_INCREMENT) * sizeof(wxHtmlCacheItem));
            tg = m_CacheSize++;
            m_Cache[tg].Key = stpos = pos++;
            dummy[0] = 0; i = 0;
            while (pos < lng && 
                   src[pos] != wxT('>') &&
                   src[pos] != wxT(' ') && src[pos] != wxT('\r') && 
                   src[pos] != wxT('\n') && src[pos] != wxT('\t')) 
            {
                dummy[i] = src[pos++];
                if ((dummy[i] >= wxT('a')) && (dummy[i] <= wxT('z'))) dummy[i] -= (wxT('a') - wxT('A'));
                i++;
            }
            dummy[i] = 0;
            m_Cache[tg].Name = new wxChar[i+1];
            memcpy(m_Cache[tg].Name, dummy, (i+1)*sizeof(wxChar));

            while (pos < lng && src[pos] != wxT('>')) pos++;

            if (src[stpos+1] == wxT('/')) // ending tag:
            {
                m_Cache[tg].End1 = m_Cache[tg].End2 = -2;
                // find matching begin tag:
                for (i = tg; i >= 0; i--)
                    if ((m_Cache[i].End1 == -1) && (wxStrcmp(m_Cache[i].Name, dummy+1) == 0)) 
                    {
                        m_Cache[i].End1 = stpos;
                        m_Cache[i].End2 = pos + 1;
                        break;
                    }
            }
            else 
            {
                m_Cache[tg].End1 = m_Cache[tg].End2 = -1;
            }
        }

        pos++;
    }

    // ok, we're done, now we'll free .Name members of cache - we don't need it anymore:
    for (i = 0; i < m_CacheSize; i++) 
    {
        delete[] m_Cache[i].Name;
        m_Cache[i].Name = NULL;
    }
}

void wxHtmlTagsCache::QueryTag(int at, int* end1, int* end2)
{
    if (m_Cache == NULL) return;
    if (m_Cache[m_CachePos].Key != at) 
    {
        int delta = (at < m_Cache[m_CachePos].Key) ? -1 : 1;
        do 
        { 
            m_CachePos += delta; 
        }
        while (m_Cache[m_CachePos].Key != at);
    }
    *end1 = m_Cache[m_CachePos].End1;
    *end2 = m_Cache[m_CachePos].End2;
}


//-----------------------------------------------------------------------------
// wxHtmlTag
//-----------------------------------------------------------------------------

IMPLEMENT_CLASS(wxHtmlTag,wxObject)

wxHtmlTag::wxHtmlTag(wxHtmlTag *parent,
                     const wxString& source, int pos, int end_pos, 
                     wxHtmlTagsCache *cache,
                     wxHtmlEntitiesParser *entParser) : wxObject()
{
    /* Setup DOM relations */

    m_Next = NULL;
    m_FirstChild = m_LastChild = NULL;
    m_Parent = parent;
    if (parent)
    {
        m_Prev = m_Parent->m_LastChild;
        if (m_Prev == NULL)
            m_Parent->m_FirstChild = this;
        else
            m_Prev->m_Next = this;
        m_Parent->m_LastChild = this;
    }
    else
        m_Prev = NULL;

    /* Find parameters and their values: */
    
    int i;
    wxChar c;

    // fill-in name, params and begin pos:
    i = pos+1;

    // find tag's name and convert it to uppercase:
    while ((i < end_pos) && 
           ((c = source[i++]) != wxT(' ') && c != wxT('\r') && 
             c != wxT('\n') && c != wxT('\t') &&
             c != wxT('>'))) 
    {
        if ((c >= wxT('a')) && (c <= wxT('z'))) 
            c -= (wxT('a') - wxT('A'));
        m_Name << c;
    }

    // if the tag has parameters, read them and "normalize" them,
    // i.e. convert to uppercase, replace whitespaces by spaces and 
    // remove whitespaces around '=':
    if (source[i-1] != wxT('>'))
    {
        #define IS_WHITE(c) (c == wxT(' ') || c == wxT('\r') || \
                             c == wxT('\n') || c == wxT('\t'))
        wxString pname, pvalue;
        wxChar quote;
        enum 
        {
            ST_BEFORE_NAME = 1, 
            ST_NAME,
            ST_BEFORE_EQ,
            ST_BEFORE_VALUE,
            ST_VALUE
        } state;
    
        quote = 0;
        state = ST_BEFORE_NAME;
        while (i < end_pos)
        {
            c = source[i++];

            if (c == wxT('>') && !(state == ST_VALUE && quote != 0)) 
            {
                if (state == ST_BEFORE_EQ || state == ST_NAME)
                {
                    m_ParamNames.Add(pname);
                    m_ParamValues.Add(wxEmptyString);
                }
                else if (state == ST_VALUE && quote == 0)
                {
                    m_ParamNames.Add(pname);
                    if (entParser)
                        m_ParamValues.Add(entParser->Parse(pvalue));
                    else
                        m_ParamValues.Add(pvalue);
                }
                break;
            }
            switch (state)
            {
                case ST_BEFORE_NAME:
                    if (!IS_WHITE(c))
                    {
                        pname = c;
                        state = ST_NAME;
                    }
                    break;
                case ST_NAME:
                    if (IS_WHITE(c))
                        state = ST_BEFORE_EQ;
                    else if (c == wxT('='))
                        state = ST_BEFORE_VALUE;
                    else
                        pname << c;
                    break;
                case ST_BEFORE_EQ:
                    if (c == wxT('='))
                        state = ST_BEFORE_VALUE;
                    else if (!IS_WHITE(c))
                    {
                        m_ParamNames.Add(pname);
                        m_ParamValues.Add(wxEmptyString);
                        pname = c;
                        state = ST_NAME;
                    }
                    break;
                case ST_BEFORE_VALUE:
                    if (!IS_WHITE(c))
                    {
                        if (c == wxT('"') || c == wxT('\''))
                            quote = c, pvalue = wxEmptyString;
                        else
                            quote = 0, pvalue = c;
                        state = ST_VALUE;
                    }
                    break;
                case ST_VALUE:
                    if ((quote != 0 && c == quote) ||
                        (quote == 0 && IS_WHITE(c)))
                    {
                        m_ParamNames.Add(pname);
                        if (quote == 0)
                        {
                            // VS: backward compatibility, no real reason,
                            //     but wxHTML code relies on this... :(
                            pvalue.MakeUpper();
                        }
                        if (entParser)
                            m_ParamValues.Add(entParser->Parse(pvalue));
                        else
                            m_ParamValues.Add(pvalue);
                        state = ST_BEFORE_NAME;
                    }
                    else
                        pvalue << c;
                    break;
            }
        }
        
        #undef IS_WHITE
   }
   m_Begin = i;

   cache->QueryTag(pos, &m_End1, &m_End2);
   if (m_End1 > end_pos) m_End1 = end_pos;
   if (m_End2 > end_pos) m_End2 = end_pos;
}

wxHtmlTag::~wxHtmlTag()
{
    wxHtmlTag *t1, *t2;
    t1 = m_FirstChild;
    while (t1)
    {
        t2 = t1->GetNextSibling();
        delete t1;
        t1 = t2;
    }
}

bool wxHtmlTag::HasParam(const wxString& par) const
{
    return (m_ParamNames.Index(par, FALSE) != wxNOT_FOUND);
}

wxString wxHtmlTag::GetParam(const wxString& par, bool with_commas) const
{
    int index = m_ParamNames.Index(par, FALSE);
    if (index == wxNOT_FOUND)
        return wxEmptyString;
    if (with_commas)
    {
        // VS: backward compatibility, seems to be never used by wxHTML...
        wxString s;
        s << wxT('"') << m_ParamValues[index] << wxT('"');
        return s;
    }
    else
        return m_ParamValues[index];
}

int wxHtmlTag::ScanParam(const wxString& par, wxChar *format, void *param) const
{
    wxString parval = GetParam(par);
    return wxSscanf(parval, format, param);
}

bool wxHtmlTag::GetParamAsColour(const wxString& par, wxColour *clr) const
{
    wxString str = GetParam(par);
    
    if (str.IsEmpty()) return FALSE;
    if (str.GetChar(0) == wxT('#'))
    {
        unsigned long tmp;
        if (ScanParam(par, wxT("#%lX"), &tmp) != 1)
            return FALSE;
        *clr = wxColour((unsigned char)((tmp & 0xFF0000) >> 16),
					    (unsigned char)((tmp & 0x00FF00) >> 8),
					    (unsigned char)(tmp & 0x0000FF));
        return TRUE;
    }
    else
    {
        // Handle colours defined in HTML 4.0:
        #define HTML_COLOUR(name,r,g,b)                 \
            if (str.IsSameAs(wxT(name), FALSE))         \
                { *clr = wxColour(r,g,b); return TRUE; }
        HTML_COLOUR("black",   0x00,0x00,0x00)
        HTML_COLOUR("silver",  0xC0,0xC0,0xC0)
        HTML_COLOUR("gray",    0x80,0x80,0x80)
        HTML_COLOUR("white",   0xFF,0xFF,0xFF)
        HTML_COLOUR("maroon",  0x80,0x00,0x00)
        HTML_COLOUR("red",     0xFF,0x00,0x00)
        HTML_COLOUR("purple",  0x80,0x00,0x80)
        HTML_COLOUR("fuchsia", 0xFF,0x00,0xFF)
        HTML_COLOUR("green",   0x00,0x80,0x00)
        HTML_COLOUR("lime",    0x00,0xFF,0x00)
        HTML_COLOUR("olive",   0x80,0x80,0x00)
        HTML_COLOUR("yellow",  0xFF,0xFF,0x00)
        HTML_COLOUR("navy",    0x00,0x00,0x80)
        HTML_COLOUR("blue",    0x00,0x00,0xFF)
        HTML_COLOUR("teal",    0x00,0x80,0x80)
        HTML_COLOUR("aqua",    0x00,0xFF,0xFF)
        #undef HTML_COLOUR
    }

    return FALSE;
}

bool wxHtmlTag::GetParamAsInt(const wxString& par, int *clr) const
{
    if (!HasParam(par)) return FALSE;
    long i;
    bool succ = GetParam(par).ToLong(&i);
    *clr = (int)i;
    return succ;
}

wxString wxHtmlTag::GetAllParams() const
{
    // VS: this function is for backward compatiblity only, 
    //     never used by wxHTML
    wxString s;
    size_t cnt = m_ParamNames.GetCount();
    for (size_t i = 0; i < cnt; i++)
    {
        s << m_ParamNames[i];
        s << wxT('=');
        if (m_ParamValues[i].Find(wxT('"')) != wxNOT_FOUND)
            s << wxT('\'') << m_ParamValues[i] << wxT('\'');
        else
            s << wxT('"') << m_ParamValues[i] << wxT('"');
    }
    return s;
}

wxHtmlTag *wxHtmlTag::GetFirstSibling() const
{
    if (m_Parent)
        return m_Parent->m_FirstChild;
    else
    {
        wxHtmlTag *cur = (wxHtmlTag*)this;
        while (cur->m_Prev) 
            cur = cur->m_Prev;
        return cur;
    }
}

wxHtmlTag *wxHtmlTag::GetLastSibling() const
{
    if (m_Parent)
        return m_Parent->m_LastChild;
    else
    {
        wxHtmlTag *cur = (wxHtmlTag*)this;
        while (cur->m_Next) 
            cur = cur->m_Next;
        return cur;
    }
}

wxHtmlTag *wxHtmlTag::GetNextTag() const
{
    if (m_FirstChild) return m_FirstChild;
    if (m_Next) return m_Next;
    wxHtmlTag *cur = m_Parent;
    if (!cur) return NULL;
    while (cur->m_Parent && !cur->m_Next) 
        cur = cur->m_Parent;
    return cur->m_Next;
}

#endif
Commit	Line	Data
5526e819 VS	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: htmltag.cpp
	3	// Purpose: wxHtmlTag class (represents single tag)
	4	// Author: Vaclav Slavik
69941f05	5	// RCS-ID: $Id$
5526e819 VS	6	// Copyright: (c) 1999 Vaclav Slavik
	7	// Licence: wxWindows Licence
	8	/////////////////////////////////////////////////////////////////////////////
	9
	10
	11	#ifdef __GNUG__
	12	#pragma implementation
	13	#endif
	14
3096bd2f	15	#include "wx/wxprec.h"
5526e819 VS	16
	17	#include "wx/defs.h"
	18	#if wxUSE_HTML
	19
	20	#ifdef __BORDLANDC__
	21	#pragma hdrstop
	22	#endif
	23
	24	#ifndef WXPRECOMP
5526e819 VS	25	#endif
5526e819 VS	26
69941f05	27	#include "wx/html/htmltag.h"
daa616fc	28	#include "wx/html/htmlpars.h"
fc1f2125	29	#include "wx/colour.h"
7e1e0960	30	#include <stdio.h> // for vsscanf
5526e819 VS	31	#include <stdarg.h>
	32
	33
5526e819 VS	34	//-----------------------------------------------------------------------------
	35	// wxHtmlTagsCache
	36	//-----------------------------------------------------------------------------
	37
5e8e25e7 VS	38	struct wxHtmlCacheItem
	39	{
	40	// this is "pos" value passed to wxHtmlTag's constructor.
	41	// it is position of '<' character of the tag
	42	int Key;
	43
	44	// end positions for the tag:
	45	// end1 is '<' of ending tag,
	46	// end2 is '>' or both are
	47	// -1 if there is no ending tag for this one...
	48	// or -2 if this is ending tag </...>
	49	int End1, End2;
	50
	51	// name of this tag
	52	wxChar *Name;
	53	};
	54
	55
5526e819 VS	56	IMPLEMENT_CLASS(wxHtmlTagsCache,wxObject)
	57
	58	#define CACHE_INCREMENT 64
	59
	60	wxHtmlTagsCache::wxHtmlTagsCache(const wxString& source)
	61	{
66a77a74	62	const wxChar *src = source.c_str();
5526e819 VS	63	int i, tg, pos, stpos;
5526e819 VS	64	int lng = source.Length();
66a77a74	65	wxChar dummy[256];
5526e819 VS	66
	67	m_Cache = NULL;
	68	m_CacheSize = 0;
	69	m_CachePos = 0;
	70
	71	pos = 0;
4f9297b0 VS	72	while (pos < lng)
	73	{
	74	if (src[pos] == wxT('<')) // tag found:
a914db0f	75	{
5526e819	76	if (m_CacheSize % CACHE_INCREMENT == 0)
5e8e25e7	77	m_Cache = (wxHtmlCacheItem) realloc(m_Cache, (m_CacheSize + CACHE_INCREMENT) sizeof(wxHtmlCacheItem));
5526e819 VS	78	tg = m_CacheSize++;
	79	m_Cache[tg].Key = stpos = pos++;
	80	dummy[0] = 0; i = 0;
15db3cf5 VS	81	while (pos < lng &&
15db3cf5 VS	82	src[pos] != wxT('>') &&
f6bcfd97	83	src[pos] != wxT(' ') && src[pos] != wxT('\r') &&
4f9297b0	84	src[pos] != wxT('\n') && src[pos] != wxT('\t'))
a914db0f	85	{
5526e819	86	dummy[i] = src[pos++];
66a77a74	87	if ((dummy[i] >= wxT('a')) && (dummy[i] <= wxT('z'))) dummy[i] -= (wxT('a') - wxT('A'));
5526e819 VS	88	i++;
	89	}
	90	dummy[i] = 0;
66a77a74 OK	91	m_Cache[tg].Name = new wxChar[i+1];
66a77a74 OK	92	memcpy(m_Cache[tg].Name, dummy, (i+1)*sizeof(wxChar));
5526e819	93
15db3cf5	94	while (pos < lng && src[pos] != wxT('>')) pos++;
5526e819	95
4f9297b0	96	if (src[stpos+1] == wxT('/')) // ending tag:
a914db0f	97	{
5526e819 VS	98	m_Cache[tg].End1 = m_Cache[tg].End2 = -2;
	99	// find matching begin tag:
	100	for (i = tg; i >= 0; i--)
4f9297b0	101	if ((m_Cache[i].End1 == -1) && (wxStrcmp(m_Cache[i].Name, dummy+1) == 0))
a914db0f	102	{
5526e819 VS	103	m_Cache[i].End1 = stpos;
	104	m_Cache[i].End2 = pos + 1;
	105	break;
	106	}
	107	}
4f9297b0	108	else
a914db0f	109	{
5526e819 VS	110	m_Cache[tg].End1 = m_Cache[tg].End2 = -1;
	111	}
	112	}
	113
	114	pos++;
	115	}
	116
	117	// ok, we're done, now we'll free .Name members of cache - we don't need it anymore:
4f9297b0 VS	118	for (i = 0; i < m_CacheSize; i++)
4f9297b0 VS	119	{
2776d7c3	120	delete[] m_Cache[i].Name;
5526e819 VS	121	m_Cache[i].Name = NULL;
	122	}
	123	}
	124
5526e819 VS	125	void wxHtmlTagsCache::QueryTag(int at, int* end1, int* end2)
	126	{
	127	if (m_Cache == NULL) return;
4f9297b0 VS	128	if (m_Cache[m_CachePos].Key != at)
4f9297b0 VS	129	{
5526e819	130	int delta = (at < m_Cache[m_CachePos].Key) ? -1 : 1;
daa616fc VS	131	do
	132	{
	133	m_CachePos += delta;
	134	}
	135	while (m_Cache[m_CachePos].Key != at);
5526e819 VS	136	}
	137	*end1 = m_Cache[m_CachePos].End1;
	138	*end2 = m_Cache[m_CachePos].End2;
	139	}
	140
	141
	142
	143
	144	//-----------------------------------------------------------------------------
	145	// wxHtmlTag
	146	//-----------------------------------------------------------------------------
	147
	148	IMPLEMENT_CLASS(wxHtmlTag,wxObject)
	149
211dfedd VS	150	wxHtmlTag::wxHtmlTag(wxHtmlTag *parent,
211dfedd VS	151	const wxString& source, int pos, int end_pos,
daa616fc VS	152	wxHtmlTagsCache *cache,
daa616fc VS	153	wxHtmlEntitiesParser *entParser) : wxObject()
5526e819	154	{
211dfedd VS	155	/* Setup DOM relations */
	156
	157	m_Next = NULL;
	158	m_FirstChild = m_LastChild = NULL;
	159	m_Parent = parent;
	160	if (parent)
	161	{
	162	m_Prev = m_Parent->m_LastChild;
	163	if (m_Prev == NULL)
	164	m_Parent->m_FirstChild = this;
	165	else
	166	m_Prev->m_Next = this;
	167	m_Parent->m_LastChild = this;
	168	}
	169	else
	170	m_Prev = NULL;
	171
	172	/* Find parameters and their values: */
	173
5526e819	174	int i;
daa616fc	175	wxChar c;
5526e819 VS	176
5526e819 VS	177	// fill-in name, params and begin pos:
5526e819	178	i = pos+1;
5526e819	179
b076dc01	180	// find tag's name and convert it to uppercase:
f6bcfd97	181	while ((i < end_pos) &&
daa616fc VS	182	((c = source[i++]) != wxT(' ') && c != wxT('\r') &&
	183	c != wxT('\n') && c != wxT('\t') &&
	184	c != wxT('>')))
a914db0f	185	{
daa616fc VS	186	if ((c >= wxT('a')) && (c <= wxT('z')))
	187	c -= (wxT('a') - wxT('A'));
	188	m_Name << c;
5526e819 VS	189	}
5526e819 VS	190
b076dc01 VS	191	// if the tag has parameters, read them and "normalize" them,
	192	// i.e. convert to uppercase, replace whitespaces by spaces and
	193	// remove whitespaces around '=':
c9893146	194	if (source[i-1] != wxT('>'))
daa616fc VS	195	{
	196	#define IS_WHITE(c) (c == wxT(' ') \|\| c == wxT('\r') \|\| \
	197	c == wxT('\n') \|\| c == wxT('\t'))
	198	wxString pname, pvalue;
	199	wxChar quote;
	200	enum
a914db0f	201	{
daa616fc VS	202	ST_BEFORE_NAME = 1,
	203	ST_NAME,
	204	ST_BEFORE_EQ,
	205	ST_BEFORE_VALUE,
	206	ST_VALUE
	207	} state;
	208
	209	quote = 0;
	210	state = ST_BEFORE_NAME;
	211	while (i < end_pos)
	212	{
	213	c = source[i++];
	214
	215	if (c == wxT('>') && !(state == ST_VALUE && quote != 0))
a914db0f	216	{
daa616fc	217	if (state == ST_BEFORE_EQ \|\| state == ST_NAME)
b076dc01	218	{
daa616fc VS	219	m_ParamNames.Add(pname);
daa616fc VS	220	m_ParamValues.Add(wxEmptyString);
b076dc01	221	}
daa616fc VS	222	else if (state == ST_VALUE && quote == 0)
	223	{
	224	m_ParamNames.Add(pname);
367c84b9 VS	225	if (entParser)
	226	m_ParamValues.Add(entParser->Parse(pvalue));
	227	else
	228	m_ParamValues.Add(pvalue);
daa616fc VS	229	}
daa616fc VS	230	break;
5526e819	231	}
daa616fc	232	switch (state)
a914db0f	233	{
daa616fc VS	234	case ST_BEFORE_NAME:
	235	if (!IS_WHITE(c))
	236	{
	237	pname = c;
	238	state = ST_NAME;
	239	}
	240	break;
	241	case ST_NAME:
	242	if (IS_WHITE(c))
	243	state = ST_BEFORE_EQ;
	244	else if (c == wxT('='))
	245	state = ST_BEFORE_VALUE;
	246	else
	247	pname << c;
	248	break;
	249	case ST_BEFORE_EQ:
	250	if (c == wxT('='))
	251	state = ST_BEFORE_VALUE;
	252	else if (!IS_WHITE(c))
	253	{
	254	m_ParamNames.Add(pname);
	255	m_ParamValues.Add(wxEmptyString);
	256	pname = c;
	257	state = ST_NAME;
	258	}
	259	break;
	260	case ST_BEFORE_VALUE:
	261	if (!IS_WHITE(c))
	262	{
	263	if (c == wxT('"') \|\| c == wxT('\''))
	264	quote = c, pvalue = wxEmptyString;
	265	else
	266	quote = 0, pvalue = c;
	267	state = ST_VALUE;
	268	}
	269	break;
	270	case ST_VALUE:
	271	if ((quote != 0 && c == quote) \|\|
	272	(quote == 0 && IS_WHITE(c)))
	273	{
	274	m_ParamNames.Add(pname);
	275	if (quote == 0)
	276	{
	277	// VS: backward compatibility, no real reason,
	278	// but wxHTML code relies on this... :(
	279	pvalue.MakeUpper();
	280	}
367c84b9 VS	281	if (entParser)
	282	m_ParamValues.Add(entParser->Parse(pvalue));
	283	else
	284	m_ParamValues.Add(pvalue);
daa616fc VS	285	state = ST_BEFORE_NAME;
	286	}
	287	else
	288	pvalue << c;
	289	break;
72aa4a98	290	}
5526e819	291	}
daa616fc VS	292
	293	#undef IS_WHITE
	294	}
5526e819 VS	295	m_Begin = i;
5526e819 VS	296
4f9297b0	297	cache->QueryTag(pos, &m_End1, &m_End2);
5526e819 VS	298	if (m_End1 > end_pos) m_End1 = end_pos;
	299	if (m_End2 > end_pos) m_End2 = end_pos;
	300	}
	301
211dfedd VS	302	wxHtmlTag::~wxHtmlTag()
211dfedd VS	303	{
0d58bb65 VS	304	wxHtmlTag t1, t2;
	305	t1 = m_FirstChild;
	306	while (t1)
	307	{
	308	t2 = t1->GetNextSibling();
	309	delete t1;
	310	t1 = t2;
	311	}
211dfedd VS	312	}
211dfedd VS	313
5526e819 VS	314	bool wxHtmlTag::HasParam(const wxString& par) const
5526e819 VS	315	{
daa616fc	316	return (m_ParamNames.Index(par, FALSE) != wxNOT_FOUND);
5526e819 VS	317	}
5526e819 VS	318
5526e819 VS	319	wxString wxHtmlTag::GetParam(const wxString& par, bool with_commas) const
5526e819 VS	320	{
daa616fc VS	321	int index = m_ParamNames.Index(par, FALSE);
	322	if (index == wxNOT_FOUND)
	323	return wxEmptyString;
	324	if (with_commas)
4f9297b0	325	{
daa616fc VS	326	// VS: backward compatibility, seems to be never used by wxHTML...
	327	wxString s;
	328	s << wxT('"') << m_ParamValues[index] << wxT('"');
	329	return s;
5526e819	330	}
daa616fc VS	331	else
daa616fc VS	332	return m_ParamValues[index];
5526e819 VS	333	}
5526e819 VS	334
66a77a74	335	int wxHtmlTag::ScanParam(const wxString& par, wxChar format, void param) const
5526e819	336	{
5526e819	337	wxString parval = GetParam(par);
161f4f73	338	return wxSscanf(parval, format, param);
5526e819 VS	339	}
5526e819 VS	340
8bd72d90 VS	341	bool wxHtmlTag::GetParamAsColour(const wxString& par, wxColour *clr) const
	342	{
	343	wxString str = GetParam(par);
	344
	345	if (str.IsEmpty()) return FALSE;
	346	if (str.GetChar(0) == wxT('#'))
	347	{
	348	unsigned long tmp;
	349	if (ScanParam(par, wxT("#%lX"), &tmp) != 1)
	350	return FALSE;
	351	*clr = wxColour((unsigned char)((tmp & 0xFF0000) >> 16),
	352	(unsigned char)((tmp & 0x00FF00) >> 8),
	353	(unsigned char)(tmp & 0x0000FF));
	354	return TRUE;
	355	}
	356	else
	357	{
	358	// Handle colours defined in HTML 4.0:
	359	#define HTML_COLOUR(name,r,g,b) \
	360	if (str.IsSameAs(wxT(name), FALSE)) \
	361	{ *clr = wxColour(r,g,b); return TRUE; }
	362	HTML_COLOUR("black", 0x00,0x00,0x00)
	363	HTML_COLOUR("silver", 0xC0,0xC0,0xC0)
	364	HTML_COLOUR("gray", 0x80,0x80,0x80)
	365	HTML_COLOUR("white", 0xFF,0xFF,0xFF)
	366	HTML_COLOUR("maroon", 0x80,0x00,0x00)
	367	HTML_COLOUR("red", 0xFF,0x00,0x00)
	368	HTML_COLOUR("purple", 0x80,0x00,0x80)
	369	HTML_COLOUR("fuchsia", 0xFF,0x00,0xFF)
	370	HTML_COLOUR("green", 0x00,0x80,0x00)
	371	HTML_COLOUR("lime", 0x00,0xFF,0x00)
	372	HTML_COLOUR("olive", 0x80,0x80,0x00)
	373	HTML_COLOUR("yellow", 0xFF,0xFF,0x00)
	374	HTML_COLOUR("navy", 0x00,0x00,0x80)
	375	HTML_COLOUR("blue", 0x00,0x00,0xFF)
	376	HTML_COLOUR("teal", 0x00,0x80,0x80)
	377	HTML_COLOUR("aqua", 0x00,0xFF,0xFF)
	378	#undef HTML_COLOUR
8bd72d90	379	}
5716a1ab VZ	380
5716a1ab VZ	381	return FALSE;
8bd72d90 VS	382	}
	383
	384	bool wxHtmlTag::GetParamAsInt(const wxString& par, int *clr) const
	385	{
	386	if (!HasParam(par)) return FALSE;
	387	long i;
	388	bool succ = GetParam(par).ToLong(&i);
	389	*clr = (int)i;
	390	return succ;
	391	}
	392
daa616fc VS	393	wxString wxHtmlTag::GetAllParams() const
	394	{
	395	// VS: this function is for backward compatiblity only,
	396	// never used by wxHTML
	397	wxString s;
	398	size_t cnt = m_ParamNames.GetCount();
	399	for (size_t i = 0; i < cnt; i++)
	400	{
	401	s << m_ParamNames[i];
	402	s << wxT('=');
	403	if (m_ParamValues[i].Find(wxT('"')) != wxNOT_FOUND)
	404	s << wxT('\'') << m_ParamValues[i] << wxT('\'');
	405	else
	406	s << wxT('"') << m_ParamValues[i] << wxT('"');
	407	}
	408	return s;
	409	}
	410
211dfedd VS	411	wxHtmlTag *wxHtmlTag::GetFirstSibling() const
	412	{
	413	if (m_Parent)
	414	return m_Parent->m_FirstChild;
	415	else
	416	{
	417	wxHtmlTag cur = (wxHtmlTag)this;
	418	while (cur->m_Prev)
	419	cur = cur->m_Prev;
	420	return cur;
	421	}
	422	}
	423
	424	wxHtmlTag *wxHtmlTag::GetLastSibling() const
	425	{
	426	if (m_Parent)
	427	return m_Parent->m_LastChild;
	428	else
	429	{
	430	wxHtmlTag cur = (wxHtmlTag)this;
	431	while (cur->m_Next)
	432	cur = cur->m_Next;
	433	return cur;
	434	}
	435	}
	436
	437	wxHtmlTag *wxHtmlTag::GetNextTag() const
	438	{
	439	if (m_FirstChild) return m_FirstChild;
	440	if (m_Next) return m_Next;
	441	wxHtmlTag *cur = m_Parent;
	442	if (!cur) return NULL;
	443	while (cur->m_Parent && !cur->m_Next)
	444	cur = cur->m_Parent;
	445	return cur->m_Next;
	446	}
	447
4d223b67	448	#endif