C4LogBuf.cpp

Go to the documentation of this file.

/*
 * OpenClonk, http://www.openclonk.org
 *
 * Copyright (c) 2001-2009, RedWolf Design GmbH, http://www.clonk.de/
 * Copyright (c) 2013-2016, The OpenClonk Team and contributors
 *
 * Distributed under the terms of the ISC license; see accompanying file
 * "COPYING" for details.
 *
 * "Clonk" is a registered trademark of Matthes Bender, used with permission.
 * See accompanying file "TRADEMARK" for details.
 *
 * To redistribute this file separately, substitute the full license texts
 * for the above references.
 */
// a buffer holding a log history
 
#include "C4Include.h"
#include "lib/C4LogBuf.h"
 
#include "graphics/C4FontLoader.h"
 
C4LogBuffer::C4LogBuffer(int iSize, int iMaxLines, int iLBWidth, const char *szIndentChars, bool fDynamicGrow, bool fMarkup)
        : iBufSize(iSize), iFirstLinePos(0), iAfterLastLinePos(0), iLineDataPos(0),
        iNextLineDataPos(0), iMaxLineCount(iMaxLines), iLineCount(0), iLineBreakWidth(iLBWidth), fDynamicGrow(fDynamicGrow), fMarkup(fMarkup)
{
    // copy indent
    if (szIndentChars && *szIndentChars)
    {
        szIndent = new char[strlen(szIndentChars)+1];
        strcpy(szIndent, szIndentChars);
    }
    else szIndent = nullptr;
    // create buffers, if buffer size is given. Otherwise, create/grow them dynamically
    if (iBufSize) szBuf = new char[iBufSize]; else szBuf=nullptr;
    if (iMaxLineCount) pLineDataBuf = new LineData[iMaxLineCount]; else pLineDataBuf=nullptr;
    assert(fDynamicGrow || (iBufSize && iMaxLineCount));
}
 
C4LogBuffer::~C4LogBuffer()
{
    // free buffers
    delete [] pLineDataBuf;
    delete [] szBuf;
    // free indent
    if (szIndent) delete [] szIndent;
}
 
void C4LogBuffer::GrowLineCountBuffer(size_t iGrowBy)
{
    assert(fDynamicGrow);
    if (!iGrowBy) return;
    LineData *pNewBuf = new LineData[iMaxLineCount += iGrowBy];
    if (iLineCount) memcpy(pNewBuf, pLineDataBuf, sizeof(LineData) * iLineCount);
    delete [] pLineDataBuf;
    pLineDataBuf = pNewBuf;
}
 
void C4LogBuffer::GrowTextBuffer(size_t iGrowBy)
{
    assert(fDynamicGrow);
    if (!iGrowBy) return;
    char *pNewBuf = new char[iBufSize += iGrowBy];
    if (iAfterLastLinePos) memcpy(pNewBuf, szBuf, sizeof(char) * iAfterLastLinePos);
    delete [] szBuf;
    szBuf = pNewBuf;
}
 
void C4LogBuffer::DiscardFirstLine()
{
    // any line to discard? - this is guaranteed (private call)
    assert(iLineCount && szBuf && !fDynamicGrow);
    // dec line count
    --iLineCount;
    // advance first line pos until delimeter char is reached
    while (szBuf[iFirstLinePos]) ++iFirstLinePos;
    // skip delimeter
    ++iFirstLinePos;
    // check if end of used buffer is reached (by size or double delimeter)
    if (iFirstLinePos == iBufSize || !szBuf[iFirstLinePos] || !iLineCount)
    {
        // end of buffer reached: wrap to front
        iFirstLinePos = 0;
    }
    // discard line data
    ++iLineDataPos;
    if (!iLineCount) iLineDataPos = iNextLineDataPos = 0;
}
 
