pcsx2/3rdparty/wxwidgets3.0/include/wx/private/markupparser.h

177 lines
6.0 KiB
C
Raw Normal View History

///////////////////////////////////////////////////////////////////////////////
// Name: wx/private/markupparser.h
// Purpose: Classes for parsing simple markup.
// Author: Vadim Zeitlin
// Created: 2011-02-16
// Copyright: (c) 2011 Vadim Zeitlin <vadim@wxwidgets.org>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PRIVATE_MARKUPPARSER_H_
#define _WX_PRIVATE_MARKUPPARSER_H_
#include "wx/string.h"
// ----------------------------------------------------------------------------
// wxMarkupSpanAttributes: information about attributes for a markup span.
// ----------------------------------------------------------------------------
struct wxMarkupSpanAttributes
{
enum OptionalBool
{
Unspecified = -1,
No,
Yes
};
wxMarkupSpanAttributes()
{
m_sizeKind = Size_Unspecified;
m_isBold =
m_isItalic =
m_isUnderlined =
m_isStrikethrough = Unspecified;
}
// If a string is empty, it means that the corresponding attribute is not
// set.
wxString m_fgCol,
m_bgCol,
m_fontFace;
// There are many ways of specifying the size. First of all, the size may
// be relative in which case m_fontSize is either -1 or +1 meaning that
// it's one step smaller or larger than the current font. Second, it may be
// absolute in which case m_fontSize contains either the size in 1024th of
// a point (Pango convention) or its values are in [-3, 3] interval and map
// to [xx-small, xx-large] CSS-like font size specification. And finally it
// may be not specified at all, of course, in which case the value of
// m_fontSize doesn't matter and it shouldn't be used.
enum
{
Size_Unspecified,
Size_Relative,
Size_Symbolic,
Size_PointParts
} m_sizeKind;
int m_fontSize;
// If the value is Unspecified, the attribute wasn't given.
OptionalBool m_isBold,
m_isItalic,
m_isUnderlined,
m_isStrikethrough;
};
// ----------------------------------------------------------------------------
// wxMarkupParserOutput: gathers the results of parsing markup.
// ----------------------------------------------------------------------------
// A class deriving directly from this one needs to implement all the pure
// virtual functions below but as the handling of all simple tags (bold, italic
// &c) is often very similar, it is usually more convenient to inherit from
// wxMarkupParserFontOutput defined in wx/private/markupparserfont.h instead.
class wxMarkupParserOutput
{
public:
wxMarkupParserOutput() { }
virtual ~wxMarkupParserOutput() { }
// Virtual functions called by wxMarkupParser while parsing the markup.
// Called for a run of normal text.
virtual void OnText(const wxString& text) = 0;
// These functions correspond to the simple tags without parameters.
virtual void OnBoldStart() = 0;
virtual void OnBoldEnd() = 0;
virtual void OnItalicStart() = 0;
virtual void OnItalicEnd() = 0;
virtual void OnUnderlinedStart() = 0;
virtual void OnUnderlinedEnd() = 0;
virtual void OnStrikethroughStart() = 0;
virtual void OnStrikethroughEnd() = 0;
virtual void OnBigStart() = 0;
virtual void OnBigEnd() = 0;
virtual void OnSmallStart() = 0;
virtual void OnSmallEnd() = 0;
virtual void OnTeletypeStart() = 0;
virtual void OnTeletypeEnd() = 0;
// The generic span start and end functions.
virtual void OnSpanStart(const wxMarkupSpanAttributes& attrs) = 0;
virtual void OnSpanEnd(const wxMarkupSpanAttributes& attrs) = 0;
private:
wxDECLARE_NO_COPY_CLASS(wxMarkupParserOutput);
};
// ----------------------------------------------------------------------------
// wxMarkupParser: parses the given markup text into wxMarkupParserOutput.
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxMarkupParser
{
public:
// Initialize the parser with the object that will receive parsing results.
// This object lifetime must be greater than ours.
explicit wxMarkupParser(wxMarkupParserOutput& output)
: m_output(output)
{
}
// Parse the entire string and call wxMarkupParserOutput methods.
//
// Return true if the string was successfully parsed or false if it failed
// (presumably because of syntax errors in the markup).
bool Parse(const wxString& text);
// Quote a normal string, not meant to be interpreted as markup, so that it
// produces the same string when parsed as markup. This means, for example,
// replacing '<' in the input string with "&lt;" to prevent them from being
// interpreted as tag opening characters.
static wxString Quote(const wxString& text);
// Strip markup from a string, i.e. simply remove all tags and replace
// XML entities with their values (or with "&&" in case of "&amp;" to
// prevent it from being interpreted as mnemonic marker).
static wxString Strip(const wxString& text);
private:
// Simple struct combining the name of a tag and its attributes.
struct TagAndAttrs
{
TagAndAttrs(const wxString& name_) : name(name_) { }
wxString name;
wxMarkupSpanAttributes attrs;
};
// Call the wxMarkupParserOutput method corresponding to the given tag.
//
// Return false if the tag doesn't match any of the known ones.
bool OutputTag(const TagAndAttrs& tagAndAttrs, bool start);
// Parse the attributes and fill the provided TagAndAttrs object with the
// information about them. Does nothing if attrs string is empty.
//
// Returns empty string on success of a [fragment of an] error message if
// we failed to parse the attributes.
wxString ParseAttrs(wxString attrs, TagAndAttrs& tagAndAttrs);
wxMarkupParserOutput& m_output;
wxDECLARE_NO_COPY_CLASS(wxMarkupParser);
};
#endif // _WX_PRIVATE_MARKUPPARSER_H_