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

---

DataDocumentGui.h

Go to the documentation of this file.

//345678901234567890123456789012345678901234567890123456789012345678901234567890
#ifndef Impala_Visualization_DataDocumentGui_h
#define Impala_Visualization_DataDocumentGui_h

//#include "Visualization/OptionsLook.h"
#include "Visualization/AppControlDoc.h"
#include "Visualization/Window.h"
#include "OglGui/StringSelector.h"
#include "OglGui/StringListener.h"
#include "OglGui/TextArea.h"
#include "OglGui/TextField.h"
#include "OglGui/Strut.h"
#include "OglGui/Button.h"
#include "OglGui/MenuOnButton.h"

namespace Impala {
namespace Visualization {

template <class DataDocT>
class DataDocumentGui : public Window, public AppControlDoc,
                        public Core::Database::DataDocumentListener,
                        public OglGui::StringListener,
                        public OglGui::ButtonListener
{
public:

    static const int STRING_DIR = 1;
    static const int STRING_FILE = 2;
    static const int STRING_BOOK = 3;

    static const int BUT_CONCEPT = 1;
    static const int BUT_ADD_CONCEPT = 2;
    static const int BUT_LOAD_CONCEPTS = 3;
    static const int BUT_SAVE_CONCEPTS = 4;
    static const int BUT_BOOKMARK = 5;
    static const int BUT_UNBOOKMARK = 6;
    static const int BUT_CLEAR_BOOKMARKED = 7;
    static const int BUT_LOAD_BOOKMARKED = 8;
    static const int BUT_SAVE_BOOKMARKED = 9;

    DataDocumentGui(OglGui::Window* parent, int wndWidth, int wndHeight,
                    DataDocT* dataDoc, int controlId,
                    bool showFiles = true, bool showBookList = true,
                    bool infoOnly = false, int nrOnRow = 3, int nrLines = 12,
                    bool showAnno = true, bool showBookBut = true) :
        Window(parent, wndWidth, wndHeight, true),
        AppControlDoc(controlId, dataDoc)
    {
        mDataDoc = dataDoc;
        AddDocListener(this);

        int width = (wndWidth - 15) / nrOnRow;
        int line = 20;
        mInfoText1 = mInfoText2 = mInfoText3 = 0;
        mStringSelector1 = mStringSelector2 = mStringSelector3 = 0;

        if (showFiles)
        {
            mInfoText1 = new OglGui::TextArea(this, width, 1*line, "set info",
                                              false);
            if (nrOnRow >= 2)
                mInfoText2 = new OglGui::TextArea(this, width, 1*line,
                                                  "file info", false);
        }
        if ((showBookList) && (nrOnRow >= 3))
            mInfoText3 = new OglGui::TextArea(this, width, 1*line,
                                              "bookmark info", false);

        if (showFiles)
        {
            if (!infoOnly)
            {
                int nDir = mDataDoc->GetDataSet()->NrDirs();
                int sH = line * ((nrOnRow<2&&nDir<nrLines) ? nDir+1 : nrLines);
                mStringSelector1 = new OglGui::StringSelector(this, width, sH);
                mStringSelector1->SetStringListener(this, STRING_DIR);
                mStringSelector1->GuiName("dataDirSelector");
                //OptionsLook(mStringSelector1, "strSelect", "dataDir");
            }
            if (nrOnRow < 2)
            {
                new OglGui::Strut(this, 4000, 1);
                mInfoText2 = new OglGui::TextArea(this,width,line,"file info",
                                                  false);
            }
            mStringSelector2 = new OglGui::StringSelector(this, width,
                                                          nrLines*line);
            mStringSelector2->SetStringListener(this, STRING_FILE);
            mStringSelector2->GuiName("dataFileSelector");
            //OptionsLook(mStringSelector2, "strSelect", "dataFile");
        }

        if (showBookList)
        {
            if (nrOnRow < 3)
            {
                new OglGui::Strut(this, 4000, 1);
                mInfoText3 = new OglGui::TextArea(this, wndWidth, 1*line,
                                                  "bookmark info");
                mInfoText3->SetBorderType(0);
            }
            if (!infoOnly)
            {
                mStringSelector3 = new OglGui::StringSelector(this, width,
                                                              nrLines*line);
                mStringSelector3->SetStringListener(this, STRING_BOOK);
                mStringSelector3->GuiName("dataBookmarkSelector");
                //OptionsLook(mStringSelector3, "strSelect", "dataBookmark");
            }
        }

        OglGui::Button* but;
        OglGui::TextArea* tArea;
        mConceptField = 0;

        if (showAnno)
        {
            //new OglGui::Strut(this, 4000, 1);
            but = new OglGui::MenuOnButton(this, 100, 22, "Concept");
            but->SetButtonListener(this, BUT_CONCEPT);
            mConceptField = new OglGui::TextField(this, 160, 22, "");
            but = new OglGui::Button(this, 80, 22, "Add",4,true);
            but->SetButtonListener(this, BUT_ADD_CONCEPT);
            new OglGui::Strut(this, 50, 1);
            tArea = new OglGui::TextArea(this, 80, 1*line, "Concepts",false);
            //tArea->SetBorderType(0);
            but = new OglGui::Button(this, 60, 22, "Load",4,true);
            but->SetButtonListener(this, BUT_LOAD_CONCEPTS);
            but = new OglGui::Button(this, 60, 22, "Save",4,true);
            but->SetButtonListener(this, BUT_SAVE_CONCEPTS);
            mConceptFileField = new OglGui::TextField(this, 190, 22,
                                                      "concept.txt");
        }

        if (showBookBut)
        {
            new OglGui::Strut(this, 4000, 1);

            tArea = new OglGui::TextArea(this, 65, line, "Cursor");
            tArea->SetBorderType(0);
            but = new OglGui::Button(this, 105, 22, "Bookmark (b)");
            but->SetButtonListener(this, BUT_BOOKMARK);
            but = new OglGui::Button(this, 115, 22, "Unbookmark (B)");
            but->SetButtonListener(this, BUT_UNBOOKMARK);
            new OglGui::Strut(this, 50, 1);
            tArea = new OglGui::TextArea(this, 80, 1*line, "Bookmarks");
            tArea->SetBorderType(0);
            but = new OglGui::Button(this, 60, 22, "Clear");
            but->SetButtonListener(this, BUT_CLEAR_BOOKMARKED);
            but = new OglGui::Button(this, 60, 22, "Load");
            but->SetButtonListener(this, BUT_LOAD_BOOKMARKED);
            but = new OglGui::Button(this, 60, 22, "Save");
            but->SetButtonListener(this, BUT_SAVE_BOOKMARKED);
            mBookmarkedField = new OglGui::TextField(this, 190, 20,
                                                     "filename.ixs");
        }

        Core::Database::RawDataSet* dataSet = mDataDoc->GetDataSet();
        std::string info = std::string("Set ") + dataSet->GetSetName() +
            " has " + MakeString(dataSet->NrDirs()) + " dirs";
        if (mInfoText1)
            mInfoText1->SetText(info);
        if (mStringSelector1)
            for (int i=0 ; i<dataSet->NrDirs() ; i++)
                mStringSelector1->AddString(dataSet->GetSection(i) + "/" +
                                            dataSet->GetDir(i));
    }

    virtual void
    HandleNewFile()
    {
        int curD = mDataDoc->CurDirId();
        if (mStringSelector1)
            mStringSelector1->SetCurrentString(curD, true);
        Core::Database::RawDataSet* dataSet = mDataDoc->GetDataSet();
        int nrFiles = (curD != -1) ? dataSet->GetNrFiles(curD) : 0;
        std::string info("no dir selected");
        if (curD != -1)
            info = dataSet->GetDir(curD) + " has " + MakeString(nrFiles)
                   + " files";
        if (mInfoText2)
            mInfoText2->SetText(info);
        int firstVis;
        if (mStringSelector2)
        {
            firstVis = mStringSelector2->GetFirstVis();
            mStringSelector2->RemoveStrings();
        }
        if (mStringSelector2 && (curD != -1))
        {
            int start = dataSet->GetFirstFileId(curD);
            int end = start + dataSet->GetNrFiles(curD);
            for (int i=start ; i<end ; i++)
                mStringSelector2->AddString(dataSet->GetFile(i));
            int idx = mDataDoc->CurFileId() - dataSet->GetFirstFileId(curD);
            mStringSelector2->SetFirstVis(firstVis, true);
            mStringSelector2->SetCurrentString(idx, true);
        }
    }

    virtual void
    HandleNewBookmarked()
    {
        typedef typename DataDocT::BookmarkedType BookmarkedT;
        BookmarkedT* bookm = mDataDoc->GetBookmarked();
        if (mInfoText3)
            mInfoText3->SetText(MakeString(bookm->Size()) + " bookmarks");
        int firstVis;
        if (mStringSelector3)
        {
            firstVis = mStringSelector3->GetFirstVis();
            mStringSelector3->RemoveStrings();
        }
        Core::Database::RawDataSet* dataSet = mDataDoc->GetDataSet();
        int curB = mDataDoc->CurBookmark();
        if (mStringSelector3 && mDataDoc->HasBookmarks())
        {
            for (int i=0 ; i<bookm->Size() ; i++)
                mStringSelector3->AddString(mDataDoc->DescribeBookmark(i));
            mStringSelector3->SetFirstVis(firstVis, true);
            mStringSelector3->SetCurrentString(curB, true);
        }
    }

    virtual void
    HandleCursorBookmarked()
    {
        if (mStringSelector3)
            mStringSelector3->SetCurrentString(mDataDoc->CurBookmark(), true);
        if (mConceptField)
        {
            mConceptField->SetText(mDataDoc->CurBookmarkAnno());
            mConceptField->ResetCaret();
        }
    }

    virtual void
    AddCursorToBookmarked()
    {
        if (mConceptField)
            mDataDoc->SetConcept(mConceptField->GetText());
        if (! mDataDoc->AddCursorToBookmarked())
            return;
        AllHandleAddedBookmark();
    }

    virtual void
    RemoveCursorFromBookmarked()
    {
        if (! mDataDoc->RemoveCursorFromBookmarked())
            return;
        AllHandleRemovedBookmark();
        AllHandleNewCursor(Core::Database::LEVEL_FILE, true);
    }

    void
    ClearBookmarked()
    {
        mDataDoc->ClearBookmarked();
        AppControlDoc::HandleActivate();
    }

    void
    LoadBookmarked()
    {
        mDataDoc->Clear();
        std::string fileName = mBookmarkedField->GetText();
        mDataDoc->LoadBookmarked(fileName);
        mDataDoc->LoadConceptsFromBookmarks();
        AppControlDoc::HandleActivate();
    }

    void
    SaveBookmarked()
    {
        std::string fileName = mBookmarkedField->GetText();
        std::string conceptName = FileNameBase(fileName);
        mDataDoc->SaveBookmarked(fileName, conceptName);
    }

    virtual void
    StringSelectionEvent(OglGui::StringSelector* src, int strIndex,
                         void* listenerData)
    {
        typedef Core::Database::DocLevel DocLevel;
        if (listenerData == (void*)STRING_DIR)
        {
            DocLevel level = mDataDoc->CursorToDir(strIndex);
            AllHandleNewCursor(level, false);
        }
        if (listenerData == (void*)STRING_FILE)
        {
            int fileIdx = mDataDoc->GetFileOfDir(strIndex, -1);
            mDataDoc->CursorToFile(fileIdx);
            AllHandleNewCursor(Core::Database::LEVEL_FILE, false);
        }
        if (listenerData == (void*)STRING_BOOK)
        {
            mDataDoc->CursorToBookmark(strIndex);
            AllHandleNewCursor(Core::Database::LEVEL_FILE, true);
        }
    }

    virtual void
    ButtonSelectionEvent(OglGui::Button* src, void *vData)
    {
        int listenerData = (int)((long long) vData);
        switch (listenerData)
        {
        case BUT_CONCEPT: {
            if (!mDataDoc->HasConcepts())
                break;
            OGLMENU menu = oglSys.MenuCreate();
            for (int i=0 ; i<mDataDoc->NrConcepts() ; i++)
                oglSys.MenuAdd(menu, (char*) mDataDoc->GetConcept(i).c_str(),
                               0, 100 + i);
            int choice = oglSys.MenuPopUp(mOglWnd, menu);
            if (choice >= 100)
            {
                mDataDoc->SetConcept(choice - 100);
                mConceptField->SetText(mDataDoc->GetConcept());
                mConceptField->ResetCaret();
                HandleNewConcept();
            }
            oglSys.MenuDestroy(menu);
            break;
        }
        case BUT_ADD_CONCEPT:
            mDataDoc->SetConcept(mConceptField->GetText());
            HandleNewConcept();
            break;
        case BUT_LOAD_CONCEPTS:
            HandleLoadConcepts(mConceptFileField->GetText());
            break;
        case BUT_SAVE_CONCEPTS:
            HandleSaveConcepts(mConceptFileField->GetText());
            break;
        case BUT_BOOKMARK:
            AddCursorToBookmarked();
            break;
        case BUT_UNBOOKMARK:
            RemoveCursorFromBookmarked();
            break;
        case BUT_CLEAR_BOOKMARKED:
            ClearBookmarked();
            break;
        case BUT_LOAD_BOOKMARKED:
            LoadBookmarked();
            break;
        case BUT_SAVE_BOOKMARKED:
            SaveBookmarked();
            break;
        } // end switch
    }

    virtual void
    HandleNewConcept()
    {
    }

    virtual void
    HandleLoadConcepts(std::string fileName)
    {
        mDataDoc->LoadConcepts(fileName);
    }

    virtual void
    HandleSaveConcepts(std::string fileName)
    {
        mDataDoc->SaveConcepts(fileName);
    }

protected:

    OglGui::TextField* mConceptField;
    OglGui::TextField* mConceptFileField;
    OglGui::TextField* mBookmarkedField;

    DataDocT*         mDataDoc;
private:

    OglGui::TextArea*       mInfoText1;
    OglGui::TextArea*       mInfoText2;
    OglGui::TextArea*       mInfoText3;
    OglGui::StringSelector* mStringSelector1;
    OglGui::StringSelector* mStringSelector2;
    OglGui::StringSelector* mStringSelector3;

};

} // namespace Visualization
} // namespace Impala

#endif

---