C4Markup Class Reference

#include <C4Markup.h>

Public Member Functions
	C4Markup (bool fDoClr)
	~C4Markup ()
bool	Read (const char **ppText, bool fSkip=false)
bool	SkipTags (const char **ppText)
void	Apply (C4BltTransform &rBltTrf, DWORD &dwClr)
bool	Clean ()
std::string	ClosingTags () const
std::string	OpeningTags () const

Static Public Member Functions
static bool	StripMarkup (char *szText)
static bool	StripMarkup (StdStrBuf *sText)

Detailed Description

Definition at line 60 of file C4Markup.h.

Constructor & Destructor Documentation

C4Markup()

C4Markup::C4Markup ( bool  fDoClr )

inline

Definition at line 71 of file C4Markup.h.

{ pTags=pLast=nullptr; this->fDoClr=fDoClr; };   // ctor

~C4Markup()

C4Markup::~C4Markup ( )

inline

Definition at line 72 of file C4Markup.h.

    { C4MarkupTag *pTag=pTags,*pNext; while (pTag) { pNext=pTag->pNext; delete pTag; pTag=pNext; } }

References C4MarkupTag::pNext.

Member Function Documentation

Apply()

void C4Markup::Apply ( C4BltTransform &  rBltTrf, DWORD &  dwClr  )

inline

Definition at line 77 of file C4Markup.h.

    { for (C4MarkupTag *pTag=pTags; pTag; pTag=pTag->pNext) pTag->Apply(rBltTrf, fDoClr, dwClr); }

References C4MarkupTag::Apply(), and C4MarkupTag::pNext.

Referenced by CStdFont::DrawText().

Here is the call graph for this function:

Here is the caller graph for this function:

Clean()

bool C4Markup::Clean ( )

inline

Definition at line 79 of file C4Markup.h.

{ return !pTags; } // empty?

Referenced by CStdFont::DrawText().

Here is the caller graph for this function:

ClosingTags()

std::string C4Markup::ClosingTags

(

)

const

Definition at line 132 of file C4Markup.cpp.

{
    std::string result;
    for (auto tag = pLast; tag; tag = tag->pPrev)
        result += tag->ClosingTag();
    return result;
}

Referenced by C4LogBuffer::AppendLines().

Here is the caller graph for this function:

OpeningTags()

std::string C4Markup::OpeningTags

(

)

const

Definition at line 140 of file C4Markup.cpp.

{
    std::string result;
    for (auto tag = pTags; tag; tag = tag->pNext)
        result += tag->OpeningTag();
    return result;
}

Referenced by C4LogBuffer::AppendLines().

Here is the caller graph for this function:

Read()

bool C4Markup::Read	(	const char **	ppText,
		bool	fSkip = false
	)

Definition at line 52 of file C4Markup.cpp.

{
    char Tag[50]; C4MarkupTag *pNewTag=nullptr; int iTagLen,iParLen;
    // get tag
    if (!SCopyEnclosed(*ppText, '<', '>', Tag, 49)) return false;
    iTagLen=SLen(Tag);
    // split tag to name and pars
    char *szPars=nullptr; int iSPos;
    if ((iSPos=SCharPos(' ', Tag))>-1)
    {
        Tag[iSPos]=0;
        szPars=Tag+iSPos+1;
    }
    // closing tag?
    if (Tag[0]=='/')
    {
        // no parameters
        if (szPars) return false;
        if (!fSkip)
        {
            // is this the tag to be closed?
            if (!pLast) return false;
            if (!SEqual(pLast->TagName(), Tag+1)) return false;
            // close it
            delete Pop();
        }
    }
    // italic
    else if (SEqual(Tag, "i"))
    {
        // no parameters
        if (szPars) return false;
        // create italic tag
        if (!fSkip) pNewTag=new C4MarkupTagItalic();
    }
    // colored
    else if (SEqual(Tag, "c"))
    {
        // no parameters?
        if (!szPars) return false;
        if ((iParLen=SLen(szPars))>8) return false;
        if (!fSkip)
        {
            // get color value by parameter
            DWORD dwClr=0;
            for (int i=0; i<iParLen; ++i)
            {
                BYTE b;
                if (szPars[i]>='0' && szPars[i]<='9') b=szPars[i]-'0';
                else if (szPars[i]>='a' && szPars[i]<='f') b=szPars[i]-'a'+10;
                else return false;
                dwClr|=(b<<((iParLen-i-1)*4));
            }
            // adjust alpha if not given
            if (iParLen<=6) dwClr|=0xff000000;
            // create color tag
            pNewTag=new C4MarkupTagColor(dwClr);
        }
    }
    // unknown tag
    else return false;
    // add created tag
    if (pNewTag) Push(pNewTag);
    // advance past tag
    *ppText+=iTagLen+2;
    // success
    return true;
}

References b, SCharPos(), SCopyEnclosed(), SEqual(), and SLen().

Referenced by C4LogBuffer::AppendLines(), and CStdFont::DrawText().

Here is the call graph for this function:

Here is the caller graph for this function:

SkipTags()

bool C4Markup::SkipTags

(

const char **

ppText

)

Definition at line 123 of file C4Markup.cpp.

{
    // read tags as long as found
    while (**ppText=='<') if (!Read(ppText, true)) break;
    // return whether end is reached
    return !**ppText;
}

Referenced by CStdFont::BreakMessage(), C4MenuItem::DoTextProgress(), CStdFont::GetTextExtent(), LogSilent(), and StripMarkup().

Here is the caller graph for this function:

StripMarkup() [1/2]

bool C4Markup::StripMarkup ( char *  szText )

static

Definition at line 148 of file C4Markup.cpp.

{
    // skip any tags and inline-images
    C4Markup mkup(false);
    const char *szRead = szText, *szPos2;
    do
    {
        mkup.SkipTags(&szRead);
        if (szRead[0] == '{' && szRead[1] == '{' && szRead[2] != '{') // skip at {{{, because {{{id}} should be parsed as { {{id}} }.
        {
            if ((szPos2 = SSearch(szRead+2, "}}")))
                // valid {{blub}}-tag
                szRead = szPos2;
            else
                // invalid {{-tag
                szRead += 2;
        }
        else if (szRead[0] == '}' && szRead[1] == '}')
            // invalid }}-tag
            szRead += 2;
    }
    while ((*szText++ = *szRead++));
    return szText != szRead;
}

References SkipTags(), and SSearch().

Referenced by C4PlayerInfoCore::Load(), and C4InVal::ValidateString().

Here is the call graph for this function:

Here is the caller graph for this function:

StripMarkup() [2/2]

bool C4Markup::StripMarkup ( StdStrBuf *  sText )

static

Definition at line 173 of file C4Markup.cpp.

{
    // strip any markup codes from given text buffer
    char *buf = sText->GrabPointer();
    if (!buf) return false;
    bool fSuccess = StripMarkup(buf);
    sText->Take(buf);
    return fSuccess;
}

References StdStrBuf::GrabPointer(), and StdStrBuf::Take().

Here is the call graph for this function:

---

The documentation for this class was generated from the following files:

• C4Markup.h
• C4Markup.cpp