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

---

AppControlDoc.h

Go to the documentation of this file.

#ifndef Impala_Visualization_AppControlDoc_h
#define Impala_Visualization_AppControlDoc_h

#include <sstream>
#include <vector>
#include "Basis/Timer.h"
#include "Visualization/AppControl.h"
#include "Visualization/KeyBindingsMap.h"
#include "OglGui/Sys.h"
#include "Core/Database/DataDocument.h"
#include "Core/Database/DataDocumentListener.h"

namespace Impala
{
namespace Visualization
{


class AppControlDoc : public AppControl
{
public:
    typedef Core::Database::DataDocument DataDocument;
    typedef Core::Database::DataDocumentListener DataDocumentListener;
    typedef Core::Database::DocLevel DocLevel;

    AppControlDoc(int id, DataDocument* doc) : AppControl(id, false), mTimer(1)
    {
        mDoc = doc;
        mDone = false;
        mDoContinuous = false;
        mNrItemsDone = 0;

        //CmdOptions& options = CmdOptions::GetInstance();
        //String videoSet = options.GetString("videoSet", "");

        InitKeyBinding("dataFirstDir","ctrl#home");
        InitKeyBinding("dataNextDir", "ctrl#pagedown");
        InitKeyBinding("dataPrevDir", "ctrl#pageup");
        InitKeyBinding("dataNextFile", "ctrl#down");
        InitKeyBinding("dataPrevFile", "ctrl#up");
        InitKeyBinding("dataNextShot", "ctrl#right");
        InitKeyBinding("dataPrevShot", "ctrl#left");
        InitKeyBinding("dataAddBookMark", "b");
        InitKeyBinding("dataDelBookMark", "B");
        InitKeyBinding("dataContinuous", "c");
        InitKeyBinding("dataNotContinuous", "C");
    }

    void
    AddDocListener(DataDocumentListener* listener)
    {
        ILOG_DEBUG("(" << GetControlId() << ")::AddDocListener");
        mDocListeners.push_back(listener);
    }

    void InitKeyBinding(String keyStr, String dfltStr)
    {
        mKeyBindings[keyStr] = GetKeyBinding(keyStr, dfltStr);
    }

    void
    SetDoContinuous(bool flag)
    {
        mDoContinuous = flag;
        if (mDoContinuous)
            IpsReset();
    }

    bool
    GetDoContinuous()
    {
        return mDoContinuous;
    }

    void
    IpsReset()
    {
        mTimer.Start();
        mNrItemsDone = 0;
    }

    std::string
    GetIpsString()
    {
        double timeVal = mTimer.SplitTime();
        double ips = (double) mNrItemsDone / timeVal;
        std::ostringstream ipsStream;
        ipsStream << mNrItemsDone << " items in " << timeVal
                  << " sec = " << ips << " ips" << std::ends;
        return ipsStream.str();
    }

    // in general: doRightOnBookmarks is used with video only
    void
    VisitAll(bool doRightOnBookmarks, int startDir, int numberDir)
    {
        if (mDoc->HasBookmarks())
        {
            DocLevel level;
            do
            {
                level = mDoc->CursorNextBookmark();
                AllHandleNewCursor(level, true);
                if (doRightOnBookmarks && (level != Core::Database::LEVEL_NONE))
                {
                    DocLevel level2;
                    do
                    {
                        level2 = mDoc->CursorNextShot();
                        AllHandleNewCursor(level2, false);
                    }
                    while (level2 != Core::Database::LEVEL_NONE);
                }
                AllHandleDoneCursor(level);
            }
            while (level != Core::Database::LEVEL_NONE);
        }
        else
        {
            if (numberDir == -1)
                numberDir = mDoc->GetDataSet()->NrDirs();
            DocLevel level1 = mDoc->CursorToDir(startDir);
            AllHandleNewCursor(level1, false);
            int nr = 0;
            while ((level1 != Core::Database::LEVEL_NONE) && (nr < numberDir))
            {
                DocLevel level2;
                do
                {
                    level2 = mDoc->CursorNextShot();
                    AllHandleNewCursor(level2, false);
                }
                while (level2 != Core::Database::LEVEL_NONE);
                AllHandleDoneCursor(level1);
                nr++;
                if (nr < numberDir)
                {
                    level1 = mDoc->CursorNextDir();
                    AllHandleNewCursor(level1, false);
                }
            }
        }
        AllHandleDoneVisit();
    }

    // specialization of base class

    virtual void
    ComputeCycle(double elapsedTime)
    {
        /*
        if (elapsedTime > mLastTime + mInterval)
        {
            mLastTime = elapsedTime;
            AllHandleCycleDoc();
        }
        */
        if (!GetDoContinuous())
            return;
        AllHandleNewCursor(mDoc->CursorNextShot(), false);
        AllHandleCycleDoc();
        mNrItemsDone++;
    }

    virtual void
    HandleActivate()
    {
        ILOG_DEBUG("(" << GetControlId() << ")::HandleActivate()");
        for (int i=0 ; i<mDocListeners.size() ; i++)
        {
            mDocListeners[i]->HandleNewFile();
            mDocListeners[i]->HandleNewBookmarked();
        }
    }

