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

---

StringSelector.h

Go to the documentation of this file.

#ifndef OglGui_StringSelector_h
#define OglGui_StringSelector_h

#include <algorithm>
#include <string>

#ifndef OglGui_Window_h
#include "OglGui/Window.h"
#endif

#ifndef OglGui_StringListener_h
#include "OglGui/StringListener.h"
#endif

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

//#define BSIZE 20

namespace OglGui
{

class StringSelector : public Window, ScrollBarListener
{
public:

    StringSelector(Window* parent, int width, int height) :
        Window(parent, width, height)
    {
        Init(height/cLineHeight);
    }

    StringSelector(Window* parent, int x, int y, int width, int height) :
        Window(parent, x, y, width, height)
    {
        Init(height/cLineHeight);
    }

    void SetStringListener(StringListener* listener, void* listenerData = 0)
    {
        mStringListener = listener;
        mStrListenerData = listenerData;
    }
    void SetStringListener(StringListener* listener, int listenerData)
    {
        SetStringListener(listener, (void*) listenerData);
    }

    ScrollBar*  SBar()
    {
        return mScrollBar;
    }

    int GetFirstVis() const
    {
        return mFirstVis;
    }

    void SetFirstVis(int nr, bool signalScrollBar = false)
    {
        if (signalScrollBar)
        {
            mScrollBar->SetNewPos(nr);
            //return;
        }
        if (nr == mFirstVis)
            return;
        if (mNrVisible > mStrings.size())
            return;
        if ((nr < 0) || (nr > mStrings.size() - mNrVisible))
            return;
        mFirstVis = nr;
    }


    /*
    void MakeCurrentVisible()
    {
        if ((mCurrent < mFirstVis) || (mCurrent > mFirstVis + mNrVisible))
            SetFirstVis(lastLiner ? mCurrent-mNrVisible+1 : mCurrent);
        mScrollBar->MakeVisible(mCurrent);
    }
    */

    void MakeCurrentVisible()
    {
        bool lastLiner = mCurrent == mFirstVis + mNrVisible;
        int  visIdx = lastLiner ? mCurrent-mNrVisible+1 : mCurrent;
        if ((mCurrent < mFirstVis) || (mCurrent > mFirstVis + mNrVisible-1))
        {
            //SetFirstVis(visIdx);
            //mScrollBar->MakeVisible(visIdx);
            mScrollBar->SetNewPos(visIdx);
        }
    }


    void AddString(strconst str, bool intelliScroll = false)
    {
        int pos = mStrings.size();
        mStrings.push_back(str);
        if (intelliScroll & (mFirstVis == pos - mNrVisible))
        {
            mCurrent = pos;
            SetFirstVis(mFirstVis + 1);
        }
        if (mScrollBar)
            mScrollBar->SetRange(mStrings.size(), mNrVisible);
    }

    // todo: find better name... what is the standard name to
    // check the presence of an element in a collection?
    bool Contains(strconst str) const
    {
        if (std::find(mStrings.begin(), mStrings.end(), str) == mStrings.end())
            return false;
        return true;
    }

    std::string GetString(int strInd) const
    {
        return mStrings[strInd];
    }

    void SetCurrentString(int idx, bool makeVisible=false)
    {
        mCurrent = idx;
        if (makeVisible)
            MakeCurrentVisible();
    }

    std::string GetCurrentString() const
    {
        return mStrings[mCurrent];
    }

    int GetCurrentStringIdx() const
    {
        return mCurrent;
    }

    void CurrentStringUpDown(bool down, bool makeVisible=false)
    {
        int nIdx = mCurrent + (down ? 1 : -1);
        if (nIdx<0 || nIdx>mStrings.size()-1)
            return;
        mCurrent = nIdx;
        if (makeVisible)
            MakeCurrentVisible();
    }

    void RemoveStrings()
    {
        mStrings.clear();
        mCurrent = 0;
        mFirstVis = 0;
        if (mScrollBar)
            mScrollBar->SetRange(0, mNrVisible);
    }

    // specialization of base classes

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

        int lH = cLineHeight;
        int w = WndWidth();
        OGC oldOGC;

        OGCSave(&oldOGC);

