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

---

WindowTimeLine.h

Go to the documentation of this file.

//345678901234567890123456789012345678901234567890123456789012345678901234567890
/*
    WindowTimeLine :    A time-line that can display any OGL window connected
                        to a point in time.

    BRAINSTORM
    ==========
    Scrolling and sizing of the time-line will be based on the DocDimensions.h
    interface. In this way the time-line can externally be supplied with
    scrollbars and scrolling behaviour through the use of a DocScroller.h

    In a first version implement mouse-gesture based shifting/scaling of
    the time-line. Later also implement visual controls.

    Let the user add any OGL window inside the time-line connected
    to a certain point, or maybe to a certain time-span, in time.

    The time-line than becomes responsible for repositioning the
    added OGL windows based on the position of its connection to the
    time-line in time.

    Implement a WindowTimeLineListener interface to allow for outsiders
    to be involved with interaction.

    ADDENDUM 29-09-2009
    ===================
    Support to also allow OGLVIEW* objects to be connected to a point in time.

    Rationale:
    Using OglGui::WindowView2D objects to display OGLVIEW* objects on a
    WindowTimeLine is not well suited for displaying thousands of them,
    for reasons of speed and because of the difficulty to use
    image caching across separate OglGui::Window derived components.
    
    By also supporting the direct display of OGLVIEW* objects, while utilizing
    OglGui::OglImageCache, many thousands of them can be placed on a
    WindowTimeLine.
    
    Added to WindowTimeLine directly rather then in a derived class,
    because there is almost no overhead when the new functionality
    is not used. So if you do not add OGLVIEW* objects the overhead is
    neglectable.

    Author: Richard van Balen
*/
#ifndef OglGui_WindowTimeLine_h
#define OglGui_WindowTimeLine_h

#ifndef OglGui_ZoomShiftRuler_h
#include "OglGui/ZoomShiftRuler.h"
#endif

#ifndef OglGui_WindowTimeLineListener_h
#include "OglGui/WindowTimeLineListener.h"
#endif

#ifndef OglGui_GetOglImageByIdInterface_h
#include "OglGui/GetOglImageByIdInterface.h"
#endif

#ifndef OglGui_OglImageCache_h
#include "OglGui/OglImageCache.h"
#endif

namespace OglGui {

class WindowTimeLine :  public ZoomShiftRuler
{
public:
    WindowTimeLine(int x, int y, int w, int h,
                   long startTimeMs=0, long timeSpanMs=60000) :
        ZoomShiftRuler(x,y,w,h,startTimeMs,timeSpanMs)
    {
        Init(w,h,startTimeMs,timeSpanMs);
    }
    WindowTimeLine(Window* parent, int w, int h,
                   long startTimeMs=0, long timeSpanMs=60000) :
        ZoomShiftRuler(parent,w,h,startTimeMs,timeSpanMs)
    {
        Init(w,h,startTimeMs,timeSpanMs);
    }

    WindowTimeLine(Window* parent, int x, int y, int w, int h,
                   long startTimeMs=0, long timeSpanMs=60000) :
        ZoomShiftRuler(parent,x,y,w,h,startTimeMs,timeSpanMs)
    {
        Init(w,h,startTimeMs,timeSpanMs);
    }

    void
    SetListener(WindowTimeLineListener* listener, void* listenerData = 0)
    {
        mListener = listener;
        mWndTimeLineListenerData = listenerData;
    }

    void SetGetOglImageByIdInterface(GetOglImageByIdInterface* i)
    {
        mGetOglImageByIdI = i;
    }

    void SetOglImageCache(OglImageCache* oglImageCache)
    {
        mOglImageCache = oglImageCache;
    }

    OGLIMAGE* LoadViewImage(long long id)
    {
        if (!mOglImageCache || !mGetOglImageByIdI)
            return 0;

        OGLIMAGE* im = mOglImageCache->GetImage(id);

        if (!im && (im = mGetOglImageByIdI->GetOglImageById(id)))
            mOglImageCache->Add(im, id);
        return im;
    }

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

    // RvB: Not sure yet how to handle this.
    // If done as below the user must delete the added objects first
    // and then call ClearWindows() or ClearViews().
    // Not used yet, so placed in comment
    /*
    void ClearWindows()
    {
        mWindows.clear();
        mTimes.clear();
        mOffX.clear();
        mOffY.clear();
        mShowAtTickSpan.clear();
        mLineColor.clear();
    }

    void ClearViews()
    {
        mViews.clear();
        mViewTimes.clear();
        mViewOffX.clear();
        mViewOffY.clear();
        mViewShowAtTickSpan.clear();
        mViewLineColor.clear();
    }
    */

    int AddWindow(Window* wnd, long timeMs, int offX = 0, int offY=8)
    {
        mWindows.push_back(wnd);
        mTimes.push_back(timeMs);
        mOffX.push_back(offX);
        mOffY.push_back(offY);
        mShowAtTickSpan.push_back(-1);
        mLineColor.push_back(oglBLACK);
        wnd->SetAllowReposition(false);
        return mWindows.size()-1;
    }

