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

---

ScrollBar.h

Go to the documentation of this file.

#ifndef OglGui_ScrollBar_h
#define OglGui_ScrollBar_h
/*
 * Author: Michiel van Liempt
 * Changed by Richard van Balen
 */

//#define ORG_BTN
// RvB: Reverted from AllFeedstateback trick to be more in line with XP
//#define ORG_STATEFEEDBACK

#ifndef OglGui_DirectionButton_h
#include "OglGui/DirectionButton.h"
#endif

#ifndef OglGui_ScrollBarListener_h
#include "OglGui/ScrollBarListener.h"
#endif

namespace OglGui
{

class ScrollBar : public Window, RepeatTimer, ButtonListener
{
public:
    ScrollBar(Window* parent, int w, int h, bool horizontal) :
        Window(parent, w, h, true)
    {
        Init(horizontal, horizontal ? h : w);
    }

    ScrollBar(Window* parent, int x, int y, int w, int h, bool horizontal) :
        Window(parent, x, y, w, h, true)
    {
        Init(horizontal, horizontal ? h : w);
    }

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

    // RvB: Ask Michiel if he objects being able to
    // retrieve a pointer to the components. If so
    // the user could tune the components fully to their taste
    // For now I only allow the borderType and roundness to be set
    // ***** Decided to grant acces for maximum adjustability

    DirectionButton* ButIncr()
    {
        return mButIncr;
    }

    DirectionButton* ButDecr()
    {
        return mButDecr;
    }

    Button* ButThumb()
    {
        return mButThumb;
    }


    // Shorthand for Component
    enum Comp {
        Incr, Thumb, Decr, All
    };

    void SetCompBorderType(Comp comp, int type)
    {
        Window   *wnd = 0;
        switch(comp)
        {
        case All:
            mButIncr->SetBorderType(type);
            mButDecr->SetBorderType(type);
            mButThumb->SetBorderType(type);
        break;
        case Incr: wnd = mButIncr; break;
        case Thumb: wnd = mButThumb; break;
        case Decr: wnd = mButDecr; break;
        }
        if (wnd && comp != All)
            wnd->SetBorderType(type);
    }

    void SetCompRoundness(Comp comp, float r0, float r1, float r2, float r3)
    {
        Window   *wnd = 0;
        switch(comp)
        {
        case All:
            mButIncr->SetRoundness(r0, r1, r2, r3);
            mButDecr->SetRoundness(r0, r1, r2, r3);
            mButThumb->SetRoundness(r0, r1, r2, r3);
        break;
        case Incr: wnd = mButIncr; break;
        case Thumb: wnd = mButThumb; break;
        case Decr: wnd = mButDecr; break;
        }
        if (wnd && comp != All)
            wnd->SetRoundness(r0, r1, r2, r3);
    }

    void SetScrollBarListener(ScrollBarListener* listener, void* data=0)
    {
        mListener = listener;
        mListenerData = data;
    }
    void SetScrollBarListener(ScrollBarListener* listener, int data)
    {
        SetScrollBarListener(listener, (void*) data);
    }

    void ScrollKeyHandling(bool mode)       { mScrollKeyHandling = mode; }
    bool ScrollKeyHandling()                { return mScrollKeyHandling; }

    // Deprecated
    void SetLineIncrement(int incr)
    {
        mScrollLine = incr;
    }

    void LineIncrement(int incr)
    {
        mScrollLine = incr;
    }
    int LineIncrement()
    {
        return mScrollLine;
    }

