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 <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(const wxString& source, int pos, int end_pos,
                     wxHtmlTagsCache *cache,
                     wxHtmlEntitiesParser *entParser) : wxObject()
{
    int i;
    wxChar c;

    // fill-in name, params and begin pos:
    i = pos+1;
    if (source[i] == wxT('/'))
        { m_Ending = TRUE; i++; }
    else
        m_Ending = FALSE;

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

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

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