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

---

ZoomShiftRuler.h

Go to the documentation of this file.

//345678901234567890123456789012345678901234567890123456789012345678901234567890
// ZoomShiftRuler:
//  - Ruler based on the abtract concept of integer units.
//  - Class specializations can give meaning to the units.
//      Example of such a specialization is the WindowTimeLine class,
//      which defines unit to be 1 ms, and handles the drawing of ticks
//      showing the time.
//  - ZoomShiftRuler allows the user to shift the ruler horizontally by
//    dragging the mouse while holding the SHIFT key down.
//  - ZoomShiftRuler allows the user to zoom in on the ruler by
//    dragging the mouse while holding the CONTROL key down.
//  - ZoomShiftRuler maintains the notion of a current value, which the
//    user can change with the mouse. This feature can be used for example
//    to steer a parameter of another component, like the frame position
//    of a VideoPlayer.
//  - ZoomShiftRuler is based on the DocDimensions interface, allowing
//    other components, like the DocScroller, to scroll and zoom it.
//  - ZoomshiftRuler uses the RepeatTimer interface to propagate scrolling
//    when the user holds down the mouse before the first mPropagateMargin pixels, or after
//    the last mPropagateMargin pixels of its window.
//  - In its basic form the ZoomShiftRuler draws simple ticks without any text.
//    It does, however, support the notion of drawing text in a single
//    color or shadowed. Other classes that do draw text at the ticks
//    are supposed to honor the text settings maintained in this class.
//
//  ToDo:   - Make it optional whether the user can shift and/or zoom.
//          - Optional buttons indicating what happens when the mouse
//            is used without modifier keys, to allow use without
//            knowledge of the CONTROL and SHIFT modifiers.
//
// Author: Richard van Balen
#ifndef OglGui_ZoomShiftRuler_h
#define OglGui_ZoomShiftRuler_h

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

#ifndef OglGui_DocDimensions_h
#include "OglGui/DocDimensions.h"
#endif

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

#ifndef OglGui_ZoomShiftRulerListener_h
#include "OglGui/ZoomShiftRulerListener.h"
#endif

