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

---

UpDownButton.h

Go to the documentation of this file.

/*
 * UpDownButton to be used in combination with other widgets.
 * For example combining it with a TextField to create an UpDownNumber
 */

#ifndef OglGui_UpDownButton_h
#define OglGui_UpDownButton_h

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

#ifndef OglGui_UpDownButtonListener_h
#include "OglGui/UpDownButtonListener.h"
#endif

// RvB: I could store the buttons in a vector in their own class
// and make a DirectionSetter interface that performs the actions
// over all DirectionButtons in the vector.
//
// Class DirectionButtonSet -> holder of the buttons with setting functions
// Dan UpDownButton en future LeftRightButton als extension hiervan.

namespace OglGui
{

class UpDownButton : public Window, ButtonListener
{
public:

    UpDownButton(Window* parent, int x, int y, int width, int height,
                 bool leftRight=false, int margin=0) :
        Window(parent, x, y, width, height)
    {
        Init(width, height, leftRight, margin);
    }

    UpDownButton(Window* parent, int width, int height,
                 bool leftRight=false, int margin=0) :
        Window(parent, width, height)
    {
        Init(width, height, leftRight, margin);
    }

    void
    SetUpDownButtonListener(UpDownButtonListener* listener, void* userData = 0)
    {
        mListener = listener;
        mListenerData = userData;
    }
    void
    SetUpDownButtonListener(UpDownButtonListener* listener, int userData)
    {
        SetUpDownButtonListener(listener, (void *) userData);
    }

    virtual void ButtonSelectionEvent(Button *src, void* userData)
    {
        if (!mListener)
            return;
        mListener->UpDownButtonSelectionEvent(this, userData==(void*)1, mListenerData);
    }

    DirectionButton* UpButton() const
    {
        return mUpButton;
    }

    DirectionButton* DownButton() const
    {
        return mDownButton;
    }

    virtual void MouseFunc(INT msg, INT but, INT state, INT x, INT y)
    {
        Window::MouseFunc(msg, but, state, x, y);
        if (msg == oglMouseWheelUp)
            mUpButton->DoButtonSelectionEvent(); 
        if (msg == oglMouseWheelDown)
            mDownButton->DoButtonSelectionEvent(); 
    }

    /*
    virtual void KeyboardFunc( INT c, INT state )
    {
        Window::KeyboardFunc(c, state);
        GetParent()->KeyboardFunc(c, state);
    }
    */

    void SetRepeatMode(bool mode)
    {
        mUpButton->SetRepeatMode(mode);
        mDownButton->SetRepeatMode(mode);
    }

    void SetDirectionFeedback(bool mode, ULONG feedbackCol=0xff606060)
    {
        mUpButton->SetDirectionFeedback(mode, feedbackCol);
        mDownButton->SetDirectionFeedback(mode, feedbackCol);
    }

    void SetClosed(bool mode=true)
    {
        mUpButton->SetClosed(mode);
        mDownButton->SetClosed(mode);
    }

    void SetFilled(bool mode=true)
    {
        mUpButton->SetFilled(mode);
        mDownButton->SetFilled(mode);
    }

    void SetFixedArrowSize(int sz)
    {
        mUpButton->SetFixedArrowSize(sz);
        mDownButton->SetFixedArrowSize(sz);
    }

    void AdjustRoundness(float r0, float r1, float r2, float r3,
                         bool childAdjust=true, int margin=0)
    {
        Window::SetRoundness(r0, r1, r2, r3);
        if (childAdjust && !mLeftRight)
        {
            mUpButton->SetRoundness(r0-margin, r1-margin, FRETAIN, FRETAIN);
            mDownButton->SetRoundness(FRETAIN, FRETAIN, r2-margin, r3-margin);
        }
        if (childAdjust && mLeftRight)
        {
            mUpButton->SetRoundness(FRETAIN, r1-margin, r2-margin, FRETAIN);
            mDownButton->SetRoundness(r0-margin, FRETAIN, FRETAIN, r3-margin);
        }
    }


private :

    void
    Init(int w, int h, bool leftRight, int margin)
    {
        int     m = margin;

        if (m >= w/2)
            m = w/2-1;
        if (m >= h/2)
            m = h/2-1;

        mLeftRight = leftRight;
        mListener = 0;

        if (!leftRight)
        {
            mUpButton = new DirectionButton(this, m, h/2, w-2*m, h/2-m, 1.0f);
            mDownButton = new DirectionButton(this, m, m, w-2*m, h/2-m, 3.0f);
        }
        else
        {
            mUpButton = new DirectionButton(this, w/2, m, w/2-m, h-2*m, 0.0f);
            mDownButton = new DirectionButton(this, m, m, w/2-m, h-2*m, 2.0f);
        }

        mUpButton->SetButtonListener(this, (void*)1);
        mDownButton->SetButtonListener(this, (void*)-1);

        // If user indicated a margin than provide suitable default border
        if (margin > 0)
            SetBorderType((margin<3) ? BEV_LINE : BEV_ETCHED);

        SetDirectionFeedback(true);

        ScaleChildren(0,true);

        // Prevent others setting scaling as we allready scale
        mUpButton->SetAllowScaling(false);
        mDownButton->SetAllowScaling(false);

        // To prevent the margin becoming bigger when scaling
        if (margin>0)
        {
            if (!leftRight)
            {
                mUpButton->ConnectTo(this, T2T | R2R | L2L | TPARENT);
                mDownButton->ConnectTo(this, B2B | R2R | L2L | TPARENT);
            }
            else
            {
                mUpButton->ConnectTo(this, B2B | T2T | R2R | TPARENT);
                mDownButton->ConnectTo(this, B2B | T2T | L2L | TPARENT);
            }
        }
    }
    DirectionButton*      mUpButton;
    DirectionButton*      mDownButton;
    UpDownButtonListener* mListener;
    void*                 mListenerData;
    bool                  mLeftRight;

};

} // namespace OglGui

#endif UpDownButton_h

---