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

---

DataDocument.h

Go to the documentation of this file.

#ifndef Impala_Core_Database_DataDocument_h
#define Impala_Core_Database_DataDocument_h

#include "Util/DatabaseReadString.h"
#include "Util/DatabaseWriteString.h"
#include "Core/Array/Arrays.h"
#include "Core/Database/RawDataSet.h"
#include "Core/Table/TableIds.h"
#include "Persistency/KeywordListRepository.h"

namespace Impala
{
namespace Core
{
namespace Database
{


enum DocLevel
{
    LEVEL_NONE  = 0,
    LEVEL_DIR   = 1,
    LEVEL_FILE  = 2,
    LEVEL_SHOT  = 3,
    LEVEL_FRAME = 4
};


class DataDocument
{
public:
    typedef Geometry::Rectangle Rectangle;
    typedef Core::Table::TableIds TableIds;

    DataDocument(RawDataSet* dataSet)
    {
        mDataSet = dataSet;
        mCurFileId = -1;
        mCurDirId = -1;
        mThumbScale = 0.5;
    }

    // dataset part

    bool
    HasCurFile()
    {
        return mCurFileId != -1;
    }

    bool
    HasCurDir()
    {
        if (HasCurFile())
            return true;
        return mCurDirId != -1;
    }

    int
    CurFileId()
    {
        return mCurFileId;
    }

    int
    CurDirId()
    {
        if (HasCurFile())
            return mDataSet->GetDirIdOfFile(CurFileId());
        return mCurDirId;
    }

    int
    GetFileOfDir(int fileIdx, int dirId) // (dirId == -1) implies current dir
    {
        if (!mDataSet->HasFiles())
            return -1;
        if (dirId == -1)
        {
            if (!HasCurDir())
                return -1;
            dirId = CurDirId();
        }
        return mDataSet->GetFirstFileId(dirId) + fileIdx;
    }

    // ownership of table resides with caller
    TableIds*
    GetFilesOfDir(int dirId) // (dirId == -1) implies current dir
    {
        if (dirId == -1)
        {
            if (!HasCurDir())
                return 0;
            dirId = CurDirId();
        }
        int first = mDataSet->GetFirstFileId(dirId);
        int nr = mDataSet->GetNrFiles(dirId);
        TableIds* table = new TableIds(nr);
        for (int i=0 ; i<nr ; i++)
            table->Add(first + i);
        return table;
    }

    RawDataSet*
    GetDataSet()
    {
        return mDataSet;
    }

    // cursor part (maps onto dataset by default)

    virtual bool
    HasCursor()
    {
        return HasCurFile();
    }

    virtual DocLevel
    CursorToDir(int dirId)
    {
        GotoDir(dirId);
        return LEVEL_DIR;
    }

    virtual DocLevel
    CursorToFile(int fileId)
    {
        GotoFile(fileId);
        return LEVEL_FILE;
    }

#if 0
    virtual DocLevel
    CursorPageUp()
    {
        if (GotoPrevDir())
            return LEVEL_DIR;
        return LEVEL_NONE;
    }

    virtual DocLevel
    CursorPageDown()
    {
        if (GotoNextDir())
            return LEVEL_DIR;
        return LEVEL_NONE;
    }

    virtual DocLevel
    CursorLeft()
    {
        if (GotoPrevFile(/*oglSys.KeyModifierState(oglShift) == 0*/))
            return LEVEL_FILE;
        return LEVEL_NONE;
    }

    virtual DocLevel
    CursorRight()
    {
        if (GotoNextFile(/*oglSys.KeyModifierState(oglShift) == 0*/))
            return LEVEL_FILE;
        return LEVEL_NONE;
    }

    virtual DocLevel
    CursorUp()
    {
        return LEVEL_NONE;
    }

    virtual DocLevel
    CursorDown()
    {
        return LEVEL_NONE;
    }
#endif // #if 0
    virtual DocLevel
    CursorPrevDir()
    {
        if (GotoPrevDir())
            return LEVEL_DIR;
        return LEVEL_NONE;
    }

    virtual DocLevel
    CursorNextDir()
    {
        if (GotoNextDir())
            return LEVEL_DIR;
        return LEVEL_NONE;
    }

    virtual DocLevel
    CursorPrevFile()
    {
        if (GotoPrevFile(/*oglSys.KeyModifierState(oglShift) == 0*/))
            return LEVEL_FILE;
        return LEVEL_NONE;
    }

    virtual DocLevel
    CursorNextFile()
    {
        if (GotoNextFile(/*oglSys.KeyModifierState(oglShift) == 0*/))
            return LEVEL_FILE;
        return LEVEL_NONE;
    }

    virtual DocLevel
    CursorPrevShot()
    {
        return LEVEL_NONE;
    }

    virtual DocLevel
    CursorNextShot()
    {
        return LEVEL_NONE;
    }

    virtual bool
    HasBookmarks() = 0;

    virtual DocLevel
    CursorToBookmark(int idx) = 0;

    virtual DocLevel
    CursorNextBookmark() = 0;

    virtual DocLevel
    CursorPrevBookmark() = 0;

    // ownership resides with caller
    // data only garanteed as long as cursor doesn't move
    virtual Core::Array::Array2dVec3UInt8*
    VisualAtCursor(bool thumbnail)
    {
        return 0;
    }

    // rectangle part, size of rectangle is stored at full resolution

    void
    SetRect(Rectangle r)
    {
        mRect = r;
        mRect.CheckSize();
    }

    void
    SetRect(Rectangle r, double scale)
    {
        mRect = r / scale;
        mRect.CheckSize();
    }

    void
    SetRectThumb(Rectangle r)
    {
        SetRect(r, mThumbScale);
    }

