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

---

IntervalChooser.h

Go to the documentation of this file.

//345678901234567890123456789012345678901234567890123456789012345678901234567890
// IntervalChooser.h
// ToDo: Implement MaxInterval constraint.
//
// Author: Richard van Balen

#ifndef OglGui_IntervalChooser_h
#define OglGui_IntervalChooser_h

#include "OglGui/IntervalChooserListener.h"
#include "OglGui/SizableDirectionButton.h"

namespace OglGui {

class IntervalChooser : public Window
{
public:
    IntervalChooser(Window* parent, int x, int y, int w, int h,
                    int minVal, int maxVal, int startVal, int endVal) :
        Window(parent, x, y, w, h)
    {
        Init(w,h,minVal,maxVal,startVal,endVal);
    }

    void SetIntervalChooserListener(IntervalChooserListener* li, void* userData)
    {
        mListener = li;
        mUserData = userData;
    }

    SizableDirectionButton* StartThumb()    { return mStartThumb; }
    SizableDirectionButton* EndThumb()      { return mEndThumb; }

    void IntervalColor(ULONG col)           { mIntervalColor = col; }
    void IntervalY(int y)                   { mIntervalY = y; }

    void MinInterval(int sz)
    {
        mMinInterval = sz;
        mMinSizePix = Val2Pixel(sz);
    }

    int Val2Pixel(int val)
    {
        return ((val-mMinVal)*W())/(float)(mMaxVal-mMinVal+1);
    }
    int Pixel2Val(int pix)
    {
        return mMinVal + (pix*(mMaxVal-mMinVal+1))/(float)W();
    }

    int NeedleX(SizableDirectionButton* szBtn)
    {
        return szBtn->X() + szBtn->W()/2;
    }
    int SetNeedleX(SizableDirectionButton* szBtn, int x)
    {
        ClampX(x);
        szBtn->SetDimensions(x-szBtn->W()/2,RETAIN,RETAIN,RETAIN);
        return x;
    }

    void SetHighlightBorderType(int mode)
    {
        mStartThumb->SetHighLightBorderType(mode);
        mEndThumb->SetHighLightBorderType(mode);
    }

    virtual void DisplayFunc()
    {
        int     bInfo[3];
        OGC     myOGC;

        OGCSave(&myOGC);
        Window::DisplayFunc();

        if (!mReshaping)
            HandleThumbs();
        mReshaping = false;

        oglSys.StartBlend(bInfo);
        SetSolidFillColor(mIntervalColor);
        int sX = NeedleX(mStartThumb);
        int eX = NeedleX(mEndThumb);
        FillRectangle(sX,mIntervalY,eX-sX,H()-mIntervalY);
        oglSys.EndBlend(bInfo);
        OGCRestore(&myOGC);
    }

    virtual void ReshapeFunc(int w, int h)
    {
        Window::ReshapeFunc(w,h);
        SetNeedleX(mStartThumb,Val2Pixel(mStartVal));
        SetNeedleX(mEndThumb,Val2Pixel(mEndVal));
        mMinSizePix = Val2Pixel(mMinInterval);
        mReshaping = true;
    }

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

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

        if (mDragging && !(state & oglLeftButton))
        {
            mDragging = false;
            mMinSizePix = mOldMinSizePix;
        }
        if (msg==oglMouseDown && state==oglLeftButton)
        {
            mDragging = true;
            int sX = NeedleX(mStartThumb);
            int eX = NeedleX(mEndThumb);
            mDragDiffX = x - sX; 
            mOldMinSizePix = mMinSizePix;
            mMinSizePix = eX - sX;
        }
        if (msg == oglMouseMove && state==oglLeftButton)
        {
            int nX = SetNeedleX(mStartThumb, x - mDragDiffX);
            SetNeedleX(mEndThumb,nX + mMinSizePix);
        }
    }

protected:
    void ClampX(int& x)
    {
        int w = W();
        if (x<0) x = 0;
        if (x>w) x = w;
    }