    void SetRange(int totalRange, int pageSize) // normally measured in lines
    {
        bool    tooSmall =  (mHorizontal && mOglWnd->width < 40) ||
                            (!mHorizontal && mOglWnd->height < 40);

        mScrollRange = totalRange;
        mScrollPage = pageSize;
        // reposition thumb
        // RvB: Added test on mScrollRange != 0, to prevent zero division
        if(totalRange > pageSize && pageSize > 0 && !tooSmall &&
           mScrollRange!=0)
        {
            mButThumb->SetVisible(true);
            mButIncr->SetVisible(true);
            mButDecr->SetVisible(true);
            if (mHorizontal)
                mPixelPage = ((mOglWnd->width - (2*cSbW)) * mScrollPage) /
                             mScrollRange;
            else
                mPixelPage = ((mOglWnd->height - (2*cSbW)) * mScrollPage) /
                             mScrollRange;
            // minimal thumb size
            if (mPixelPage < 12)
                mPixelPage = 12;

            // if change of range pushes thumb over maximum then reposition
            if (mPixelPage + mPixelPos > mPixelRange)
            {
                mPixelPos = mPixelRange - mPixelPage;
                // RvB: When resizing, jumpy behavior of content being scrolled
                // occurred.After countless hours of trying different strategies
                // removing next line solved the problem.
                // Although I do allow an inconsistency here (BUT RESULT: MUCH
                // BETTER BEHAVIOUR)
                // This trick should probably be made settable

                // OnScrollThumb(mPixelPos);
            }

            if (mHorizontal)
                oglSys.SetDimensions(mButThumb->GetOGLWND(), mPixelPos + cSbW,
                                     0, mPixelPage, cSbW);
            else
            {
                int y = mOglWnd->height - cSbW - mPixelPos - mPixelPage;
                oglSys.SetDimensions(mButThumb->GetOGLWND(), 0, y, cSbW,
                                     mPixelPage);
            }
        }
        else
        {   // Too small to show buttons
            mButThumb->SetVisible(false);
            mButIncr->SetVisible(false);
            mButDecr->SetVisible(false);
        }
    }

    void GetRange(int& totalRange, int& pageSize)
    {
        totalRange = mScrollRange;
        pageSize = mScrollPage;
    }

    void
    ChangePos(int change)
    {
        SetNewPos(mScrollPos + change);
    }


    void
    SetNewPos(int pos) // still measured in lines
    {
        if (pos>=mScrollRange - mScrollPage)
            pos = mScrollRange - mScrollPage;
        if (pos<0)
            pos = 0;
        if (pos != mScrollPos)
        {
            mScrollPos = pos;
// RvB: Division by zero
//            mPixelPos = (mPixelRange - mPixelPage) * mScrollPos /
//                        (mScrollRange - mScrollPage);
// RvB Replaced by next lines 
            int divider = mScrollRange - mScrollPage;
            if (!divider)
                divider = 1;
            //mPixelPos = (mPixelRange - mPixelPage) * mScrollPos / divider; // Overflow
            mPixelPos = ((mPixelRange - mPixelPage) / (double) divider) * mScrollPos;
            if(mListener)
                mListener->OnScroll(this, mScrollPos, mListenerData);
            oglSys.UpdateSceneFlag(GetOGLWND(), 1);
        }
    }

    void
    MakeVisible(int pos)
    {
        if ((pos >= mScrollPos) && (pos < mScrollPos+mScrollPage))
            return;
        SetNewPos(pos);
    }


    void SetValue(int val)
    {
        SetNewPos(val);
    }

    int GetValue()
    {
        return mScrollPos;
    }

    void
    SetPosition(int x, int y, int w, int h)
    {
        // RvB: Michiel vragen
        // SetAllowReposition(false);
        mOglWnd->x = x;
        mOglWnd->y = y;
        mOglWnd->height = h;
        mOglWnd->width = w;
        if (mHorizontal)
            mPixelRange = mOglWnd->width - (2*cSbW);
        else
            mPixelRange = mOglWnd->height - (2*cSbW);
        SetRange(mScrollRange, mScrollPage);
    }