void C4LogBuffer::AppendSingleLine(const char *szLine, int iLineLength, const char *szIndent, CStdFont *pFont, DWORD dwClr, bool fNewPar)
{
    // security: do not append empty line
    if (!szLine || !iLineLength || !*szLine) return;
    // discard first line or grow buffer if data buffer is full
    if (iLineCount == iMaxLineCount)
    {
        if (fDynamicGrow)
            GrowLineCountBuffer(4 + iMaxLineCount/2);
        else
            DiscardFirstLine();
    }
    // include trailing zero-character
    ++iLineLength;
    // include indent
    if (szIndent) iLineLength += strlen(szIndent);
    // but do not add a message that is longer than the buffer (shouldn't happen anyway)
    if (iLineLength > iBufSize && !fDynamicGrow)
    {
        // cut from beginning then
        szLine += iLineLength - iBufSize;
        iLineLength = iBufSize;
    }
    // check if the rest of the buffer is sufficient
    if (iAfterLastLinePos + iLineLength > iBufSize)
    {
        if (fDynamicGrow)
        {
            // insufficient buffer in grow mode: grow text buffer
            GrowTextBuffer(std::max(iLineLength, iBufSize/2));
        }
        else
        {
            // insufficient buffer in non-grow mode: wrap to beginning
            // discard any messages in rest of buffer
            // if there are no messages, iFirstLinePos is always zero
            // and iAfterLastLinePos cannot be zero here
            while (iFirstLinePos >= iAfterLastLinePos) DiscardFirstLine();
            // add delimeter to mark end of used buffer
            // if the buffer is exactly full by the last line, no delimeter is needed
            if (iAfterLastLinePos < iBufSize) szBuf[iAfterLastLinePos] = 0;
            // wrap insertion pos to beginning
            iAfterLastLinePos = 0;
        }
    }
    // discard any messages within insertion range of new message
    if (!fDynamicGrow)
        while (iLineCount && Inside(iFirstLinePos, iAfterLastLinePos, iAfterLastLinePos+iLineLength-1))
            DiscardFirstLine();
    // copy indent
    int iIndentLen = 0;
    if (szIndent)
    {
        iIndentLen = strlen(szIndent);
        memcpy(szBuf + iAfterLastLinePos, szIndent, iIndentLen);
    }
    // copy message
    if (iLineLength - iIndentLen > 1)
        memcpy(szBuf + iAfterLastLinePos + iIndentLen, szLine, iLineLength-iIndentLen-1);
    // add delimeter
    iAfterLastLinePos += iLineLength;
    szBuf[iAfterLastLinePos - 1] = 0;
    // no need to add any double delimeters, because this is currently the end of the message list
    // also no need to check for end of buffer here, because that will be done when the next message is inserted
    // add line data
    LineData &rData = pLineDataBuf[iNextLineDataPos];
    rData.pFont = pFont;
    rData.dwClr = dwClr;
    rData.fNewParagraph = fNewPar;
    // new message successfully added; count it
    ++iLineCount;
    if (++iNextLineDataPos == iMaxLineCount)
    {
        if (fDynamicGrow)
            GrowLineCountBuffer(4 + iMaxLineCount/2);
        else
            iNextLineDataPos = 0;
    }
}
 