    int AddImIdOGLVIEW(OGLVIEW* view, long timeMs, long long imId,
                   int offX = 0, int offY=8)
    {
        mViews.push_back(view);
        mViewTimes.push_back(timeMs);
        mViewImIds.push_back(imId);
        mViewOffX.push_back(offX);
        mViewOffY.push_back(offY);
        mViewShowAtTickSpan.push_back(-1);
        mViewLineColor.push_back(oglBLACK);
        return mViews.size()-1;
    }

    int AddOGLVIEW(OGLVIEW* view, long timeMs, int offX = 0, int offY=8)
    {
        return AddImIdOGLVIEW(view, timeMs, 0, offX, offY);
    }


    void SetDrawLines(bool mode=true)           { mDrawLineFlag = mode; }
    void SetLineStipple(short stipple)          { mLineStipple = stipple; }

    void SetViewDrawLines(bool mode=true)       { mViewDrawLineFlag = mode; }
    void SetViewLineStipple(short stipple)      { mViewLineStipple = stipple; }

    void  MaxVisibleImages(int m)               { mMaxVisibleImages = m; }
    int   MaxVisibleImages()                    { return mMaxVisibleImages; }

    void SetLineColor(Window* wnd, long col)
    {
        int idx = FindWindowIdx(wnd);
        
        if (idx == -1)
            return;
        mLineColor[idx] = col;
    }

    void SetLineColor(OGLVIEW* view, long col)
    {
        int idx = FindViewIdx(view);
        
        if (idx == -1)
            return;
        mViewLineColor[idx] = col;
    }

    void ShowAtTickSpanIdx(int idx, long ms)
    {
        if (idx < 0 || idx >= mShowAtTickSpan.size())
            return;
        mShowAtTickSpan[idx] = ms;
    }
    void ShowAtTickSpan(Window* wnd, long ms)
    {
        return ShowAtTickSpanIdx(FindWindowIdx(wnd), ms);
    }

    void ShowViewAtTickSpanIdx(int idx, long ms)
    {
        if (idx < 0 || idx >= mViewShowAtTickSpan.size())
            return;
        mViewShowAtTickSpan[idx] = ms;
    }
    void ShowAtTickSpan(OGLVIEW* view, long ms)
    {
        return ShowViewAtTickSpanIdx(FindViewIdx(view), ms);
    }

    static void
    GetTimeUnits(long timeInMs, int& hours, int& minutes, int& seconds, int& ms)
    {
        hours   = timeInMs / 3600000;
        minutes = (timeInMs % 3600000) / 60000;
        seconds = (timeInMs % 60000) / 1000;
        ms      = (timeInMs % 1000);
    }

    virtual void DisplayFunc()
    {
        LayoutViews();
        ZoomShiftRuler::DisplayFunc();
        LayoutWindows();
    }

protected:
    int FindWindowIdx(Window* wnd)
    {
        for (int i=0; i<mWindows.size(); i++)
            if (mWindows[i] == wnd)
                return i;
        return -1;
    }

    int FindViewIdx(OGLVIEW* view)
    {
        for (int i=0; i<mViews.size(); i++)
            if (mViews[i] == view)
                return i;
        return -1;
    }

    virtual void DrawTick(long timeMs,int x,int y,long tickSpanMs,int tickLen=5)
    {
        DrawLine(x, y-tickLen, x, y);

        int         h,m,s,ms;
        GetTimeUnits(timeMs,h,m,s,ms);

        std::string format = h ? "%02d:%02d:%02d" : "%02d:%02d";

        if (tickSpanMs <= 500 && tickSpanMs > 100){
            format += ".%d";
            ms /= 100;
        }
        if (tickSpanMs <= 100 && tickSpanMs > 10){
            format += ".%02d";
            ms /= 10;
        }
        if (tickSpanMs <= 10)
            format += ".%03d";

        char    charBuf[256];
        if (h) // hours
            sprintf(charBuf, format.c_str(), h, m, s, ms);
        else
            sprintf(charBuf, format.c_str(), m, s, ms);

        int     txtY = y - tickLen - 10;
        int     txtX = x - ((x<15) ? 2 : 15);

        if (!mTextShaded)
            oglSys.PosColPrintf(mOglWnd, txtX, txtY, mTextColor, charBuf);
        else
            oglSys.ShadowPrintf(mOglWnd, txtX, txtY, mTextShadowBg,
                                mTextShadowFg, charBuf);
    }

