|| || || || || || || ||

---

TextArea.h

Go to the documentation of this file.

/*
 * Author: Michiel van Liempt
 */

#ifndef OglGui_TextArea_h
#define OglGui_TextArea_h

#ifndef OglGui_WindowScrollBar_h
#include "OglGui/WindowScrollBar.h"
#endif

namespace OglGui
{

// XXX RvB drawBorder zou verwijderd moeten worden.
// Kan vervangen worden door indicator of lines of pixels gebruikt moet worden
class TextArea : public Window, ScrollBarListener
{
public:

    TextArea(Window* parent, int width, int height, strconst text,
             bool drawBorder = true) :
        Window(parent, width, height)
    {
        Init(height/cLineHeight, text, drawBorder);
    }

    TextArea(Window* parent, int x, int y, int width, int nrLines,
             strconst text, bool drawBorder = true) :
        Window(parent, x, y, width, nrLines * cLineHeight + 4)
    {
        Init(nrLines, text, drawBorder);
    }
    
    void SetText(strconst text)
    {
        mStrings.clear();
        mFirstVisible = 0;
        mFormatted = false;
        mText = text;
    }

    void SetFirstVis(int nr)
    {
        int sz = mStrings.size();
        if (nr > sz - mNrLines)
            nr = sz - mNrLines;
        if (nr < 0) 
            nr = 0;
        if (nr == mFirstVisible)
            return;
        mFirstVisible = nr;
    }

    void SetTextShadowing(bool doShadow)
    {
        mDoTextShadow = doShadow;
    }

    bool GetTextShadowing() const
    {
        return mDoTextShadow;
    }

    void SetTextColor(ULONG fg)
    {
        mTextColor = fg;
    }

    ULONG GetTextColor() const
    {
        return mTextColor;
    }

    bool GetBreakOnLines() const
    {
        return mBreakOnLines;
    }

    void SetBreakOnLines(bool doBreak)
    {
        mBreakOnLines = doBreak;
    }

    void SetTextShadowColor(ULONG shadow)
    {
        mShadowColor = shadow;
    }

    ULONG GetTextShadowColor() const
    {
        return mShadowColor;
    }

    virtual void DisplayFunc()
    {
        Window::DisplayFunc();

        OGC oldOGC;
        OGCSave(&oldOGC);

                if (this == NULL) 
                {
                        //std::cout << "WARNING: trying to TextArea::DisplayFunc() on a NULL TextArea." << std::endl;
                        return;
                }

        // draw the string content
        CheckTextFormat();
        int startPos = (mScrollBar) ? cLineHeight : 0;
        for (int i=mFirstVisible ; i<mStrings.size() ; i++)
        {
            int n = i - mFirstVisible;
            int y = mOglWnd->height - (n+1) * cLineHeight + cLineHeight/2 - 7;
            if (mDoTextShadow)
                oglSys.ShadowPrintf(mOglWnd, startPos + 2, y, mShadowColor,
                                    mTextColor, "%s", mStrings[i].c_str());
            else
                oglSys.PosColPrintf(mOglWnd, startPos + 2, y, mTextColor,
                                    "%s", mStrings[i].c_str());
       }

        OGCRestore(&oldOGC);
    }

    virtual int SetState(int nState)
    {
        if (mScrollBar != 0)
            mScrollBar->SetState(nState);

        return Window::SetState(nState);
    }

    virtual void MouseFunc(INT msg, INT but, INT state, INT x, INT y)
    {
        Window::MouseFunc(msg, but, state, x, y);

        if (mScrollBar && msg == oglMouseWheelUp)
            mScrollBar->ChangePos(-1);
        if (mScrollBar && msg == oglMouseWheelDown)
            mScrollBar->ChangePos(1);
    }

    virtual void KeyboardFunc(INT c, int state)
    {
        Window::KeyboardFunc(c, state);
        if (mScrollBar)
            mScrollBar->ScrollKeys(c, state);
    }

    virtual void ReshapeFunc(INT width, INT height)
    {
        Window::ReshapeFunc(width, height);
        if (height / cLineHeight != mNrLines)
        {
            if ((mNrLines = height / cLineHeight) > 1)
            {
                if (!mScrollBar)
                    CreateScrollBar();
            }
        }
        SetText(mText);
    }

    void OnScroll(ScrollBar *src, int position, void* data)
    {
        SetFirstVis(position);
    }



private:

    void Init(int nrLines, strconst text, bool drawBorder)
    {
        mNrLines = nrLines;
        if (mDrawBorder = drawBorder)
            mOglWnd->borderType = BEV_ETCHED;
        mFirstVisible = 0;
        mDoTextShadow = false;
        mShadowColor = oglWHITE;
        mTextColor = oglBLACK;
        mFormatted = false;
        SetText(text);
        mScrollBar = 0;
        if (mNrLines > 1)
            CreateScrollBar();
    }

    void CreateScrollBar()
    {
        mScrollBar = new WindowScrollBar(this, false, false);
        mScrollBar->SetScrollBarListener(this, 0);
        mScrollBar->SetRange(0, mNrLines);
    }

    void CheckTextFormat()
    {
        if (mFormatted)
            return;
        OGLWND* top = oglSys.GetTopOGLWND(mOglWnd);
        if (! top->hFont)
            return;

        int maxWidth = mOglWnd->width - 2 - (mScrollBar ? cLineHeight : 0);
        std::string::size_type start = 0;
        // crude way of displaying newlines, WARNING: line lenghts are not checked:
        if (mBreakOnLines)
            while (start < mText.size())
            {
                std::string::size_type end = mText.find('\n', start);
                if ((end == std::string::npos) || (end <= start))
                {
                    mStrings.push_back(mText.substr(start));
                    start = mText.size();
                }
                else
                {
                    mStrings.push_back(mText.substr(start, end - start + 1));
                    start = end + 1;
                    while (mText[start] == ' ')
                        start++;
                }
            }
        else
            while (start < mText.size())
            {
                std::string::size_type end = mText.size();
                while ((end != std::string::npos) && (end > start) &&
                    (StringWidth(top, start, end) >= maxWidth))
                {   // XXX RvB should also break at newlines
                    std::string::size_type res = mText.rfind(' ', end);
                    end = (res != std::string::npos) ? res - 1 : res;
                }
                if ((end == std::string::npos) || (end <= start))
                {
                    mStrings.push_back(mText.substr(start));
                    start = mText.size();
                }
                else
                {
                    mStrings.push_back(mText.substr(start, end - start + 1));
                    start = end + 1;
                                        while (start < mText.size() && mText[start] == ' ')
                        start++;
                }
            }
        mFormatted = true;
        if (mScrollBar)
            mScrollBar->SetRange(mStrings.size(), mNrLines);
    }

    int StringWidth(OGLWND* top, std::string::size_type start,
                    std::string::size_type end)
    {
        INT w;
        INT h;
        std::string s = mText.substr(start, end - start + 1);
        oglSys.AbstFontTextSize(top, top->hFont, (char *) s.c_str(), &w, &h);
        return w;
    }

    int             mNrLines;
    bool            mDrawBorder;
    int             mFirstVisible;
    bool            mDoTextShadow;
    ULONG           mTextColor;
    ULONG           mShadowColor;

    std::string     mText;
    bool            mFormatted;
    bool            mBreakOnLines;
    std::vector<std::string> mStrings;

    WindowScrollBar* mScrollBar;

    static const int cLineHeight = 18;

};

#undef cLineHeight
} // namespace OglGui

#endif

---