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

---

VideoTimeLine.h

Go to the documentation of this file.

//345678901234567890123456789012345678901234567890123456789012345678901234567890
// VideoTimeLine: Combining a VideoPlayer with a versatile TimeLine.
// Author: Richard van Balen
#ifndef Impala_Visualization_VideoTimeLine_h
#define Impala_Visualization_VideoTimeLine_h

#include "Core/Stream/RgbDataSrcFactory.h"

#include "OglGui/TitledWindow.h"
#include "OglGui/WindowDocScroller.h"

#include "Visualization/VideoPlayerWithButtons.h"
#include "Visualization/TimeLineViewStrip.h"


namespace Impala {
namespace Visualization {

//using namespace OglGui;

class VideoTimeLine :   public OglGui::Window,
                        public OglGui::WindowTimeLineListener,
                        public VideoPlayerListener
{
public:
    typedef OglGui::Window                           Window;
    typedef OglGui::StaticText                       StaticText;
    typedef OglGui::TitledWindow                     TitledWindow;
    typedef OglGui::WindowDocScroller                WindowDocScroller;
    typedef OglGui::WindowTimeLine                   WindowTimeLine;
    typedef OglGui::WindowTimeLineListener           WindowTimeLineListener;
    typedef Impala::Core::Stream::RgbDataSrcFactory  RgbDataSrcFactory;
    typedef Impala::Core::Stream::RgbDataSrc         RgbDataSrc;

    VideoTimeLine(int x, int y, int w, int h) :
        Window(x, y, w, h)
    {
        Init(w,h);
    }

    VideoTimeLine(Window* parent, int w, int h) :
        Window(parent, w, h)
    {
        Init(w,h);
    }

    VideoTimeLine(Window* parent,int x,int y,int w,int h):
        Window(parent, x, y, w, h)
    {
        Init(w,h);
    }

    void OpenVideo(String videoName, strconst videoType)
    {
        RgbDataSrc* videoRgb = VideoPlayer::Construct(videoName, videoType);
        RgbDataSrc* stripRgb = VideoPlayer::Construct(videoName, videoType);
        OpenVideo(videoName, videoRgb, stripRgb);
    }

    void
    OpenVideo(String videoName, RgbDataSrc* vidRgb, RgbDataSrc* stripRgb)
    {
        ShowTitle(videoName);
        mVideoPlayer->OpenVideo(vidRgb);
        mTLineViewStrip->ViewStripRgbDataSrc(stripRgb);
        if (vidRgb && stripRgb)
            HandleNewVideo();
    }

    virtual void HandleNewVideo()
    {
        mVideoPlayer->Reset();
        HandleFrameSettings();
    }

    virtual void HandleFrameSettings()
    {
        int nFrames = mVideoPlayer->LastFrame();
        int imW = mVideoPlayer->DataSrc()->FrameWidth();
        if (mTLineViewStrip->ViewStripRgbSrc())
            imW = mTLineViewStrip->ViewStripRgbSrc()->FrameWidth();
        mTLineViewStrip->Current(0);
        mTLineViewStrip->SetSpan(40*nFrames);
        mTLineViewStrip->SetMinMaxDocWidth(160, nFrames*imW);
        mTLineViewStrip->DocW(nFrames*4);

        mTimeLineRuler->SetSpan(40*nFrames);
    }

    void ShowTitle(strconst videoName)
    {
        if (!videoName.empty())
        {
            std::string name = FileNameTail(videoName);
            mTitledVideoPlayer->TitleText()->SetText(name);
        }
    }


    virtual void CurrentChanged(WindowTimeLine *src, long nVal, void* userData)
    {
        VideoPlayer* vP = (VideoPlayer*) userData;
        int nFrame = (int) floor((nVal / 40.)+0.5); // Finds nearest frame
        if (nFrame != vP->FrameNr())
            vP->GotoFrame(nFrame);
        else
        {   // Needed to only allow needle at center of frames
            mTLineViewStrip->Current(nFrame*40);
            mTimeLineRuler->Current(nFrame*40);
        }
    }

    virtual void
    OnNewFrame(VideoPlayer *src, int frameNr, void* userData)
    {
        mTimeLineRuler->Current(frameNr*40);
        mTLineViewStrip->Current(frameNr*40);
        HandleVisibility(mTLineViewStrip);
    }

    void HandleVisibility(TimeLineViewStrip* tLineViewStrip)
    {
        if (!tLineViewStrip->IsDragging() &&
            (mCenterNeedle || (mVideoPlayer->Playing() && mCenterNeedleOnPlay)))
           tLineViewStrip->ShowCurrentAt(tLineViewStrip->W()/2);
        else
            tLineViewStrip->MakeCurrentVisible();
    }


    // Setter / Getter funtions
    void CenterNeedleOnPlay(bool mode)      { mCenterNeedleOnPlay = mode; }
    bool CenterNeedleOnPlay()               { return mCenterNeedleOnPlay; }

    void CenterNeedle(bool mode)            { mCenterNeedle = mode; }
    bool CenterNeedle()                     { return mCenterNeedle; }


    // Functions to obtain handles to our objects
    TitledWindow*       TitledVideoPlayer()       {return mTitledVideoPlayer;}
    TitledWindow*       TitledTimeLine()          {return mTitledTimeLine;}
    TimeLineViewStrip*  TLineViewStrip()          {return mTLineViewStrip;}
    VideoPlayer*        VidPlayer()               {return mVideoPlayer;}
    WindowTimeLine*     TimeLineRuler()           {return mTimeLineRuler;}
    WindowDocScroller*  ViewStripScroller()       {return mViewStripScroller;}
    StaticText*         FrameNrTxt()              {return mFrameNrTxt;}

    VideoPlayerWithButtons* VideoPlayerWithBtns() {return mVideoPlayerWithBtns;}

    // Overruled standard functions
    virtual void DisplayFunc()
    {
        mTimeLineRuler->DocX(5);
        mTimeLineRuler->DocW(mTimeLineRuler->W()-10);
        if (mCenterNeedle)
            HandleVisibility(mTLineViewStrip);
        Window::DisplayFunc();
    }

private:
    void Init(int w, int h)
    {
        int vpH   = 288 + 32 + 8; // videoH + Buttons + margin

        mTitledVideoPlayer = new TitledWindow(this,4,4,352+8,vpH+32,"");
        Window* pane  = mTitledVideoPlayer->ContentPane();
        int     paneW = pane->W();
        int     paneH = pane->H();

        mVideoPlayerWithBtns = new VideoPlayerWithButtons(pane,0,0,paneW,paneH);
        mVideoPlayerWithBtns->ConnectTo(pane);
        mVideoPlayer = mVideoPlayerWithBtns->Player();
        mVideoPlayer->NormalSpeed(true);

        Window* videoTitle = mTitledVideoPlayer->TitleText();
        mFrameNrTxt = new StaticText(videoTitle,paneW-90,2,60,20, "");
        mFrameNrTxt->SetAlign(oglLeftAlign,oglCenterAlign);
        mFrameNrTxt->ConnectTo(videoTitle,OglGui::TORIGHT);

        mTitledTimeLine = new TitledWindow(this,368,4,w-372,vpH+32,"TimeLine");
        pane = mTitledTimeLine->ContentPane();
        paneW = pane->W();
        paneH = pane->H();

        mTimeLineRuler = new WindowTimeLine(pane,0,paneH-32,paneW,30);
        mTimeLineRuler->ConnectTo(pane,OglGui::TOLEFTRIGHT | OglGui::TOTOP);
        mTimeLineRuler->SetListener(this, (void*) mVideoPlayer);
        mTimeLineRuler->SetBorderType(BEV_ETCHED);
        mTimeLineRuler->SetBorderFillShaded(2);
        mTimeLineRuler->ShowNeedle(true);
        mTimeLineRuler->SetNeedleUpDownHeight(100,100);
        mTimeLineRuler->SetNeedleColor(oglRED);

        mViewStripScroller = new WindowDocScroller(pane,0,0,paneW,paneH-34,1);
        mViewStripScroller->ConnectTo(pane);
        mTLineViewStrip =
            new TimeLineViewStrip(mViewStripScroller,0,16,paneW,paneH-50,600);
        mViewStripScroller->SetDocWindow(mTLineViewStrip,mTLineViewStrip,true);

        mTLineViewStrip->SetBorderType(-1);
        mTLineViewStrip->SetListener(this, (void *) mVideoPlayer);
        mTLineViewStrip->CurrentViewOnTop(2);
        mVideoPlayer->SetVideoPlayerListener(this,0);

        mCenterNeedle = true;
        mCenterNeedleOnPlay = true;
    }

    TitledWindow*                       mTitledVideoPlayer;
    TitledWindow*                       mTitledTimeLine;
    TimeLineViewStrip*                  mTLineViewStrip;
    VideoPlayer*                        mVideoPlayer;
    VideoPlayerWithButtons*             mVideoPlayerWithBtns;
    WindowTimeLine*                     mTimeLineRuler;
    WindowDocScroller*                  mViewStripScroller;
    StaticText*                         mFrameNrTxt;

    bool                                mCenterNeedleOnPlay;
    bool                                mCenterNeedle;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(VideoTimeLine, Visualization);

} // Namespace Visualization
} // Namespace Impala
#endif

---