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

---

SelectionCollection.h

Go to the documentation of this file.

#ifndef MediaTable_SelectionCollection_h
#define MediaTable_SelectionCollection_h

#include "SelectionCollectionItem.h"
#include "OglGui/ScrollWnd.h"

#include <fstream>

namespace Impala {
namespace Application {
namespace MediaTable {


class SelectionCollection : public OglGui::Window,
                            OglGui::ScrollBarListener,
                            TableDataViewListener,
                            SelectionCollectionListener
{
public:
    typedef OglGui::Window                          Window;
    typedef OglGui::ScrollBar                       ScrollBar;
    typedef OglGui::ScrollWnd                       ScrollWnd;

    SelectionCollection(Window* parent, TableDataView *source, int w, int h) :
        Window(parent, w, h)
    {
        Init(source, w, h);
    }

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

// Listeners
    virtual void UpdateSelectionEvent()
    {
        UpdateItemCounts();
    }

    virtual void OnScroll(ScrollBar *src, int position, void *userData)
    {
    }

    virtual void MouseFunc(int msg, int but, int state, int x, int y)
    {
    }

    virtual void KeyboardFunc(int c, int state)
    {
    }

    void UpdateItemCounts()
    {
        ILOG_DEBUG("UpdateItemCounts");
        std::map<int, int>  marks   = mSource->GetMarkedRowsMap();
        std::map<int, bool> visible = mSource->GetUnfilteredRowsMap();
        std::map<int, int>  markcounts;
        std::map<int, int>  markviscounts;

        for (int x = 0; x < 9; x++)
        {
            markcounts[x]    = 0;
            markviscounts[x] = 0;
        }

        for (int x = 0; x < mSource->GetTotalRows(); x++)
        {
            if(marks.find(x) != marks.end())
            {
                int mark = marks[x];

                if (mark & 1)   markcounts[1] += 1;
                if (mark & 2)   markcounts[2] += 1;
                if (mark & 4)   markcounts[3] += 1;
                if (mark & 8)   markcounts[4] += 1;
                if (mark & 16)  markcounts[5] += 1;
                if (mark & 32)  markcounts[6] += 1;
                if (mark & 64)  markcounts[7] += 1;
                if (mark & 128) markcounts[8] += 1;
                if (visible[x])
                {
                    if (mark & 1)   markviscounts[1] += 1;
                    if (mark & 2)   markviscounts[2] += 1;
                    if (mark & 4)   markviscounts[3] += 1;
                    if (mark & 8)   markviscounts[4] += 1;
                    if (mark & 16)  markviscounts[5] += 1;
                    if (mark & 32)  markviscounts[6] += 1;
                    if (mark & 64)  markviscounts[7] += 1;
                    if (mark & 128) markviscounts[8] += 1;
                }
            }
            else
            {
                markcounts[0] += 1;
                if (visible[x])
                    markviscounts[0] += 1;
            }
        }

        for (int x=0; x < 9; x++)
            mItems[x + 1]->SetItemCounts(markcounts[x], markviscounts[x]);

        mItems[0]->SetItemCounts(mSource->GetTotalRows(),
                                 mSource->GetFilteredRows());
        ILOG_DEBUG("UpdateItemCounts done");
    }

    /* selection collection listeners ******************************/

    virtual void SelectCollectionEvent(int id)
    {
        if (id==-1)
            mSource->DisableFilterByMark();
        else
            mSource->EnableFilterByMark(id);
        ProcessHighlights();
    }

    virtual void SelectCollectionInvertedEvent(int id)
    {
        int everything = mSource->GetMarkFilterForEverything();
        mSource->EnableFilterByMark(everything & ~id);
        ProcessHighlights();
    }

    virtual void AddCollectionToSelectionEvent(int id)
    {
        mSource->EnableFilterByMark(mSource->GetMarkFilter() | id);
        ProcessHighlights();
    }

    virtual void RemoveCollectionFromSelectionEvent(int id)
    {
        mSource->EnableFilterByMark(mSource->GetMarkFilter() & ~id);
        ProcessHighlights();
    }

        virtual void EmptyCollectionEvent(int id)
        {
        mSource->TransformMarkedTo(id, 0);
                mSource->DoUpdateSelectionEvent();
        ProcessHighlights();
        }

    void SaveCollectionEvent(int id)
    {
        ILOG_SYSTEM("SaveCollectionEvent");

        std::map<int, int>  marks   = mSource->GetMarkedRowsMap();
        if(!marks.size()) return;

        std::string filename = "marks.csv";
        std::ofstream os(filename.c_str());

        if(!os.good())
        {
                ILOG_ERROR("Can not write to " << filename);
                return;
        }

#ifndef MEDIATABLE_VIDEOLYMPICS
                os << "row,mark,mark1,mark2,mark3,mark4,mark5,mark6,mark7,mark8\n";
#else
                os << "row,mark,mark1,mark2,mark3,mark4,mark5,mark6,mark7,mark8,shotname\n";
#endif
        std::map<int, int>::iterator iter;
        for (iter = marks.begin(); iter != marks.end(); iter++)
        {
                os << iter->first << ",";
                os << iter->second << ",";
                        os << ((iter->second &   1) ? "1" : "0") << ",";
                        os << ((iter->second &   2) ? "1" : "0") << ",";
                        os << ((iter->second &   4) ? "1" : "0") << ",";
                        os << ((iter->second &   8) ? "1" : "0") << ",";
                        os << ((iter->second &  16) ? "1" : "0") << ",";
                        os << ((iter->second &  32) ? "1" : "0") << ",";
                        os << ((iter->second &  64) ? "1" : "0") << ",";
                        os << ((iter->second & 128) ? "1" : "0");
#ifdef MEDIATABLE_VIDEOLYMPICS
                os  << "," << mSource->GetTextDataByID("shotname", iter->first);
#endif
                        os << "\n";
        }
        os.close();
        ILOG_DEBUG("Written " << marks.size() << " to " << filename);
    }

    void LoadCollectionEvent(int id)
    {
        ILOG_SYSTEM("SaveCollectionEvent");

        std::string filename = "marks.csv";
        std::ifstream is(filename.c_str());

        if(!is.good())
        {
                ILOG_ERROR("Can not read from " << filename);
                return;
        }

                std::string line, cell;
                int row, mark;
                int marks = 0;
                bool first = true;
        while(is.good()) {
                std::getline(is, line);
                if(line.length() == 0) continue;
                std::stringstream lineStream(line);

                if(first) {
                        first = false;
                        if(!std::getline(lineStream,cell,',')) first = true;
                        if(cell != "row") first = true;
                        if(!std::getline(lineStream,cell,',')) first = true;
                        if(cell != "mark") first = true;

                        if(first)
                        {
                                ILOG_ERROR(filename << " does not have correct column header.");
                                break;
                        }
                } else {
                        if(!std::getline(lineStream,cell,',')) continue;
                        row = atoi(cell.c_str());
                        if(!std::getline(lineStream,cell,',')) continue;
                        mark = atoi(cell.c_str());

                        mSource->SetMarkById(row, mark);
                                marks++;
                }
        }
        UpdateItemCounts();
        ILOG_DEBUG("Read " << marks << " from " << filename);
    }
    void ProcessHighlights()
    {
        int id = mSource->GetMarkFilter();
        for (int x=0; x<mItems.size(); x++)
            mItems[x]->SetHighlighted(false);

        if (id==-1)
            mItems[0]->SetHighlighted(true);
        else
        {
            if (id== 0)  mItems[1]->SetHighlighted(true);
            if (id & 1)  mItems[2]->SetHighlighted(true);
            if (id & 2)  mItems[3]->SetHighlighted(true);
            if (id & 4)  mItems[4]->SetHighlighted(true);
            if (id & 8)  mItems[5]->SetHighlighted(true);
            if (id & 16) mItems[6]->SetHighlighted(true);
            if (id & 32) mItems[7]->SetHighlighted(true);
            if (id & 64) mItems[8]->SetHighlighted(true);
            if (id & 128) mItems[9]->SetHighlighted(true);
        }
   }

private :

    int MarkToColor(int m)
    {
        int r=127,g=127,b=127;
        if (m == -1)
            return ARGB2COLOR(255, 200, 200, 200);
        if (m & 1)
            r = g = b = 255;
        if (m & 2)
            r = g = b = 20;
        if (m & 4)
            r += 64;
        if (m & 8)
            g += 64;
        if (m & 16)
            b += 64;
        if (m & 32)
            { r += 64; g += 64; }
        if (m & 64)
            { g += 64; b += 64; }
        if (m & 128)
            { r += 64; b += 64; }
        if (r>255) r = 255;
        if (g>255) g = 255;
        if (b>255) b = 255;
        return ARGB2COLOR(255, r,g,b);
    }

    SelectionCollectionItem*
    MakeSelectionCollectionItem(std::string name, int markID)
    {
        Window* pane = mItemWindow->ContentPane();
        SelectionCollectionItem *item =
            new SelectionCollectionItem(pane, markID, MarkToColor(markID));
        item->SetItemName(name);
        item->SetListener(this);
        return item;
    }

    void Init(TableDataView *source, int w, int h)
    {
        mSource = source;
        mSource->AddTableDataViewListener(this);

        SetBorderType(1);
        SetBorderFillShaded(-2);

        mItemWindow = new ScrollWnd(this, 8, 8, W()-16, H()-16, true, true, false);
        mItemWindow->ConnectTo(this);
        mItemWindow->ContentPane()->SetDimensions(0, 0, 10 * 90, 90);
                mItemWindow->SetBorderType(0);

        mItems.push_back(MakeSelectionCollectionItem("everything", -1));
        mItems.push_back(MakeSelectionCollectionItem("unknown", 0));
        mItems.push_back(MakeSelectionCollectionItem("selected", 1));
        mItems.push_back(MakeSelectionCollectionItem("seen", 2));
        mItems.push_back(MakeSelectionCollectionItem("red", 4));
        mItems.push_back(MakeSelectionCollectionItem("green", 8));
        mItems.push_back(MakeSelectionCollectionItem("blue", 16));
        mItems.push_back(MakeSelectionCollectionItem("yellow", 32));
        mItems.push_back(MakeSelectionCollectionItem("cyan", 64));
#ifndef MEDIATABLE_VIDEOLYMPICS
        mItems.push_back(MakeSelectionCollectionItem("other", 128));
#else
#ifdef WIN32
                mItems.push_back(MakeSelectionCollectionItem("VideOlympic", 128));
#else
        mItems.push_back(MakeSelectionCollectionItem("VideOlympics", 128));
#endif
#endif
                
        mItems[0]->SetHighlighted(true);
    }

    TableDataView*                              mSource;
    ScrollWnd*                              mItemWindow;

    std::vector<SelectionCollectionItem*>   mItems;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(SelectionCollection, Application.MediaTable);


} // namespace MediaTable
} // namespace Application
} // namespace Impala

#endif // SelectionCollection_h

---