    // Positions the buttons within the scrollbar
    void
    RepositionViewports()
    {
        OGLWND  *oglWnd = GetOGLWND();

        if (mHorizontal)
        {   // normally adjust to wideness of scrollbar
            int h = oglWnd->height; 
            if (mFixedWide) // If fixedWide, refuse a different wideness
                h = oglWnd->height = mWide;
            oglSys.SetDimensions(mButDecr->GetOGLWND(), 0, 0, cSbW, h);
            oglSys.SetDimensions(mButThumb->GetOGLWND(), mPixelPos + cSbW,
                                 0, mPixelPage, h);
            oglSys.SetDimensions(mButIncr->GetOGLWND(), mOglWnd->width - cSbW,
                                 0, cSbW, h);
        }
        else
        {   // normally adjust to wideness of scrollbar
            int w = oglWnd->width;
            if (mFixedWide)// If fixedWide, refuse a different wideness
                w = oglWnd->width = mWide;
           // please note that y is reversed
            oglSys.SetDimensions(mButDecr->GetOGLWND(), 0,
                                 mOglWnd->height - cSbW, w, cSbW);
            oglSys.SetDimensions(mButThumb->GetOGLWND(), 0,
                                 mOglWnd->height - cSbW - mPixelPos - mPixelPage,
                                 w, mPixelPage);
            oglSys.SetDimensions(mButIncr->GetOGLWND(), 0, 0, w, cSbW);
        }
    }


    virtual void
    MouseFunc(INT msg, INT but, INT state, INT x, INT y)
    {
        if (!GetState() || (state & (oglShift|oglControl)))
            return;

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

        // a click here means pageup or pagedown
        if ((msg==oglMouseDown || msg==oglMouseDblClick) && but==oglLeftButton) 
        {
            if (mHorizontal)
                mMouseDownPos = x-cSbW;
            else
                mMouseDownPos = y-cSbW;
            PropagateScrolling();
            mPagePressed = true;
            StartRepeatTime();
            oglSys.SetAlwaysDraw(mOglWnd, true);
        }

        if (msg == oglMouseWheelUp)
            ChangePos(-mScrollLine * ((state&oglShift) ? 5 : 1));
        if (msg == oglMouseWheelDown)
            ChangePos(mScrollLine * ((state&oglShift) ? 5 : 1));

        if (msg == oglMouseMove)
        {
            if (mHorizontal)
                mMouseDownPos = x-cSbW;
            else
                mMouseDownPos = y-cSbW;
        }

        if (msg == oglMouseUp && but == oglLeftButton)
        {
            mPagePressed = false;
            oglSys.SetAlwaysDraw(mOglWnd, false);
        }

    }

    virtual void
    InitDisplayFunc()
    {
#ifdef ORG_STATEFEEDBACK
        if (GetState()==2 || mButThumb->GetState()==2 ||
            mButIncr->GetState()==2 || mButDecr->GetState()==2)
        {
            mOldBorderBg = GetBorderBackground();
            SetBorderBackground(mStateFeedbackColor);
        }
#endif
        // RvB: Added to make sure sizes are correct
        // Bespreken met Michiel, hoe het misschien anders kan
        if (mHorizontal)
            mPixelRange = mOglWnd->width - (2*cSbW);
        else
            mPixelRange = mOglWnd->height - (2*cSbW);
        SetRange(mScrollRange, mScrollPage);

        if (mScrollRange == mScrollPage){
//            oglSys.ErrorBox("Error", "Division by zero mScrollRange==mScrollPage");
            mScrollPage--;// Provisorisch
        }
        // RvB: Introduced double cast to prevent overflow
        mPixelPos = (mPixelRange - mPixelPage) * (double) mScrollPos /
                    (mScrollRange - mScrollPage);

        RepositionViewports();

        Window::InitDisplayFunc();
    }

    virtual void
    DisplayFunc()
    {
        if (mPagePressed && RepeatTime())
            PropagateScrolling();

        Window::DisplayFunc();
    }
   
