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

---

Slider.h

Go to the documentation of this file.

#ifndef OglGui_Slider_h
#define OglGui_Slider_h

#ifndef OglGui_Window_h
#include "OglGui/Window.h"
#endif

#ifndef OglGui_SliderListener_h
#include "OglGui/SliderListener.h"
#endif

namespace OglGui
{

class Slider : public Window
{
public:

    Slider(Window* parent, int w, int h, int minVal, int maxVal, int val,
           int borderType=BEV_ETCHED, float roundness=0) :
        Window(parent, w, h)
    {
        Init(minVal, maxVal, val, borderType, roundness);
    }

    Slider(Window* parent, int x, int y, int w, int h, int minVal, int maxVal,
           int val, int borderType=BEV_ETCHED, float roundness=0) :
        Window(parent, x, y, w, h)
    {
        Init(minVal, maxVal, val, borderType, roundness);
    }

    void
    SetSliderListener(SliderListener* listener, void* listenerData = 0)
    {
        mSliderListener = listener;
        mSliderListenerData = listenerData;
    }

    void HorBackDrawing(int y, int wndW, int wndH) const
    {
        char    buf[25], format[10];
        int     tW, tH, x, oldTickX = -100;

        // Show base line
        SetSolidLineColor(oglBLACK);
        DrawLine(mThumbW/2, y, wndW - mThumbW/2, y);
        SetSolidLineColor(oglWHITE);
        DrawLine(mThumbW/2, y - 1, wndW - mThumbW/2, y - 1);

        if (mShowTicks && (wndW > mThumbW + 40) &&
           (mUpsideDown ? (y - 3 > 0) : (y + 3 < wndH)))
        {
            for(int i = mMinVal; i < mMaxVal+mTickInterval; i += mTickInterval)
            {
                int tickLen = 5;

                if (i > mMaxVal) i = mMaxVal;

                x = (int) (mThumbW/2 + ((i-mMinVal) / (float)(mMaxVal-mMinVal))
                          * (mOglWnd->width-mThumbW));

                if (mShowTickValue &&
                   (mUpsideDown ? (y-11-tickLen > 0) : (y+16+tickLen < wndH)))
                {
                    sprintf(format, "%%.%df", mPrecisionIdx);
                    sprintf(buf, format, i / pow(10.0,mPrecisionIdx));
                    /*
                    sprintf(buf, mShowValPerc ? "%.2f" : "%.0f",
                            i / (mShowValPerc ? 100.0f : 1.0f));
                    */
                    oglSys.GetTextExtent(mOglWnd, buf, &tW, &tH);
                    if (x - oldTickX > tW + 8)
                    {
                        tickLen += 3;
                        oldTickX = x;
                        int len = mUpsideDown ? -(tickLen-1+tH) : (tickLen+4);
                        oglSys.ShadowPrintf(mOglWnd, x - tW/2 - 1, y + len,
                                            oglWHITE, oglBLACK, "%s", buf);
                    }
                }
                int y1 = y + (mUpsideDown ? -2 : 2);
                int y2 = y1 + (mUpsideDown ? -tickLen : tickLen);
                SetSolidLineColor(oglWHITE);
                DrawLine(x, y1, x, y2);
                SetSolidLineColor(oglDARKGREY);
                DrawLine(x-1, y1, x-1, y2);
            }
        }
    }

    void VerBackDrawing(int x, int wndW, int wndH) const
    {
        char    buf[25], format[10];
        int     tW, tH, y, oldTickY = -100;

        // Draw base line
        SetSolidLineColor(oglBLACK);
        DrawLine(x, mThumbH/2, x, wndH - mThumbH/2);
        SetSolidLineColor(oglWHITE);
        DrawLine(x-1, mThumbH/2, x - 1, wndH - mThumbH/2);

        if (mShowTicks && (wndH > mThumbH + 40) &&
           (mUpsideDown ? (x - 3 > 0) : (x + 3 < wndW)))
        {
            for(int i = mMinVal; i < mMaxVal+mTickInterval; i += mTickInterval)
            {
                int tickLen = 5;

                if (i > mMaxVal)
                    i = (int) mMaxVal;

                y = (int) (mThumbH/2 + ((i-mMinVal) /
                          (float) (mMaxVal-mMinVal)) * (wndH-mThumbH));

                if (mShowTickValue)
                {
                    sprintf(format, "%%.%df", mPrecisionIdx);
                    sprintf(buf, format, i / pow(10.0,mPrecisionIdx));

                    oglSys.GetTextExtent(mOglWnd, buf, &tW, &tH);
                    if (y - oldTickY > tH/2 + 8)
                    {
                        tickLen += 3;
                        oldTickY = y;
                        int len = mUpsideDown ? -(tickLen+5+tW) : (tickLen+2);
                        oglSys.ShadowPrintf(mOglWnd, x + len, y - 5, oglWHITE,
                                            oglBLACK, "%s", buf);

                    }
                }
                int x1 = x + (mUpsideDown ? -2 : 0);
                int x2 = x1 + (mUpsideDown ? -tickLen : tickLen);
                SetSolidLineColor(oglWHITE);
                DrawLine(x1, y, x2, y);
                SetSolidLineColor(oglDARKGREY);
                DrawLine(x1, y-1, x2, y-1);
            }
        }
    }