void C4LogBuffer::AppendLines(const char *szLine, CStdFont *pFont, DWORD dwClr, CStdFont *pFirstLineFont)
{
    char LineBreakChars [] = { 0x0D, 0x0A, '|' };
    int32_t iLineBreakCharCount = 2 + fMarkup;
    // safety
    if (!szLine) return;
    // split '|'/CR/LF-separations first, if there are any
    bool fAnyLineBreakChar = false;
    for (int i = 0; i < iLineBreakCharCount; ++i)
        if (strchr(szLine, LineBreakChars[i]))
        {
            fAnyLineBreakChar = true;
            break;
        }
    if (fAnyLineBreakChar)
    {
        char *szBuf = new char[strlen(szLine)+1];
        char *szBufPos, *szPos2 = szBuf, *szBufFind;
        strcpy(szBuf, szLine);
        while ((szBufPos = szPos2))
        {
            // find first occurance of any line break char
            szPos2 = nullptr;
            for (int i = 0; i < iLineBreakCharCount; ++i)
                if ((szBufFind = strchr(szBufPos, LineBreakChars[i])))
                    if (!szPos2 || szBufFind < szPos2)
                        szPos2 = szBufFind;
            // split string at linebreak char
            if (szPos2) *szPos2++ = '\0';
            // output current line if not empty
            if (!*szBufPos) continue;
            // first line in caption font
            if (pFirstLineFont)
            {
                AppendLines(szBufPos, pFirstLineFont, dwClr);
                pFirstLineFont = nullptr;
            }
            else
                AppendLines(szBufPos, pFont, dwClr);
        }
        delete [] szBuf;
        return;
    }
    // no line breaks desired: Output all in one line
    if (!iLineBreakWidth || !pFont)
    {
        AppendSingleLine(szLine, strlen(szLine), nullptr, pFont, dwClr, true);
    }
    else
    {
        C4Markup markup(false);
        const char *markupPos = szLine;
        std::string rline;
        // output broken lines until there are any
        int iLineIndex = 0;
        while (*szLine)
        {
            // get line width of this line
            int iBreakWdt = iLineBreakWidth;
            if (iLineIndex && szIndent)
            {
                int32_t iIndentWdt, Q;
                pFont->GetTextExtent(szIndent, iIndentWdt, Q, true);
                iBreakWdt -= iIndentWdt;
            }
            // get number of characters printable into this line
            const char *szNextLine;
            int iNumChars = pFont->GetMessageBreak(szLine, &szNextLine, iBreakWdt);
            // make sure not to break markup
            if (fMarkup)
            {
                std::string opening = markup.OpeningTags();
                while (markupPos < szNextLine)
                {
                    if (*markupPos == '<')
                    {
                        if (markup.Read(&markupPos))
                        {
                            if (markupPos > szNextLine)
                            {
                                // The message break is within a tag.
                                iNumChars += markupPos - szNextLine + 1;
                                szNextLine = markupPos;
                            }
                            // Read already moved us over a valid tag.
                            continue;
                        }
                    }
                    markupPos++;
                }
                std::string closing = markup.ClosingTags();
                if (!opening.empty() || !closing.empty())
                {
                    rline = std::move(opening);
                    rline.append(szLine, iNumChars);
                    rline.append(closing);
                    szLine = rline.c_str();
                    iNumChars = rline.size();
                }
            }
            // add them
            AppendSingleLine(szLine, iNumChars, iLineIndex ? szIndent : nullptr, pFont, dwClr, !iLineIndex);
            // next line
            szLine = szNextLine;
            ++iLineIndex;
            rline.clear();
        }
    }
}
 
const char *C4LogBuffer::GetLine(int iLineIndex, CStdFont **ppFont, DWORD *pdwClr, bool *pfNewPar) const
{
    // evaluate negative indices
    if (iLineIndex < 0)
    {
        iLineIndex += iLineCount;
        if (iLineIndex < 0) return nullptr;
    }
    // range check
    if (iLineIndex >= iLineCount) return nullptr;
    // assign data
    LineData &rData = pLineDataBuf[(iLineDataPos + iLineIndex) % iMaxLineCount];
    if (ppFont) *ppFont = rData.pFont;
    if (pdwClr) *pdwClr = rData.dwClr;
    if (pfNewPar) *pfNewPar = rData.fNewParagraph;
    // advance in lines until desired line is found
    char *szResult = szBuf + iFirstLinePos;
    while (iLineIndex--)
    {
        // skip this line
        while (*szResult++) ;
        // double delimeter or end of buffer: reset searching to front of buffer
        if (szResult == (szBuf+iBufSize) || !*szResult) szResult = szBuf;
    }
    // return found buffer pos
    return szResult;
}
 
void C4LogBuffer::Clear()
{
    // clear buffer usage
    iFirstLinePos = iAfterLastLinePos = iLineCount = iNextLineDataPos = iLineDataPos = 0;
}
 
void C4LogBuffer::SetLBWidth(int iToWidth)
{
    iLineBreakWidth = iToWidth;
}