        // draw the string content
        int lastVis = mFirstVis + mNrVisible;
        if (lastVis > mStrings.size())
            lastVis = mStrings.size();
        for (int i=mFirstVis ; i<mStrings.size() ; i++)
        {
            int n = i - mFirstVis;
            int y = mOglWnd->height - (n+1) * lH;
            if (mDoTextShadow)
                oglSys.ShadowPrintf(mOglWnd, lH+2, y+6, mShadowColor,
                                   mTextColor, "%s", mStrings[i].c_str());
            else
                oglSys.PosColPrintf(mOglWnd, lH+2, y+6, mTextColor,
                                   "%s", mStrings[i].c_str());
            if (i == mCurrent)
            {
                int oldBlendInfo[3];
                oglSys.StartBlend(oldBlendInfo);
                SetSolidFillColor(mHighLightColor);
                FillRectangle(lH, y, w - lH, lH);
                oglSys.EndBlend(oldBlendInfo);
                if (mHighlightBorderType > 0)
                    DrawBevRect(mHighlightBorderType, lH, y, w-lH, lH);
                else
                    DrawBevRect(-mHighlightBorderType, lH+3, y+3, lH-6, lH-6);
            }
        }
        OGCRestore(&oldOGC);
    }


    virtual void ReshapeFunc(INT w, INT h)
    {
        mNrVisible = h / cLineHeight;
        mScrollBar->SetRange(mStrings.size(), mNrVisible);
        Window::ReshapeFunc(w, h);
    }

    virtual int SetState(int nState)
    {
        mScrollBar->SetState(nState ? 1 : 0);
        return Window::SetState(nState);
    }

    void ActivateListener()
    {
        if (!mStringListener)
            return;
        mStringListener->StringSelectionEvent(this,mCurrent,mStrListenerData);
    }

    virtual void MouseFunc(int msg, int but, int state, int x, int y)
    {
        if (!GetState())
            return;

        Window::MouseFunc(msg, but, state, x, y);

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

        if ((msg==oglMouseDown) && (but==oglLeftButton))
        {
            int idx, clipY = (y < 0) ? 0 : y;
            if (clipY >= mOglWnd->height)
                clipY = mOglWnd->height;
            clipY = mOglWnd->height - clipY; // mirror for string order
            if ((idx = clipY / cLineHeight + mFirstVis) < mStrings.size())
            {
                mCurrent = idx;
                ActivateListener();
            }
        }
    }

    virtual void KeyboardFunc(int c, int state)
    {
        if (!GetState()) return;

        Window::KeyboardFunc(c, state);
        if (state)
            return;
        if (c == '\r')
            return ActivateListener();
        if (c==oglUP || c==oglDOWN)
            CurrentStringUpDown(c==oglDOWN,true);
        // else if (mScrollBar /*&& mScrollBar->ScrollKeyHandling()*/)
        else if (mScrollBar)
            mScrollBar->ScrollKeys(c, state);
    }

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

private:

    void Init(int nrVisible)
    {
        GuiGeneralName("StringSelector");
        mCurrent = 0;
        mNrVisible = nrVisible;
        mFirstVis = 0;
        mStringListener = 0;

        mDoTextShadow = false;
        mShadowColor = oglWHITE;
        mTextColor = oglBLACK;

        mHighLightColor = 0x4080ff80;
        mHighlightBorderType = BEV_ETCHED;

        mOglWnd->borderType = BEV_ETCHED;

        mScrollBar = new WindowScrollBar(this, false, false, 16);
        mScrollBar->SetScrollBarListener(this, 0);
        mScrollBar->SetRange(0, nrVisible);
        // RvB: Next two experimental AA
        mScrollBar->ScrollKeyHandling(false);
        mScrollBar->MapKeysTo(this);

        SetDisableOGLViewKeys(true);
        SetDisableOGLViewMouse(true);
    }

    static const int            cLineHeight = 20;
    int                         mCurrent;
    int                         mNrVisible;
    int                         mFirstVis;
    bool                        mDoTextShadow;
    ULONG                       mTextColor;
    ULONG                       mShadowColor;
    ULONG                       mHighLightColor;
    int                         mHighlightBorderType;

    StringListener*             mStringListener;
    void*                       mStrListenerData;
    std::vector<std::string>    mStrings;

    WindowScrollBar*            mScrollBar;
};

} // namespace OglGui
#endif

---