    // specialization of base classes

    virtual void DisplayFunc()
    {
        int     wndW = mOglWnd->width, wndH = mOglWnd->height;
        int     x, y, tW, tH;
        INT     bInfo[3];
        char    buf[25], format[10];

        Window::DisplayFunc();

        OGC oldOGC;

        if (GetState() == 0) return;
        OGCSave(&oldOGC);

        if (mTickInterval < 1)
            mTickInterval = 1;

        if (mHorizontal){
            x = (int) (mThumbW/2 + ((mVal-mMinVal) / (float) (mMaxVal-mMinVal))
                      * (wndW-mThumbW));
            y = (int) (mUpsideDown ? wndH - mThumbH / 2 - 2: mThumbH / 2 + 2);
            HorBackDrawing(y, wndW, wndH);
        }
        else {
            y = (int) (mThumbH/2 + ((mVal-mMinVal) / (float) (mMaxVal-mMinVal))
                      * (wndH-mThumbH));
            x = (int) (mUpsideDown ? wndW - mThumbW / 2: mThumbW / 2);
            VerBackDrawing(x, wndW, wndH);
        }

        if (mDrawBlendedThumb) oglSys.StartBlend(bInfo);

        if (mShowValNeedle){
            SetSolidLineColor(oglTrDARKGREY);
            if (mHorizontal)
                DrawLine(x, 3, x, wndH - 2);
            else
                DrawLine(3, y, wndW - 2, y);
        }

        if (mShowVal){
            ULONG col = mIsPressed ? oglTrGREY : oglTrLIGHTGREY;
            col |= (GetState()==2) ? mStateFeedbackColor : 0;
            SetSolidFillColor(col);

            if (mThumbR != 0.0f){
                FillRoundRectExt(x-mThumbW/2, y-mThumbH/2, mThumbW, mThumbH,
                                 mThumbR, mThumbR, mThumbR, mThumbR);
                DrawBevRoundRectExt(mIsPressed ? BEV_SUNKEN : BEV_RAISED,
                                    x-mThumbW/2, y-mThumbH/2, mThumbW, mThumbH,
                                    mThumbR, mThumbR, mThumbR, mThumbR);
            }
            else {
                FillRectangle(x - mThumbW/2, y - mThumbH/2, mThumbW, mThumbH);
                DrawBevRect(mIsPressed ? BEV_SUNKEN : BEV_RAISED,
                            x-mThumbW/2, y - mThumbH/2, mThumbW, mThumbH);
            }
        }

        if (mDrawBlendedThumb)
            oglSys.EndBlend(bInfo);

        if (mShowVal)
        {
            sprintf(format, "%%.%df", mPrecisionIdx);
            sprintf(buf, format, mVal / pow(10.0,mPrecisionIdx));
            oglSys.GetTextExtent(mOglWnd, buf, &tW, &tH);
            oglSys.ShadowPrintf(mOglWnd, x - tW/2 - 1, y - tH/2 + 2,
                                oglWHITE, oglBLACK, "%s", buf);
        }

        OGCRestore(&oldOGC);
    }


    void HandleChange(int x, int y)
    {
        float nVal;

        if (mHorizontal)
        {
            x -= mThumbW/2;

            nVal = mMinVal + (x / (float) (mOglWnd->width-mThumbW))
                   * (mMaxVal-mMinVal);
            if (nVal > mMaxVal) nVal = mMaxVal;
            if (nVal < mMinVal) nVal = mMinVal;
            if (nVal == mVal)
                return;
        }
        else
        {
            y -= mThumbH/2;

            nVal = mMinVal + (y / (float) (mOglWnd->height-mThumbH))
                   * (mMaxVal-mMinVal);
            if (nVal > mMaxVal) nVal = mMaxVal;
            if (nVal < mMinVal) nVal = mMinVal;
            if (nVal == mVal)
                return;
        }
        mVal = (int) nVal;
        if (mSliderListener)
            mSliderListener->SliderChangedEvent(this, mSliderListenerData);
    }

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

        if ((state & (oglAlt | oglControl | oglShift)) != 0) return;

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

        if ((msg == oglMouseDown) && (but == oglLeftButton)){
            mIsPressed = true;
            HandleChange(x, y);
        }

        /* RvB: I want to remove this one
        if ((msg == oglMouseDown) && (but == oglRightButton) && mSliderListener)
            mSliderListener->SliderPopupEvent(this, mSliderListenerData);
        */

        if (msg == oglMouseMove)
            HandleChange(x, y);

        if (msg == oglMouseUp) 
            mIsPressed = false;
    }

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

