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

---

TableColumn.h

Go to the documentation of this file.

#ifndef VideoExcel_TableColumn_h
#define VideoExcel_TableColumn_h

#include "TableDataSource.h"
#include "TableCell.h"

#include "OglGui/DirectionButton.h"
#include "OglGui/TextField.h"
#include "OglGui/StaticText.h"
#include "OglGui/MenuOnButton.h"

namespace Impala {
namespace Application {
namespace VideoExcel {

//using namespace OglGui;

class TableColumn : public OglGui::Window,
                    OglGui::TextFieldListener,
                    OglGui::ButtonListener,
                    OglGui::MenuListener,
                    TableUpdateListener
{
public:
    typedef OglGui::Window                      Window;
    typedef OglGui::Button                      Button;
    typedef OglGui::DirectionButton             DirectionButton;
    typedef OglGui::TextField                   TextField;
    typedef OglGui::MenuOnButton                MenuOnButton;
    typedef OglGui::MenuTopPane                 MenuTopPane;
    typedef OglGui::Menu                        Menu;

    TableColumn(Window *parent, TableDataSource *source,
                CString name, int width=120) :
        Window(parent, width, parent->H())
    {
        ConnectTo(parent, OglGui::T2T | OglGui::B2B);
        Init(name, parent, source, width, parent->H());
    }

    void SetDisplayMode(int mode, int attr=TableCell::NONE)
    {
        mDisplayMode = mode;
        mDisplayAttr = attr;
        switch (mode)
        {
            case TableCell::DISPLAY_TEXT:
                mFilterTextField->SetVisible(true);
                mFilterValueButton->SetVisible(false);
                break;
            case TableCell::DISPLAY_IMAGE:
                if (!mCache)
                    mCache = new TableViewCache(this, mSource);
                mFilterTextField->SetVisible(false);
                mFilterValueButton->SetVisible(false);
                mSortButton->SetVisible(false);
                break;
            case TableCell::DISPLAY_DOT:
            case TableCell::DISPLAY_FILLED:
                mFilterTextField->SetVisible(false);
                mFilterValueButton->SetVisible(true);
                break;
        }
        UpdateRows();
    }

    void SetSortType(int type) {
        mSortType = type;
    }

    void UpdateRows()
    {
        if (mDisplayMode == TableCell::DISPLAY_IMAGE)
            mCache->HideViews();

        int cindex  = 0;
        int yoffset = sHeaderHeight;
        int startR  = mSource->GetStartRow();
        for (int i=startR; i<startR+mSource->GetNumberOfRows(); i++)
        {
            TableCell *c = GetCell(cindex++);
            int yheight  = mSource->GetRowHeight(i);
            yoffset += yheight;
            c->UpdateRow(yoffset, i, mDisplayMode, mDisplayAttr);
        }

        // ensure the rest is not used/invisible:
        for (int i=cindex; i<mCellCache.size(); i++)
            mCellCache[i]->SetVisible(false);
        UpdateScene();
    }

    TableViewCache* GetViewCache()
    {
        return mCache;
    }

    virtual void DisplayFunc()
    {
        if (mCache && mCache->ProcessDelayLoad())
            UpdateRows();
        Window::DisplayFunc();
    }

    virtual void ButtonSelectionEvent(Button *src, void* userData)
    {
        int t = 0;
        if (mDisplayMode == TableCell::DISPLAY_TEXT)
            t = TableDataSource::TYPE_TEXT;
        if (mDisplayMode == TableCell::DISPLAY_DOT ||
            mDisplayMode == TableCell::DISPLAY_FILLED)
            t = TableDataSource::TYPE_NORMALIZEDVALUE;
        if (mSortType > 0)
            t = mSortType;
        if (t == 0) return; // if we cannot sort on this, then don't.

        if (mSource->GetSortColumn() == mColumnName)
            mSource->SetSortColumn(mColumnName,t,!mSource->GetSortAscending());
        else
            mSource->SetSortColumn(mColumnName,t);
    }

    static int GetHeaderHeight()
    {
        return sHeaderHeight;
    }

    int GetColumnWidth()
    {
        return mColWidth;
    }

    void SetColumnWidthDynamic(bool value)
    {
        mColWidthDynamic = value;
    }

    bool GetColumnWidthDynamic()
    {
        return mColWidthDynamic;
    }

    void ResetFilter(bool callEvents=true)
    {
        switch (mDisplayMode)
        {
            case TableCell::DISPLAY_TEXT:
                mFilterTextField->SetText("");
                mFilter->Disable(callEvents);
                break;
            case TableCell::DISPLAY_DOT:
            case TableCell::DISPLAY_FILLED:
                mFilterValueButton->SetText("Filter");
                mFilter->Disable(callEvents);
                break;
        }
    }

private:

    virtual void UpdateRowsEvent()
    {
        UpdateRows();
    }

    virtual void UpdateSortEvent(String col, bool ascending)
    {
        // update sort button with current sorting state:
        if (mColumnName == col)
        {
            mSortButton->SetFilled(true);
            mColumnHeader->SetPressed(true);
            mSortButton->SetDirection(ascending ? 3 : 1);
        }
        else
        {
            mSortButton->SetFilled(false);
            mColumnHeader->SetPressed(false);
            mSortButton->SetDirection(3);
        }
    }

    // process filter events generated from the possible filters:

    virtual void // text filter
    TextFieldChangedEvent(TextField *src, void* userData)
    {
        if (mDisplayMode == TableCell::DISPLAY_TEXT)
            mFilter->SetTextFilter(src->GetText());
    }

    // value filter
    virtual void OnMenuItem(Menu *src, int menuIdx, String itemName,
                            int itemIdx, void *userData)
    {
        ILOG_DEBUG("Selected option " << itemIdx << " menuIdx " << menuIdx <<
                   " itemName " << itemName);

        switch (itemIdx)
        {
            case 1:
                mFilter->SetValueFilter(0.95, false);
                mFilterValueButton->SetText("<5%%");
                break;
            case 2:
                mFilter->SetValueFilter(0.90, false);
                mFilterValueButton->SetText("<10%%");
                break;
            case 3:
                mFilter->SetValueFilter(0.80, false);
                mFilterValueButton->SetText("<20%%");
                break;
            case 4:
                mFilter->SetValueFilter(0.70, false);
                mFilterValueButton->SetText("<30%%");
                break;
            case 5:
                mFilter->SetValueFilter(0.50, false);
                mFilterValueButton->SetText("<50%%");
                break;
            case 6:
                mFilter->SetValueFilter(0.50, true);
                mFilterValueButton->SetText(">50%%");
                break;
            case 7:
                mFilter->SetValueFilter(0.20, false);
                mFilterValueButton->SetText(">20%%");
                break;
            case 8:
                mFilter->SetValueFilter(0.10, false);
                mFilterValueButton->SetText(">10%%");
                break;
            case 9:
                mFilter->Disable();
                mFilterValueButton->SetText("Filter");
                break;
        }
    }

    TableCell *GetCell(int index)
    {
        if (index >= mCellCache.size())
        {
            TableCell *c = new TableCell(this, mSource, mCache, mColumnName);
            oglSys.SetNoMouseInput(c->GetOGLWND(),1);
            mCellCache.push_back(c);
            return c;
        }
        return mCellCache[index];
    }

    void
    Init(String name, Window *parent, TableDataSource *source, int w, int h)
    {
        mSource      = source;
        mColumnName  = name;
        mCache       = 0;
        mDisplayMode = TableCell::DISPLAY_TEXT;
        mDisplayAttr = TableCell::NONE;

        // register for updates on this datasource:
        mSource->AddTableUpdateListener(this);

        // build the column GUI
        oglSys.SetNoMouseInput(GetOGLWND(),1);
        //mColumnHeader = new Button(this,0,h-20,w,20,w<40 ? "" : name,4,true);
        mColumnHeader = new Button(this,0,h-20,w,20,name,4,true);
        mColumnHeader->SetAlign(oglLeftAlign);
        mColumnHeader->SetAlignOffsets(4,0);
        //mColumnHeader->ConnectTo(this, T2T|B2T|L2L|R2R);
        mColumnHeader->ConnectTo(this, OglGui::TOTOP| OglGui::TOLEFTRIGHT);
        mColumnHeader->SetButtonListener(this, 0);
        mColumnHeader->SetBackground(0xffffddee);

        mSortButton = new DirectionButton(mColumnHeader,w-16,2,16,16,3,-1);
        mSortButton->SetBackground(0xffffddee);
        mSortButton->ConnectTo(mColumnHeader,OglGui::TORIGHT);
        mSortButton->SetButtonListener(this, 0);

        mFilterTextField = new TextField(this, 0, h-40, w, 20, "");
        mFilterTextField->SetTextFieldListener(this, 0);
        //mFilterTextField->ConnectTo(this, T2T|B2T|L2L|R2R);
        mFilterTextField->ConnectTo(this, OglGui::TOTOP | OglGui::TOLEFTRIGHT);

        MenuTopPane* top = new MenuTopPane(this);
        Menu *filterMenu = new Menu(top, 1, 120);
        filterMenu->AddItem("filter " + mColumnName, 0);
        filterMenu->SetOptions(0, Menu::SEPARATOR, true);
        filterMenu->AddItem("strong match", 2);
        filterMenu->AddItem("less strong", 3);
        filterMenu->AddItem("weak match", 4);
        filterMenu->AddItem("very weak match", 5);
/*        filterMenu->AddItem("top 50%%", 5);
        filterMenu->AddItem("bottom 50%%", 6);
        filterMenu->AddItem("bottom 20%%", 7);
        filterMenu->AddItem("bottom 10%%", 8); */
        filterMenu->AddItem("everything", 9);

        filterMenu->SetMenuListener(this, 0);

        mFilterValueButton =
            new MenuOnButton(this, 0, h-40, w, 20, "Filter", filterMenu);
        //mFilterValueButton->ConnectTo(this, T2T|B2T|L2L|R2R);
        mFilterValueButton->ConnectTo(this, OglGui::TOTOP|OglGui::TOLEFTRIGHT);

        mFilter = new TableFilter(mSource, mColumnName);
        mSource->RegisterFilter(mFilter);

        mColWidth = w;
        mColWidthDynamic = false;
        //UpdateRows();
    }

    static int                  sHeaderHeight;

    bool                        mColWidthDynamic;
    int                         mDisplayMode;
    int                         mDisplayAttr;
    int                         mSortType;
    int                         mColWidth;

    String                      mColumnName;

    TableDataSource*            mSource;
    TableViewCache*             mCache;
    TableFilter*                mFilter;
    std::vector<TableCell*>     mCellCache;

    Button*                     mColumnHeader;
    DirectionButton*            mSortButton;
    TextField*                  mFilterTextField;
    MenuOnButton*               mFilterValueButton;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(TableColumn, Application.VideoExcel);

int TableColumn::sHeaderHeight = 40;

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

#endif // TableColumn_h

---