    bool CheckBinding(String keyStr, int c, int state)
    {
        return CheckKeyBinding(mKeyBindings,keyStr,c,state);
    }

    virtual void
    KeyEvent(OglGui::Window* src, int c, int state)
    {
        ILOG_DEBUG("(" << GetControlId() << ")::KeyEvent: " << c);
        //ILOG_INFO("(" << GetControlId() << ")::KeyEvent: " << c);
        if (c == 'Q')
        {
            ILOG_INFO("Instant exit button pressed.");
            mDone = true;
        }
        if (CheckBinding("dataFirstDir",c,state))
            AllHandleNewCursor(mDoc->CursorToDir(0), false);
        if (CheckBinding("dataNextDir",c,state))
            AllHandleNewCursor(mDoc->CursorNextDir(), false);
        else if (CheckBinding("dataPrevDir",c,state))
            AllHandleNewCursor(mDoc->CursorPrevDir(), false);
        else if (CheckBinding("dataNextFile",c,state))
            AllHandleNewCursor(mDoc->CursorNextFile(), false);
        else if (CheckBinding("dataPrevFile",c,state))
            AllHandleNewCursor(mDoc->CursorPrevFile(), false);
        else if (CheckBinding("dataNextShot",c,state))
            AllHandleNewCursor(mDoc->CursorNextShot(), false);
        else if (CheckBinding("dataPrevShot",c,state))
            AllHandleNewCursor(mDoc->CursorPrevShot(), false);


        // from here on, propagation of event is responsibility of callee
        else if (CheckBinding("dataAddBookMark",c,state))
            AddCursorToBookmarked();
        else if (CheckBinding("dataDelBookMark",c,state))
            RemoveCursorFromBookmarked();
        else if (CheckBinding("dataContinuous",c,state))
            SetDoContinuous(true);
        else if (CheckBinding("dataNotContinuous",c,state))
            SetDoContinuous(false);

        for (int i=0 ; i<mDocListeners.size() ; i++)
            mDocListeners[i]->HandleNewKey(c, state);
    }

    virtual bool
    Done()
    {
        return mDone;
    }

    // interface to derived classes

    virtual void
    AddCursorToBookmarked()
    {
    }

    virtual void
    RemoveCursorFromBookmarked()
    {
    }

// RvB commented next line, making methods public
// protected:

    void
    AllHandleNewCursor(DocLevel docLevel, bool doBookmark)
    {
        if (docLevel == 0)
            return;
        for (int i=0 ; i<mDocListeners.size() ; i++)
        {
            if (doBookmark)
                mDocListeners[i]->HandleCursorBookmarked();
            switch (docLevel) {
            case Core::Database::LEVEL_DIR:
                mDocListeners[i]->HandleNewDir();
                break;
            case Core::Database::LEVEL_FILE:
                mDocListeners[i]->HandleNewFile();
                break;
            case Core::Database::LEVEL_SHOT:
                mDocListeners[i]->HandleNewShot();
                break;
            case Core::Database::LEVEL_FRAME:
                mDocListeners[i]->HandleNewFrame();
                break;
            }
        }
    }

    void
    AllHandleDoneCursor(DocLevel docLevel)
    {
        if (docLevel == 0)
            return;
        for (int i=0 ; i<mDocListeners.size() ; i++)
        {
            switch (docLevel) {
            case Core::Database::LEVEL_DIR:
                mDocListeners[i]->HandleDoneDir();
                break;
            case Core::Database::LEVEL_FILE:
                mDocListeners[i]->HandleDoneFile();
                break;
            }
        }
    }

    void
    AllHandleDoneVisit()
    {
        for (int i=0 ; i<mDocListeners.size() ; i++)
            mDocListeners[i]->HandleDoneVisit();
    }

    void
    AllHandleBookmarkEvent(int shotid, bool selected)
    {
        for (int i=0 ; i<mDocListeners.size() ; i++)
            mDocListeners[i]->HandleBookmarkEvent(shotid, selected);
    }

    void
    AllHandleNewBookmarked()
    {
        for (int i=0 ; i<mDocListeners.size() ; i++)
            mDocListeners[i]->HandleNewBookmarked();
    }

    void
    AllHandleAddedBookmark()
    {
        for (int i=0 ; i<mDocListeners.size() ; i++)
            mDocListeners[i]->HandleAddedBookmark();
    }

    void
    AllHandleRemovedBookmark()
    {
        for (int i=0 ; i<mDocListeners.size() ; i++)
            mDocListeners[i]->HandleRemovedBookmark();
    }

    void
    AllHandleCycleDoc()
    {
        for (int i=0 ; i<mDocListeners.size() ; i++)
            mDocListeners[i]->HandleCycleDoc();
    }
protected:
    KeyBindingsMap                     mKeyBindings;

// RvB: Commented next line, making the members protected
//private:

    DataDocument*                      mDoc;
    std::vector<DataDocumentListener*> mDocListeners;

    Timer mTimer;
    bool  mDone;
    bool  mDoContinuous;
    int   mNrItemsDone;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(AppControlDoc, Visualization);

} // namespace Visualization
} // namespace Impala

#endif

---