        // Next 3 for test purposes, later to be removed
        if (c == 'a') mAutoDirection = !mAutoDirection;
        if (c == 'u') mUpsideDown = !mUpsideDown;
        if (c == 'h') mHorizontal = !mHorizontal;

        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);
        /* RvB: I want to remove this one
        if (mSliderListener)
            mSliderListener->SliderKeyEvent(this,c,state,mSliderListenerData);
        */
    }

    virtual void ViewportFunc(INT width, INT height)
    {
        Window::ViewportFunc(width, height);
        if (mAutoDirection)
            mHorizontal = width > height;
    }

// Get/Set methods
    int Value() const
    {
        return mVal;
    }

    int GetValue() const
    {
        return mVal;
    }

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

        mVal = val;
        if (mSliderListener)
            mSliderListener->SliderChangedEvent(this, mSliderListenerData);
    }

    void SetMinMax(int min, int max)
    {
        if (min!=RETAIN)
            mMinVal = min;
        if (max!=RETAIN)
            mMaxVal = max;
    }

    void GetMinMax(int& min, int& max)
    {
        min = mMinVal;
        max = mMaxVal;
    }

    void SetHorizontal(bool hor=true)
    {
        mHorizontal = hor;
    }

    bool IsHorizontal() const
    {
        return mHorizontal;
    }

    void SetShowValNeedle(bool showNeedle=true)
    {
        mShowValNeedle = showNeedle;
    }

    bool GetShowValNeedle() const
    {
        return mShowValNeedle;
    }

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

    int GetIncrement() const
    {
        return mIncrement;
    }

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

    int GetPageIncrement() const
    {
        return mPageIncrement;
    }

    void SetThumbSizes(int w, int h)
    {
        if (w != RETAIN) mThumbW = w;
        if (h != RETAIN) mThumbH = h;
    }

    void GetThumbSizes(int& w, int& h) const
    {
        w = mThumbW;
        h = mThumbH;
    }

    void SetThumbRoundness(float r)
    {
        mThumbR = r;
    }

    float GetThumbRoundness() const
    {
        return mThumbR;
    }

    void SetShowValue(bool doShow=true)
    {
        mShowVal = doShow;
    }

    bool GetShowValue() const
    {
        return mShowVal;
    }

    void SetPrecisionIdx(int n)
    {
        mPrecisionIdx = n;
    }

    void SetShowValPerc(bool doShow=true)
    {
        mShowValPerc = doShow;
        mPrecisionIdx = doShow ? 2 : 0;
    }

    bool GetShowValPerc() const
    {
        return mShowValPerc;
    }

    void SetShowTicks(bool doShow=true)
    {
        mShowTicks = doShow;
    }

    bool GetShowTicks() const
    {
        return mShowTicks;
    }

    void SetFlipOver(bool mode=true)
    {
        mUpsideDown = mode;
    }

    void SetTickInterval(int inc)
    {
        if (inc == 0)
            inc = 1;
        mTickInterval = inc;
    }

    int GetTickInterval() const
    {
        return mTickInterval;
    }

    void SetDrawBlendedThumb(bool doBlend=true)
    {
        mDrawBlendedThumb = doBlend;
    }

    bool GetDrawBlendedThumb() const
    {
        return mDrawBlendedThumb;
    }

private:

    void Init(int minVal, int maxVal, int val, int borderType, float r)
    {
        SetBorderType(borderType);
        if (r != 0.0f)
            SetRoundness(r, r, r, r);

        mHorizontal = true;
        mAutoDirection = true;
        mMinVal = minVal;
        mMaxVal = maxVal;
        mVal = val;
        mIncrement = 1;
        mPageIncrement = 10;
        mIsPressed = false;
        mDrawBlendedThumb = false;
        mThumbW = 32;
        mThumbH = 16;
        mThumbR = 10.0f;
        mPrecisionIdx = 2;
        mShowValPerc = false;
        mShowVal = true;
        mShowValNeedle = true;
        mUpsideDown = false;
        mShowTicks = true;
        mShowTickValue = true;
        mTickInterval = (maxVal-minVal) / 10;
        mSliderListener = 0;

        SetDisableOGLViewKeys(true);
        SetDisableOGLViewMouse(true);
    }

    SliderListener*   mSliderListener;
    void*             mSliderListenerData;
    int               mMinVal, mMaxVal, mVal;
    int               mIncrement;
    int               mPageIncrement;
    int               mPrecisionIdx;
    int               mThumbW;
    int               mThumbH;
    float             mThumbR;
    bool              mAutoDirection;
    bool              mHorizontal;
    bool              mIsPressed;
    bool              mShowValPerc;
    bool              mShowVal;
    bool              mShowValNeedle;
    bool              mUpsideDown;
    bool              mDrawBlendedThumb;
    bool              mShowTicks;
    bool              mShowTickValue;
    int               mTickInterval;
};

} // namespace OglGui
#endif

---