    virtual void LayoutWindows()
    {
        SetStipple(mLineStipple);
        for (int i=0; i<mWindows.size(); i++)
        {
            long showAtSpan = mShowAtTickSpan[i];
            SetSolidLineColor(mLineColor[i]);
            if (showAtSpan != -1 && mTickSpan > showAtSpan)
            {
                mWindows[i]->SetVisible(false);
                glPointSize(3);
                int x = Unit2Pixel(mTimes[i]);
                DrawPoint(x, mAxisY+mOffY[i]);
                if (mDrawLineFlag)
                    DrawLine(x, mAxisY, x, mAxisY+mOffY[i]);
                glPointSize(1);
            }
            else
            {
                int x, y, w, h;
                mWindows[i]->GetDimensions(x,y,w,h);
                mWindows[i]->SetVisible(true);
                x = Unit2Pixel(mTimes[i]);
                mWindows[i]->SetDimensions(x-w/2+mOffX[i],mAxisY+mOffY[i],w,h);
                if (mDrawLineFlag)
                    DrawLine(x, mAxisY, x+mOffX[i], mAxisY+mOffY[i]);
            }
        }
        SetStipple((short)oglSolid);
    }

    virtual void LayoutViews()
    {
        SetStipple(mViewLineStipple);
        int nrVisible = 0;
        for (int i=0; i<mViews.size(); i++)
        {
            int x = Unit2Pixel(mViewTimes[i]);

            SetSolidLineColor(mViewLineColor[i]);
            long showAtSpan = mViewShowAtTickSpan[i];
            if (showAtSpan != -1 && mTickSpan > showAtSpan)
                ViewIdxPointLine(i, x, x, true, mViewDrawLineFlag);
            else
            {
                int y, w, h, wW = W();
                int x2 = x + mViewOffX[i];
                OGLVIEW* view = mViews[i];
                viewSys.SetTags(view, visibleTag);
                viewSys.GetDimensions(view, 0, &y, &w, &h);
                viewSys.SetDimensions(view, x2-w/2, mAxisY+mViewOffY[i], w, h);

                if (mViewDrawLineFlag && (x>0 && x<wW && x2>0 && x2<wW))
                    DrawLine(x, mAxisY, x2, mAxisY+mViewOffY[i]);
                if (x2+w/2<0 || x2-w/2>wW || y+h<0 || y>H())
                {
                    HideView(view);
                    continue;
                }
                if (++nrVisible > mMaxVisibleImages)
                {
                    ViewIdxPointLine(i, x2, x, true, false);
                    continue;
                }
                if (view->im || (view->im=LoadViewImage(mViewImIds[i])))
                {
                    view->zoomX = view->h / (float) view->im->w;
                    view->zoomY = view->w / (float) view->im->h;
                }
            }
        }
        SetStipple((short)oglSolid);
    }

    void
    ViewIdxPointLine(int idx, int pX, int lX, bool drawPoint, bool drawLine)
    {
        int w = W();
        if (drawPoint)
        {
            HideView(mViews[idx]);
            if (pX > 0 && pX < w)
            {
                glPointSize(3);
                DrawPoint(pX, mAxisY+mViewOffY[idx]);
                glPointSize(1);
            }
        }
        if (drawLine && ((lX > 0 && lX < w) || (pX >0 && pX < w)))
            DrawLine(lX, mAxisY, pX, mAxisY+mViewOffY[idx]);
    }


    void HideView(OGLVIEW* view)
    {
        viewSys.ClearTags(view, visibleTag);
        if (mOglImageCache)
            viewSys.SetImage(view, 0);
    }

    std::vector<Window*>    mWindows;
    std::vector<long>       mTimes;
    std::vector<long>       mShowAtTickSpan;
    std::vector<int>        mOffX;
    std::vector<int>        mOffY;
    std::vector<long>       mLineColor;
    short                   mLineStipple;
    bool                    mDrawLineFlag;

    // RvB: 29-09-2009 added these for OGLVIEW* support
    std::vector<OGLVIEW*>   mViews;
    std::vector<long>       mViewTimes;
    std::vector<long long>  mViewImIds;
    std::vector<long>       mViewShowAtTickSpan;
    std::vector<int>        mViewOffX;
    std::vector<int>        mViewOffY;
    std::vector<long>       mViewLineColor;
    short                   mViewLineStipple;
    bool                    mViewDrawLineFlag;

    int                         mMaxVisibleImages;
    OglImageCache*              mOglImageCache;
    GetOglImageByIdInterface*   mGetOglImageByIdI;


private:
    void Init(int w, int h, long startTime, long timeSpan)
    {
        SetDocDimensions(0,0,w,h);
        SetRange(startTime,timeSpan);
        mListener = 0;
        mDrawLineFlag = mViewDrawLineFlag = true;
        mLineStipple = mViewLineStipple = (short) oglSolid;
        mAxisY = 20;
        SetTextShadowColors(oglDARKGREY, oglLIGHTGREY);

        mMaxVisibleImages = 200;
        mOglImageCache    = 0;
        mGetOglImageByIdI = 0;
    }

    WindowTimeLineListener* mListener;
    void*                   mWndTimeLineListenerData;
};
} // namespace OglGui
#endif

---