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

---

SelectionCollection.h

Go to the documentation of this file.

#ifndef VideoExcel_SelectionCollection_h
#define VideoExcel_SelectionCollection_h

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

namespace Impala {
namespace Application {
namespace VideoExcel {


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

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

    SelectionCollection(Window* parent, TableDataSource *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->GetVisibleRowsMap();
        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();
    }

    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(TableDataSource *source, int w, int h)
    {
        mSource = source;
        mSource->AddTableUpdateListener(this);

        SetBorderType(1);
        SetBorderFillShaded(-2);

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

        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));
        mItems.push_back(MakeSelectionCollectionItem("other", 128));

        mItems[0]->SetHighlighted(true);
    }

    TableDataSource*                        mSource;
    ScrollWnd*                              mItemWindow;

    std::vector<SelectionCollectionItem*>   mItems;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(SelectionCollection, Application.VideoExcel);


} // namespace VideoExcel
} // namespace Application
} // namespace Impala

#endif // SelectionCollection_h

---