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

---

SpinWheel.h

Go to the documentation of this file.

#ifndef OglGui_SpinWheel_h
#define OglGui_SpinWheel_h

// (RvB) nog instelbaar maken welke richting incr en decr zijn
#include "OglGui/RepeatTimer.h"
#include "OglGui/Window.h"
#include "OglGui/SpinWheelListener.h"

namespace OglGui
{

class SpinWheel : public Window, RepeatTimer
{
public:

    SpinWheel(Window* parent, int x, int y, int w, int h,
              int minVal, int maxVal, int val) :
        Window(parent, x, y, w, h)
    {
        Init(true, minVal, maxVal, val);
    }

    SpinWheel(Window* parent, int w, int h, int minVal, int maxVal, int val) :
        Window(parent, w, h)
    {
        Init(true, minVal, maxVal, val);
    }

    SpinWheel(Window* parent, int x, int y, int w, int h,
              float minVal, float maxVal, float val) :
        Window(parent, x, y, w, h)
    {
        Init(false, minVal, maxVal, val);
    }

    SpinWheel(Window* parent, int w, int h,
              float minVal, float maxVal, float val) :
        Window(parent, w, h)
    {
        Init(false, minVal, maxVal, val);
    }

    void SetSpinWheelListener(SpinWheelListener* l, void* userData=0)
    {
        mSpinWheelListener = l;
        mSpinWheelListenerData = userData;
    }
    void SetSpinWheelListener(SpinWheelListener* l, int userData)
    {
        SetSpinWheelListener(l, (void*) userData);
    }

    void CenterValStr(int dX, int dY) const
    {
        char    buf[25];
        int     rX, rY;
        int     w, h, state = GetState();

        if (mAsInt && mShowAsPercentage)
            sprintf(buf, "%.2f", mVal / 100.0f);
        else if (mAsInt)
            sprintf(buf, "%d", (int) mVal);
        else
            sprintf(buf, "%.2f", mVal);

        oglSys.GetTextExtent(mOglWnd, buf, &w, &h);
        oglSys.StartOrtho(mOglWnd);

        rX = mOglWnd->width/2 - w/2 + dX;
        rY = mOglWnd->height/2 - h/2 + dY;

        SetSolidFillColor(oglLIGHTGREY | (state==2 ? mStateFeedbackColor : 0));
        FillRoundRectExt(rX-4, rY-1, w+8, h+1, 6, 6, 6, 6);
        DrawBevRoundRectExt(BEV_SUNKEN, rX-4, rY-1, w+8, h+1, 6, 6, 6, 6);

        oglSys.ShadowPrintf(mOglWnd, rX, rY+1, state ? oglLIGHTGREY : oglGREY,
                            state ? oglBLACK : oglLIGHTGREY, buf);
        oglSys.EndOrtho();
    }

    virtual void DrawWheel()
    {
        int     start = - abs((int)(3*mVal)) % mOglWnd->height;
        int     n = 0, lDist = mLineDistance;

        for(int i = start; i < mOglWnd->height; i += lDist){
            n++;
            if (i < 0) continue;
            SetSolidLineColor(mDrawLineEtched ? oglWHITE : oglBLACK);
            DrawLine(0, i, mOglWnd->width, i);
            SetSolidLineColor(mDrawLineEtched ? oglBLACK : oglWHITE);
            DrawLine(0, i+1, mOglWnd->width, i+1);

            if (mLineDistance > 7 && !(n % 5)){
                SetSolidLineColor(oglBLUE);
                DrawLine(0, i+lDist/2, mOglWnd->width, i+lDist/2);
            }
        }

        if (mShowValInWheel)
            CenterValStr(0, 0);
    }

    virtual void DisplayFunc()
    {
        OGC     oldOGC;

        OGCSave(&oldOGC);

        if (mIsPressed && RepeatTime())
            PropagateScrolling();

        Window::DisplayFunc();

        DrawWheel();
        OGCRestore(&oldOGC);
   }

    void PropagateScrolling()
    {
        SetValue(mVal + (mDownDir ? -mIncrement : mIncrement));
    }