    void HandleThumbs()
    {
        int oldStartVal = mStartVal;
        int oldEndVal   = mEndVal;
        int sX          = NeedleX(mStartThumb);
        int eX          = NeedleX(mEndThumb);

        ClampX(sX);
        ClampX(eX);
        if (mOldStartX < sX && sX >= eX-mMinSizePix)
        {
            if (eX==W())
                sX = eX-mMinSizePix+1;
            else
                eX = sX+mMinSizePix;
        }
        else if (mOldEndX > eX && eX <= sX+mMinSizePix)
        {
            if (sX == 0)
                eX = mMinSizePix;
            else
                sX = eX-mMinSizePix;
        }
        mOldStartX = sX = SetNeedleX(mStartThumb,sX);
        mOldEndX   = eX = SetNeedleX(mEndThumb,eX);
        mStartVal  = Pixel2Val(sX);
        mEndVal    = mStartVal + Pixel2Val(eX-sX);

        if (mEndVal > mMaxVal)
            mEndVal = mMaxVal;

        if (oldStartVal == mStartVal && oldEndVal == mEndVal)
            return;
        // printf("%d %d\n", mStartVal, mEndVal);
        if (mListener)
            mListener->IntervalChanged(this,mStartVal,mEndVal,mUserData);
    }

    SizableDirectionButton*
    MakeThumb(Window* parent, int x, int y, int w, int h, ULONG col, ULONG hCol)
    {
        SizableDirectionButton* szBtn =
            new SizableDirectionButton(parent,x,y,w,h,1,0);
        szBtn->SetBorderType(0);

        // If col and highlight col are the same: show highlighted as button
        szBtn->SetHighLightBorderType(col==hCol?BEV_RAISED:0);
        szBtn->SetAllowHighlight(false);
        
        szBtn->SetAllowMoveDirections(SizableWindow::AllDir,false);
        szBtn->SetAllowMoveDirections(SizableWindow::EastWest,true);
        szBtn->SetAllowSizeDirections(SizableWindow::AllDir,false);
        szBtn->DirButton()->SetFilled(true);
        szBtn->SetColors(col,hCol);
        return szBtn;
    }

private :

    void Init(int w, int h, int minVal, int maxVal, int startVal, int endVal)
    {
        mMinVal     = minVal;
        mMaxVal     = maxVal;
        mStartVal   = startVal;
        mEndVal     = endVal;
        mMinInterval= 1;
        mMinSizePix = Val2Pixel(mMinInterval);

        mStartColor     = oglTrRED;
        mEndColor       = oglTrGREEN;
        mIntervalColor  = oglTrLIGHTGREY;

        mOldStartX = Val2Pixel(mStartVal);
        mStartThumb = MakeThumb(this,mOldStartX-8,0,15,15,oglTrRED,0x80a00000);

        mOldEndX = Val2Pixel(mEndVal);
        mEndThumb = MakeThumb(this,mOldEndX-8,0,15,15,oglTrGREEN,0x8000a000);

        mIntervalY = 2;
        mDragging  = false;
        mListener  = 0;
    }

    IntervalChooserListener*    mListener;
    void*                       mUserData;

    SizableDirectionButton*     mStartThumb;
    SizableDirectionButton*     mEndThumb;

    ULONG                       mStartColor;
    ULONG                       mEndColor;
    ULONG                       mIntervalColor;
    int                         mMinVal;
    int                         mMaxVal;
    int                         mStartVal;
    int                         mEndVal;
    int                         mMinInterval;
    int                         mMinSizePix;
    int                         mOldMinSizePix;
    int                         mIntervalY;
    int                         mOldStartX;
    int                         mOldEndX;
    int                         mDragDiffX;
    bool                        mDragging;
    bool                        mReshaping;
};

} // namespace OglGui

#endif // IntervalChooser_h

---