    void
    PropagateScrolling()
    {
        if (mHorizontal)
        {
            if (mMouseDownPos - mPixelPos < 0)
                SetNewPos(mScrollPos - mScrollPage);
            else
                if(mMouseDownPos - mPixelPos > mPixelPage)
                    SetNewPos(mScrollPos + mScrollPage);
        }
        else
        {
            if (mMouseDownPos - mPixelRange + mPixelPos < -mPixelPage)
                SetNewPos(mScrollPos + mScrollPage);
            else
                if (mMouseDownPos - mPixelRange + mPixelPos > 0)
                    SetNewPos(mScrollPos - mScrollPage);
        }
    }

    void
    ButtonSelectionEvent(Button *src, void* vdata)
    {
        int data = (long long) vdata;
        switch (data)
        {
        case 1: // decrement
            SetNewPos(mScrollPos-mScrollLine);
            break;
        case 3: // increment
            SetNewPos(mScrollPos+mScrollLine);
            break;
        }
    }

    virtual void
    KeyboardFunc(INT c, int state)
    {
        Window::KeyboardFunc(c, state);
        if (!mMapKeysTarget && mScrollKeyHandling)
            ScrollKeys(c, state);
    }

    void
    ScrollKeys(INT c, int state)
    {
        if (state & (oglControl|oglAlt))
            return;

        switch(c)
        {
        case oglLEFT:
        case oglUP:
            ChangePos(-mScrollLine * ((state&oglShift) ? 5 : 1));
            break;
        case oglDOWN:
        case oglRIGHT:
            ChangePos(mScrollLine * ((state&oglShift) ? 5 : 1));
            break;
        case oglPAGEUP:
            ChangePos(-mScrollPage);
            break;
        case oglPAGEDOWN:
            ChangePos(mScrollPage);
            break;
        case oglHOME:
            SetNewPos(0);
            break;
        case oglEND:
            SetNewPos(mScrollRange);
            break;
        }
    }

    void SetFixedWide(bool mode)            { mFixedWide = mode; }
    bool GetFixedWide()                     { return mFixedWide; }

    class ScrollThumb : public Button
    {
    public:
        ScrollThumb(ScrollBar* parent, int width, int height, std::string label) :
            Button(parent, width, height, label)
        {
            mParent = parent;
            SetRoundness(0, 0, 0, 0);
            SetBorderType(BEV_ETCHED);
            SetBackground(0x0);
#ifdef OGL_USING_GLUT
            SetAlignOffsets(0,-1);
#endif
        }

        virtual void
        MouseFunc(INT msg, INT but, INT state, INT x, INT y)
        {
            if (!GetState() || (state & (oglShift|oglControl)))
                return;

            Button::MouseFunc(msg, but, state, x, y);
            if (msg == oglMouseDown && but == oglLeftButton) 
            {
                mDragging = true;
                mClickX = x;
                mClickY = y;
            }

            if (msg == oglMouseUp && but == oglLeftButton)
                mDragging = false;
            if (msg == oglMouseMove)
            {
                if (mDragging)
                {
                    if (mParent->mHorizontal)
                    {
                        mOglWnd->x += x - mClickX;
                        // check restraints 
                        if (mOglWnd->x < cSbW)
                            mOglWnd->x = cSbW;
                        int max = mParent->mPixelRange + cSbW - mOglWnd->width;
                        if (mOglWnd->x > max)
                            mOglWnd->x = max;
                        // feedback to parent
                        mParent->OnScrollThumb(mOglWnd->x - cSbW);
                    }
                    else
                    {
                        mOglWnd->y += y - mClickY;
                        // check restraints 
                        if (mOglWnd->y < cSbW)
                            mOglWnd->y = cSbW;
                        int max = mParent->mPixelRange + cSbW - mOglWnd->height;
                        if (mOglWnd->y > max)
                            mOglWnd->y = max;
                        // feedback to parent
                        mParent->OnScrollThumb(mParent->mPixelRange + cSbW -
                                              mOglWnd->height - mOglWnd->y);
                    }
                }
            }
        }
    private:
        ScrollBar*  mParent;
        bool        mDragging;
        int         mClickX;
        int         mClickY;
    };

protected:
    bool                 mHorizontal;
    bool                 mFixedWide;
    bool                 mScrollKeyHandling;
    ULONG                mOldBorderBg;
    int                  mWide;
    ScrollBarListener*   mListener;
    void*                mListenerData;
    DirectionButton*     mButIncr;
    DirectionButton*     mButDecr;
    ScrollThumb*         mButThumb;
    int                  mMouseDownPos;
    bool                 mPagePressed;

