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

---

Button.h

Go to the documentation of this file.

/*
12345678901234567890123456789012345678901234567890123456789012345678901234567890
*/
#ifndef OglGui_Button_h
#define OglGui_Button_h

#ifndef OglGui_RepeatTimer_h
#include "OglGui/RepeatTimer.h"
#endif

#ifndef OglGui_StaticText_h
#include "OglGui/StaticText.h"
#endif

#ifndef OglGui_ButtonListener_h
#include "OglGui/ButtonListener.h"
#endif

// RvB: Zou wat mij betreft ook niet van static text afgeleid kunnen worden.
// Ik wil in ieder geval nog een functie in Window.h
// die een gegeven (meerlijnige) text kan aligneren in beide richtingen.
// Iets als:
// AlignText(strconst txt, TxtAlign hor=AlignCenter, TxtAlign vert=AlignCenter,
//           bool shaded=false, shadCol=oglGREY )
// De text zou dan in de mForeGroundCol getekend kunnen worden.
// Wanneer deze functie bestaat heeft de afleiding van Static text
// weinig zin meer

namespace OglGui
{

class Button : public StaticText, public RepeatTimer
{
public:

    Button(Window* parent, int x, int y, int width, int height, strconst label,
           int borderType = BEV_RIDGE, bool isRect=false) :
        StaticText(parent, x, y, width, height, label, true, true)
    {
        Init(borderType, isRect);
    }

    Button(Window* parent, int width, int height, strconst label,
           int borderType = BEV_RIDGE, bool isRect=false) :
        StaticText(parent, width, height, label, true, true)
    {
        Init(borderType, isRect);
    }

    void
    SetButtonListener(ButtonListener* listener, void* listenerData = 0)
    {
        mButtonListener = listener;
        mButtonListenerData = listenerData;
    }
    void
    SetButtonListener(ButtonListener* listener, int listenerData)
    {
        SetButtonListener(listener, (void*) /*(long long)*/ listenerData);
    }

    void
    DoButtonSelectionEvent()
    {
        if( mButtonListener && GetState() )
            mButtonListener->ButtonSelectionEvent(this, mButtonListenerData);
    }

    virtual void
    InitDisplayFunc()
    {
        oglSys.SetBorderFillShaded( mOglWnd, mFillShadedType * (mIsPressed ? -1 : 1) );
        glNormal3f(0,0,1);
        if( mIsSelected )
        {
            ULONG oldBg = oglSys.GetBorderBackground( mOglWnd );
            oglSys.SetBorderBackground( mOglWnd, mSelectedColor );
            HandleShadeBorder( mOglWnd );
            oglSys.SetBorderBackground( mOglWnd, oldBg );
        }
        StaticText::InitDisplayFunc();
    }

    virtual void
    DisplayFunc()
    {
        if( mRepeatMode && mIsPressed && RepeatTime() )
            DoButtonSelectionEvent();

        Window::SetBorderType( mIsPressed ? mDownBorderType : mUpBorderType );

        Window::DisplayFunc();
        AlignString( mAlignOffH + (mIsPressed?1:0), mAlignOffV + (mIsPressed?-1:0) );
    }

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

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

        if (state & (oglAlt|oglShift|oglControl))
            return;

        // RvB: Experimental
        if (msg == oglMouseWheelUp || msg == oglMouseWheelDown)
            GetParent()->MouseFunc(msg, but, state, x, y);

        if ((msg == oglMouseDown || msg == oglMouseDblClick)
            && (but == oglLeftButton) )
        {
            mIsPressed = true;
            if (mRepeatMode)
            {
                StartRepeatTime();
                oglSys.SetAlwaysDraw(mOglWnd, true);
                DoButtonSelectionEvent();
            }
        }
        if (msg == oglMouseMove && (state & oglLeftButton) )
        {
            if( (x < 0 || x > mOglWnd->width || y < 0 || y > mOglWnd->height) &&
                mShowCancelState )
                mIsPressed = false;
            else
                mIsPressed = true;
            if( mShowCancelState )
                SetState( mIsPressed ? 2 : 1 );
        }
        if (msg == oglMouseUp)
        {
            oglSys.SetAlwaysDraw(mOglWnd, false);
            oglSys.UpdateSceneFlag(mOglWnd, 1);
            if (!mRepeatMode && mIsPressed)
            {   mIsPressed = false;
                DoButtonSelectionEvent();
            }
            else
                mIsPressed = false;
        }
    }

    /*
    virtual void
    KeyboardFunc( INT c, INT state )
    {
        Window::KeyboardFunc(c, state);

        // Next experimental lines made conditional after introduction of MapKeysTo
        // Now if you want the keyboard input of a button you must
        // call: but->MapKeysTo(Window*);

        // RvB: Experimental, passing on to parent
        if (!mMapKeysTarget)
            GetParent()->KeyboardFunc(c, state);
    }
    */

    void
    SetLabel( std::string label )
    {
        SetText( label );
    }

    std::string
    GetLabel()
    {
        return GetText();
    }

    virtual void
    SetBorderType( int type )
    {
        Window::SetBorderType( type );
        mUpBorderType = mDownBorderType = type;
    }

    void
    SetUpBorderType( int type )
    {
        mUpBorderType = type;
    }

    void
    SetDownBorderType( int type )
    {
        mDownBorderType = type;
    }

        virtual void
        SetBorderFillShaded(int type=2)
        {
                mFillShadedType = type;
        Window::SetBorderFillShaded(type);
        }

    void
    SetRepeatMode(bool b=true)
    {
        mRepeatMode = b;
    }

    bool
    IsPressed()
    {
        return mIsPressed;
    }

    void
    SetPressed( bool pressed )
    {
        mIsPressed = pressed;
    }

    void
    SetSelected( bool selected )
    {
        mIsSelected = selected;
    }

    bool
    IsSelected()
    {
        return mIsSelected;
    }

    void
    SetShowCancelState( bool mode )
    {
        mShowCancelState = mode;
    }

private:

    void
    Init(int borderType, bool isRect)
    {
        GuiGeneralName("Button");

        mButtonListener = 0;
        mRepeatMode = false;
        SetRepeatDelays( 400, 20 );

        mDoStateFeedback = true;
        mShowCancelState = true;
        mIsPressed = false;
        mIsSelected = false;
        SetForeground( oglBLACK );
        
        mSelectedColor = 0xffff0000;

        SetBorderType( borderType );
        mDownBorderType = BEV_SUNKEN;

        SetBorderFillShaded(2);
        SetBorderFillOpacity( 0.5f );
        if( !isRect )
            SetRoundness( 200, 200, 200, 200 );

        SetDisableOGLViewKeys( true );
        SetDisableOGLViewMouse( true );
    }

    ButtonListener*   mButtonListener;
    void*             mButtonListenerData;
    ULONG             mSelectedColor;
    bool              mRepeatMode;

    bool              mIsPressed;
    bool              mIsSelected;
    bool              mShowCancelState;
    int               mUpBorderType;
    int               mDownBorderType;
    int               mFillShadedType;

};

} // namespace OglGui

#endif

---