namespace OglGui
{

class ZoomShiftRuler :  public Window,
                        public DocDimensions,
                        public RepeatTimer
{
public:
    ZoomShiftRuler(int x, int y, int w, int h, long start=0, long span=10000) :
        Window(x,y,w,h)
    {
        Init(w,h,start,span);
    }

    ZoomShiftRuler(Window* parent, int w, int h, long start=0, long span=10000) :
        Window(parent,w,h)
    {
        Init(w,h,start,span);
    }

    ZoomShiftRuler(Window* parent, int x, int y, int w, int h,
                   long start=0, long span=10000) :
        Window(parent,x,y,w,h)
    {
        Init(w,h,start,span);
    }

    void
    SetListener(ZoomShiftRulerListener* listener, void* listenerData = 0)
    {
        mListener = listener;
        mZoomShiftListenerData = listenerData;
    }

    virtual void PublishCurrentChanged()
    {
        if (mListener)
            mListener->CurrentChanged(this, mCurrent, mZoomShiftListenerData);
    }

    void SetMinMaxDocWidth(long minW=-1, long maxW=-1)
    {
        mMinDocWidth = (minW == -1) ? 20 : minW;
        mMaxDocWidth = (maxW == -1) ? (1<<30) : maxW;
        mDocW = (mDocW < mMinDocWidth) ? mMinDocWidth : mDocW;
        mDocW = (mDocW > mMaxDocWidth) ? mMaxDocWidth : mDocW;
    }
    void GetMinMaxDocWidth(long& minW, long& maxW)
    {
        minW = mMinDocWidth;
        maxW = mMaxDocWidth;
    }

    void  SetNeedleColor(ULONG col) { mNeedleColor = col; }
    ULONG GetNeedleColor()          { return mNeedleColor; }

    void  ShowNeedle(bool show)     { mShowNeedle = show; }
    bool  ShowNeedle()              { return mShowNeedle; }

    void  SetSpan(long span)        { mSpan = span; }
    long  GetSpan()                 { return mSpan; }

    void  SetStart(long start)      { mStart = start; }
    long  GetStart()                { return mStart; }

    bool  IsDragging()              { return mDragging; }

    void  SetAxisY(int y)           { mAxisY = y; }
    int   GetAxisY()                { return mAxisY; }

    void  SetTextColor(ULONG col)   { mTextColor = col; }
    ULONG GetTextColor()            { return mTextColor; }

    void  SetTextShaded(bool mode)  { mTextShaded = mode; }
    bool  GetTextShaded()           { return mTextShaded; }

    void SetTextShadowColors(ULONG shadBg, ULONG shadFg)
    {
        mTextShadowFg = shadFg;
        mTextShadowBg = shadBg;
    }
    void GetTextShadowColors(ULONG& shadBg, ULONG shadFg)
    {
        shadFg = mTextShadowFg;
        shadBg = mTextShadowBg;
    }

    void SetNeedleUpDownHeight(int upH, int downH)
    {
        mNeedleUpH   = upH;
        mNeedleDownH = downH;
    }
    void GetNeedleUpDownHeight(int& upH, int &downH)
    {
        upH = mNeedleUpH;
        downH = mNeedleDownH;
    }

    void SetRange(long start, long span)
    {
        mStart = start;
        mSpan = span;
    }
    void GetRange(long& start, long& span)
    {
        start = mStart;
        span = mSpan;
    }

    void Current(long cur)
    {
        long oldCur = mCurrent;

        if (cur > mStart + mSpan)
            cur = mStart + mSpan;
        if (cur < mStart)
            cur = mStart;
        if ((mCurrent = cur) != oldCur)
            PublishCurrentChanged();
    }
    long Current()
    {
        return mCurrent;
    }

    void ShowCurrentAt(long x)
    {
        int presX = Unit2Pixel(mCurrent);
        mDocX += x-presX;
    }

    void MakeCurrentVisible()
    {
        int presX = Unit2Pixel(mCurrent);
        if (presX < mPropagateMargin)
            ShowCurrentAt(mPropagateMargin);
        if (presX > W()-mPropagateMargin)
            ShowCurrentAt(W()-mPropagateMargin);
    }

    long Pixel2Unit(int pX)
    {
        return mStart + ((pX-mDocX)/(double)mDocW)*mSpan;
    }

    int Unit2Pixel(long u)
    {
        u -= mStart;
        return mDocX + (u/(double)mSpan)*mDocW;
    }

    virtual void DrawNeedle()
    {
        int curX = Unit2Pixel(mCurrent);
        SetSolidLineColor(mNeedleColor);
        DrawLine(curX,mAxisY-mNeedleDownH,curX,mAxisY+mNeedleUpH);
    }

    virtual void DisplayFunc()
    {
        Window::DisplayFunc();

        if (mPropagateScrolling && RepeatTime())
        {
            if (!(mMouseState & (oglShift | oglControl)))
            {
                int lastX = mLastX;
                mLastX += (mLastX < mPropagateMargin) ? -40 : 40;
//static int cnt = 0;
//printf("propMouse %d\n", cnt++);
                MouseFunc(oglMouseMove, oglLeftButton, mMouseState, lastX, 10);
//printf("propMouse done %d\n", --cnt);
            }
        }

        OGC myOGC;
        OGCSave(&myOGC);

        SetStipple((short)oglSolid);
        SetSolidLineColor(mForeGroundColor);
        DrawLine(mDocX, mAxisY, mDocX+mDocW, mAxisY);
        DrawTicks();

        if (mShowNeedle)
            DrawNeedle();

        OGCRestore(&myOGC);
    }

    void SetDocXClamped(int x)
    {
        int w = W();
        if (x > w/2)
            x = w/2;
        if (x+mDocW < w/2)
            x = -mDocW + w/2;
        mDocX = x;
    }

    void CheckPropagateScrolling(int x)
    {
        mPropagateScrolling = (x > W()-mPropagateMargin || x < mPropagateMargin);
        oglSys.SetAlwaysDraw(mOglWnd,mPropagateScrolling);
    }

    virtual void MouseFunc(int msg, int btn, int state, int x, int y)
    {
        Window::MouseFunc(msg,btn,state,x,y);

        if (state & oglAlt) return;

        bool shift   = (state & oglShift) != 0;
        bool control = (state & oglControl) != 0;

        mMouseState = state;

        if ((msg==oglMouseDown && btn==oglLeftButton) || (!mScaling && control)) 
        {
            StartRepeatTime();
            CheckPropagateScrolling(x);
            mClickedUnit = Pixel2Unit(x);
            if (!(shift||control))
                Current(mClickedUnit);
            mLastX = mClickedX = x;
            mDragging = true;
            if (control)
                mScaling = true;
        }

        if (mScaling && !control)
            mScaling = false;

        if (msg == oglMouseUp)
        {
            mPropagateScrolling = mDragging = mScaling = false;
            oglSys.SetAlwaysDraw(mOglWnd, 0);
        }
    
        if (msg == oglMouseMove && mDragging)
        {
            CheckPropagateScrolling(x);
            int dx = x - mLastX;
            if (mScaling)
            {
                int oldDocW = mDocW;
                mDocW *= (1 + .02*dx);
                if (oldDocW > 0 && mDocW<0) // Overflow
                    mDocW = oldDocW;

                if (mDocW < mMinDocWidth)
                    mDocW = mMinDocWidth;
                if (mDocW > mMaxDocWidth)
                    mDocW = mMaxDocWidth;

                long clickedPixelNow = Unit2Pixel(mClickedUnit);
                mDocX += mLastX - clickedPixelNow;
                mDocX -= mLastX - mClickedX;
            }
            else if (shift)
                SetDocXClamped(mDocX+dx);
            else
                Current(Pixel2Unit(x));

            mLastX = x;
        }
    }

protected:
    virtual void DrawTick(long val,int x,int y,long tickSpan,int tickLen=6)
    {
        DrawLine(x, y-tickLen, x, y);
    }

    virtual void DrawMicroTicks(long x, long nextX)
    {
        long    minX = Unit2Pixel(mStart);
        long    maxX = Unit2Pixel(mStart+mSpan);
        int     cnt  = 0;

        if (nextX-x <= 0)
            nextX = x + 1;

        for (double j=x; j<nextX; j+= (nextX-x)/10.)
        {
            if (j>minX && j<maxX)
                DrawLine(j,mAxisY-((++cnt%6)?2:4),j,mAxisY);
        }
    }

    virtual void DrawTicks()
    {
        int startUnit = Pixel2Unit(0);
        int endUnit   = Pixel2Unit(W());

        if (startUnit < mStart)
            startUnit = mStart;

        int     pixRange = Unit2Pixel(endUnit) - Unit2Pixel(startUnit);
        double  range    = endUnit - startUnit;
        double  order    = floor(log10(range));
        double  tmpSpan  = mTickSpan = pow(10.,order);
        double  quanta[9]= {.5,.2,.1, .05,.02,.01, .005,.002,.001};
        //Alternative:
        //double  quanta[9]= {.5,.25,.1, .025,.02,.01, .0025,.002,.001};

        int     i = 0;
        while (i<9 && range/tmpSpan < (pixRange/140))
            tmpSpan = mTickSpan * quanta[i++];
        mTickSpan = tmpSpan;
        int firstTick = ceil(startUnit / mTickSpan);
        int tickCount = floor(endUnit / mTickSpan) - firstTick + 1;

        SetStipple((short)oglSolid);
        DrawTick(startUnit, Unit2Pixel(startUnit), mAxisY, mTickSpan);

        int startI = Unit2Pixel(mStart)<0 ? -1 : 0;
        for (i=startI; i<tickCount; i++)
        {
            long val     = (i+firstTick) * mTickSpan;
            long x       = Unit2Pixel(val);
            long nextX   = Unit2Pixel(val+mTickSpan);

            if (val > mStart+mSpan || x>W())
                break;
            DrawMicroTicks(x, nextX);
            DrawTick(val, x, mAxisY, mTickSpan);
        }
    }

protected:
    int                     mAxisY;

    long                    mStart;   
    long                    mSpan;    
    double                  mTickSpan;

    long                    mCurrent;
    bool                    mShowNeedle;
    ULONG                   mNeedleColor;
    int                     mNeedleUpH;
    int                     mNeedleDownH;

    bool                    mDragging;
    bool                    mScaling;

    long                    mMinDocWidth;
    long                    mMaxDocWidth;

    int                     mMouseState;
    int                     mPropagateMargin;
    bool                    mPropagateScrolling;
    long                    mClickedUnit;
    int                     mClickedX;
    int                     mLastX;

    bool                    mTextShaded;
    ULONG                   mTextShadowFg;
    ULONG                   mTextShadowBg;
    ULONG                   mTextColor;

private:
    void Init(int w, int h, long start, long span)
    {
        mListener = 0;
        SetDocDimensions(0,0,w,h);
        SetMinMaxDocWidth(-1,-1);
        SetRange(start,span);
        mDragging = mScaling = false;
        mCurrent = start;
        mShowNeedle = true;
        mNeedleColor = oglRED;
        mNeedleUpH = mNeedleDownH = 8;
        mTextShadowFg = oglDARKGREY;
        mTextShadowBg = oglWHITE;
        mTextColor = oglBLACK;
        mTextShaded = true;
        mAxisY = 20;
        SetRepeatDelays(40,10);
        mPropagateMargin = 50;
        mPropagateScrolling = false;
        SetDisableOGLViewKeys(true);
        SetDisableOGLViewMouse(true);
    }

    ZoomShiftRulerListener* mListener;
    void*                   mZoomShiftListenerData;
};
} // namespace OglGui

#endif

---