                         // in 'scroll units' (lines)
    int                  mScrollRange, mScrollPage, mScrollPos;
    int                  mPixelRange, mPixelPage, mPixelPos; // in pixels
    int                  mScrollLine;

    // RvB: Risk division by zero?: mPixelRange==mPixelPage 
    void
    OnScrollThumb(int pos)
    {
        mPixelPos = pos;
        // RvB: Provisorische oplossing. Met Michiel bespreken
        if (mPixelRange == mPixelPage){
            //oglSys.ErrorBox("Error", "Division by zero");
            mPixelPage--;
        }
        double p = (double)pos/(double)(mPixelRange-mPixelPage);
        mScrollPos = (int) (p * (mScrollRange-mScrollPage));
        if(mListener)
            mListener->OnScroll(this, mScrollPos, mListenerData);
    }

    friend class ScrollThumb;


private:
    static const int cSbW = 16;

    void
    Init(bool isHor, int wide)
    {
        GuiGeneralName("ScrollBar");
        GuiName("ScrollBar");
        mHorizontal = isHor;
        mScrollKeyHandling = true;
        mFixedWide = false;
        mWide = wide;
        mPixelRange = (isHor ? mOglWnd->width : mOglWnd->height) - (2*cSbW);
        mScrollRange = 0;
        mScrollPage = 0;
        mScrollPos = 0;
        mScrollLine = 1;
        mPixelPos = 0;
        mListener = 0;
        mListenerData = 0;
        mPagePressed = false;

        mButDecr = new DirectionButton(this, cSbW, cSbW, isHor?2.f:1.f);
        mButDecr->GuiName("Decr");
        mButDecr->MapKeysTo(this);
        mButDecr->SetClosed(false);
        mButDecr->SetDirectionFeedback(true);
        mButDecr->SetFilled(false);
        mButDecr->SetFixedArrowSize(7);

        mButDecr->SetRoundness(0, 0, 0, 0);
        mButDecr->SetBorderType(BEV_ETCHED);
        mButDecr->SetButtonListener(this, (void*)1);
        mButDecr->SetRepeatMode(true);

        mButThumb = new ScrollThumb(this, cSbW, cSbW, "=");
        mButThumb->GuiName("Thumb");
        mButThumb->MapKeysTo(this);
        mButThumb->SetButtonListener(this, (void*)2);
        mButThumb->SetShowCancelState(false);

        mButIncr = new DirectionButton(this, cSbW, cSbW, isHor?0.f:3.f);
        mButIncr->GuiName("Incr");
        mButIncr->MapKeysTo(this);
        mButIncr->SetClosed(false);
        mButIncr->SetDirectionFeedback(true);
        mButIncr->SetFilled(false);
        mButIncr->SetFixedArrowSize(7);

        mButIncr->SetButtonListener(this, (void*)3);
        mButIncr->SetRepeatMode(true);
        mButIncr->SetRoundness(0, 0, 0, 0);
        mButIncr->SetBorderType(BEV_ETCHED);
        //mButIncr->SetShowCancelState(false);
        SetBorderType(BEV_ETCHED);

        SetDisableOGLViewKeys(true);
        SetDisableOGLViewMouse(true);
    }
};

} // namespace OglGui
#endif // ScrollBar_h

---