    Rectangle
    GetRect()
    {
        return mRect;
    }

    Rectangle
    GetRect(double scale)
    {
        return mRect * scale;
    }

    Rectangle
    GetRectThumb()
    {
        return GetRect(mThumbScale);
    }

    void
    SetThumbScale(double scale)
    {
        mThumbScale = scale;
    }

    double
    GetThumbScale()
    {
        return mThumbScale;
    }

    // concept part

    void
    SetConcept(String concept)
    {
        mConcept = concept;
        AddConcept(concept); // make sure it gets into the list
    }

    void
    SetConcept(int idx) // idx from concepts
    {
        mConcept = mConcepts[idx];
    }

    String
    GetConcept()
    {
        return mConcept;
    }

    int
    GetConceptIdx()
    {
        for (int i=0 ; i<mConcepts.size() ; i++)
            if (mConcepts[i] == mConcept)
                return i;
        return -1;
    }

    bool
    HasConcepts()
    {
        return mConcepts.size() > 0;
    }

    int
    NrConcepts()
    {
        return mConcepts.size();
    }

    String
    GetConcept(int i)
    {
        return mConcepts[i];
    }

    void
    AddConcept(String concept)
    {
        if (concept.empty())
            return;
        for (int i=0 ; i<mConcepts.size() ; i++)
            if (mConcepts[i] == concept)
                return;
        int j = 2;
        mConcepts.push_back(concept);
    }

    void
    LoadConcepts(String fileName)
    {
        mConcepts.clear();
#ifndef REPOSITORY_USED // Here comes the deprecated stuff
        Util::DatabaseReadStrings(mConcepts, fileName, mDataSet->GetDatabase());
#else // REPOSITORY_USED
        Persistency::KeywordListLocator loc(mDataSet->GetLocator(), fileName);
        mConcepts = *(Persistency::KeywordListRepository().Get(loc));
#endif // REPOSITORY_USED
    }

    void
    SaveConcepts(String fileName)
    {
#ifndef REPOSITORY_USED // Here comes the deprecated stuff
        Util::DatabaseWriteString(fileName, mDataSet->GetDatabase(),
                                  mConcepts.begin(), mConcepts.end());
#else // REPOSITORY_USED
        Persistency::KeywordListLocator loc(mDataSet->GetLocator(), fileName);
        Persistency::KeywordListRepository().Add(loc, &mConcepts);
#endif // REPOSITORY_USED
    }

    // misc

    virtual void
    Clear()
    {
        GotoFile(-1);
        mRect = Rectangle();
    }

protected:

    void
    GotoFile(int fileId)
    {
        ILOG_DEBUG("fileId = " << fileId);
        mCurFileId = fileId;
    }

    void
    GotoDir(int dirId)
    {
        if (mDataSet->HasFiles())
            GotoFile(mDataSet->GetFirstFileId(dirId));
        else
            mCurDirId = dirId;
    }

    void
    GotoFileOfDir(int fileIdx, int dirId) // (dirId == -1) implies current dir
    {
        int dst = GetFileOfDir(fileIdx, dirId);
        if (dst != -1)
            GotoFile(dst);
    }

    bool
    GotoPrevFile(bool withinDir = true)
    {
        return TryFileMove(mCurFileId - 1, withinDir);
    }

    bool
    GotoNextFile(bool withinDir = true)
    {
        return TryFileMove(mCurFileId + 1, withinDir);
    }

    // returns id of file, -1 if not applicable
    int
    GetPrevFile(int steps = 1)
    {
        return GetFileMove(mCurFileId, -1, steps);
    }

    // returns id of file, -1 if not applicable
    int
    GetNextFile(int steps = 1)
    {
        return GetFileMove(mCurFileId, 1, steps);
    }

    bool
    GotoPrevDir()
    {
        return TryDirMove(-1);
    }

    bool
    GotoNextDir()
    {
        return TryDirMove(1);
    }

    bool
    TryFileMove(int newFile, bool withinDir)
    {
        if ((newFile < 0) || (newFile >= mDataSet->NrFiles()))
            return false;
        if (!HasCurFile())
            return false;
        if (withinDir && (! SameDir(mCurFileId, newFile)))
            return false;
        GotoFile(newFile);
        return true;
    }

    int
    GetFileMove(int oldFile, int dir, int steps)
    {
        int newFile = oldFile + dir;
        if ((newFile < 0) || (newFile >= mDataSet->NrFiles()))
            return -1;
        if (! SameDir(mCurFileId, newFile))
            return -1;
        if (--steps <= 0)
            return newFile;
        return GetFileMove(newFile, dir, steps);
    }

    bool
    TryDirMove(int inc)
    {
        if (!HasCurFile())
            return false;
        int subset = mDataSet->GetDirIdOfFile(mCurFileId) + inc;
        if ((subset < 0) || (subset >= mDataSet->NrDirs()))
            return false;
        int newFile = mDataSet->GetFirstFileId(subset);
        GotoFile(newFile);
        return true;
    }

    bool
    SameDir(int fileId1, int fileId2)
    {
        return (mDataSet->GetDirIdOfFile(fileId1) ==
                mDataSet->GetDirIdOfFile(fileId2));
    }

    RawDataSet* mDataSet;
    int         mCurFileId;
    int         mCurDirId; // only valid in case there are no files

    Rectangle   mRect; // rectangle drawn by user
    double      mThumbScale;

    String                   mConcept;  // (current) concept given by user
    Core::Table::KeywordList mConcepts; // choices for concepts

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(DataDocument, Impala.Core.Database);

} // namespace Database
} // namespace Core
} // namespace Impala

#endif

---