    virtual void MouseFunc(INT msg, INT but, INT state, INT x, INT y)
    {
        Window::MouseFunc(msg, but, state, x, y);

        if (!GetState()) return;

        if (msg == oglMouseWheelUp || msg == oglMouseWheelDown)
            SetValue(mVal + (msg==oglMouseWheelUp ? mIncrement : -mIncrement));

        mDownDir = (y < mOglWnd->height/2);

        if ((msg == oglMouseDown) && (but == oglLeftButton)){
            mIsPressed = true;
            StartRepeatTime();
            SetValue(mVal + (mDownDir ? -mIncrement : mIncrement));
            oglSys.SetAlwaysDraw(mOglWnd, true);
        }
        if (msg == oglMouseMove && (state & oglLeftButton))
            mIsPressed = (x>0 && x<mOglWnd->width && y>0 && y<mOglWnd->height);

        if (msg == oglMouseUp) {
            oglSys.SetAlwaysDraw(mOglWnd, false);
            mIsPressed = false;
        }
    }

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

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

        if (c == oglLEFT || c== oglRIGHT || c == oglUP || c == oglDOWN)
            SetValue(mVal + ((c==oglLEFT||c==oglUP) ? -mIncrement:mIncrement));
        if (c == oglPAGEUP || c == oglPAGEDOWN)
            SetValue(mVal + ((c==oglPAGEUP) ? -mPageIncrement:mPageIncrement));
        if (c == oglHOME || c == oglEND)
            SetValue((c==oglHOME) ? mMinVal : mMaxVal);
    }

    bool IsPressed() const
    {
        return mIsPressed;
    }

    float GetValue() const
    {
        return mVal;
    }

    void SetValue(float val)
    {
        if (val < mMinVal)
            val = mMinVal;
        if (val > mMaxVal)
            val = mMaxVal;
        if (val == mVal)
            return;

        mVal = val;
        if (mSpinWheelListener)
            mSpinWheelListener->SpinWheelChanged(this, mSpinWheelListenerData);
    }

    void SetMinimum(float min)
    {
        mMinVal = min;
    }

    float GetMinimum() const
    {
        return mMinVal;
    }

    void SetMaximum(float max)
    {
        mMaxVal = max;
    }

    float GetMaximum() const
    {
        return mMaxVal;
    }

    void SetDrawLineEtched(bool mode)
    {
        mDrawLineEtched = mode;
    }

    bool GetDrawLineEtched() const
    {
        return mDrawLineEtched;
    }

    void SetIncrement(float inc)
    {
        mIncrement = inc;
    }

    float GetIncrement() const
    {
        return mIncrement;
    }

    void SetPageIncrement(float inc)
    {
        mPageIncrement = inc;
    }

    float GetPageIncrement() const
    {
        return mPageIncrement;
    }

    void SetLineDistance(int len)
    {
        mLineDistance = len;
    }

    int GetLineDistance() const
    {
        return mLineDistance;
    }

    void SetShowValInWheel(bool doShow=true)
    {
        mShowValInWheel = doShow;
    }

    bool GetShowValInWheel() const
    {
        return mShowValInWheel;
    }

    void
    SetShowAsPercentage(bool doShow=true)
    {
        mShowAsPercentage = doShow;
    }

    bool GetShowAsPercentage() const
    {
        return mShowAsPercentage;
    }

private:

    void Init(bool asInt, float minVal, float maxVal, float val)
    {
        mSpinWheelListener = 0;

        mIsPressed = false;

        mAsInt = asInt;
        mVal = val;
        mMinVal = minVal;
        mMaxVal = maxVal;

        mIncrement = 1;
        mPageIncrement = 10;

        mDrawLineEtched = false;
        mLineDistance = 8;
        mIsPressed = false;

        mShowAsPercentage = false;
        mShowValInWheel = true;

        SetBorderType(BEV_RAISED);
        SetBorderFillShaded(2);
        SetRoundness(12, 12, 12, 12);
        mOglWnd->clipRounded = 1;
        SetDoStateFeedback(true);

        // RvB: By disabling OGLView(Keys)(Mouse) we don't really have to set
        // next line
        oglSys.SetAllowCameraMove(mOglWnd, false);

        SetDisableOGLViewKeys(true);
        SetDisableOGLViewMouse(true);
    }

protected:
    SpinWheelListener* mSpinWheelListener;

    void*       mSpinWheelListenerData;

    float       mMinVal, mMaxVal, mVal;
    float       mIncrement;
    float       mPageIncrement;

    bool        mDownDir;
    bool        mIsPressed;

    bool        mDrawLineEtched;
    int         mLineDistance;
    bool        mAsInt;
    bool        mShowAsPercentage;
    bool        mShowValInWheel;
};

} // namespace OglGui

#endif

---