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

---

AppControlDossier.h

Go to the documentation of this file.

#ifndef Impala_Application_IDash_AppControlDossier_h
#define Impala_Application_IDash_AppControlDossier_h

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

namespace Impala
{
namespace Application
{
namespace IDash
{

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

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

    void
    AddDocListener(DataDocumentListener* listener)
    {
        Logger::Debug() << "AppControlDoc(" << GetControlId() << ")::AddDocListener" << std::endl;
        mDocListeners.push_back(listener);
    }

    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->CursorNextFile();
                        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->CursorNextFile();
                    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->CursorNextFile(), false);
        AllHandleCycleDoc();
        mNrItemsDone++;
    }

    virtual void
    HandleActivate()
    {
        Logger::Debug() << "AppControlDoc(" << GetControlId() << ")::HandleActivate()" << std::endl;

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

    virtual void
    KeyEvent(OglGui::Window* src, int c, int state)
    {
        if (c == 'Q')
            mDone = true;
        if (c == 'c')
            SetDoContinuous(true);
        if (c == 'C')
            SetDoContinuous(false);

        if (c == oglHOME)
            AllHandleNewCursor(mDoc->CursorToDir(0), false);
        if (c == oglPAGEUP)
            AllHandleNewCursor(mDoc->CursorPrevDir(), false);
        if (c == oglPAGEDOWN)
            AllHandleNewCursor(mDoc->CursorNextDir(), false);
        if (c == oglLEFT)
            AllHandleNewCursor(mDoc->CursorPrevFile(), false);
        if (c == oglRIGHT)
            AllHandleNewCursor(mDoc->CursorNextFile(), false);
        if (c == oglUP)
            AllHandleNewCursor(mDoc->CursorPrevShot(), false);
        if (c == oglDOWN)
            AllHandleNewCursor(mDoc->CursorNextShot(), false);
        if (c == 'n')
            AllHandleNewCursor(mDoc->CursorNextBookmark(), true);
        if (c == 'N')
            AllHandleNewCursor(mDoc->CursorPrevBookmark(), true);

        // from here on, propagation of event is responsibility of callee
        if (c == 'b')
            AddCursorToBookmarked();
        if (c == 'B')
            RemoveCursorFromBookmarked();
        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()
    {
    }

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
    AllHandleNewBookmarked()
    {
        for (int i=0 ; i<mDocListeners.size() ; i++)
            mDocListeners[i]->HandleNewBookmarked();
    }

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

    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();
    }

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

private:

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

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

};

} // namespace IDash
} // namespace Application
} // namespace Impala

#endif

---