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

---

TableWindowColumn.h

Go to the documentation of this file.

#ifndef MediaTable_TableWindowColumn_h
#define MediaTable_TableWindowColumn_h

#include "TableDataView.h"
#include "TableWindowCell.h"
#include "ColumnListener.h"

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

namespace Impala {
namespace Application {
namespace MediaTable {

//using namespace OglGui;

class TableWindowColumn : public OglGui::SizableWindow,
                                                  OglGui::TextFieldListener,
                                                  OglGui::ButtonListener,
                                                  OglGui::MenuListener,
                          OglGui::WindowListener,
                          OglGui::CloseWindowListener,
                                                  OglGui::CheckBoxListener,
                                                  TableDataViewListener
{
public:
    typedef OglGui::SizableWindow               SizableWindow;
    typedef OglGui::TitledWindow                TitledWindow;
    typedef OglGui::Window                      Window;
    typedef OglGui::Button                      Button;
    typedef OglGui::DirectionButton             DirectionButton;
    typedef OglGui::CheckBox                        CheckBox;
    typedef OglGui::TextField                   TextField;
    typedef OglGui::MenuOnButton                MenuOnButton;
    typedef OglGui::MenuTopPane                 MenuTopPane;
    typedef OglGui::Menu                        Menu;
        typedef OglGui::StaticText                                      StaticText;


    const static int BTN_CONFIGURE = 1;
    const static int BTN_SORT      = 2;
    const static int BTN_APPLY_FILTER = 3;
    const static int BTN_REMOVE_FILTER = 4;

    TableWindowColumn(Window *parent, ColumnListener *l, TableDataView *source,
                CString name, int width=120) :
        SizableWindow(parent, width, parent->H())
    {
        ConnectTo(parent, OglGui::T2T | OglGui::B2B);
        Init(name, parent, l, source, width, parent->H());
    }

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

    int GetDisplayMode() {
        return mDisplayMode;
    }

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

    TableViewCache* GetViewCache()
    {
        return mCache;
    }

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

    virtual void ButtonSelectionEvent(Button *src, void* userData)
    {
        switch ((long long) userData)
        {
            case BTN_CONFIGURE:
                OpenConfigWindow();
                break;
            case BTN_SORT:
                DoSort();
                break;
            case BTN_APPLY_FILTER:
                mConfigWindow->OnCloseButton();
                break;
            case BTN_REMOVE_FILTER:
                mFilter->Disable();
                mConfigWindow->OnCloseButton();
                break;
       }
   }

    void
    DoSort()
    {
        int t = 0;
        if (mDisplayMode == TableWindowCell::DISPLAY_TEXT ||
                mDisplayMode == TableWindowCell::DISPLAY_NUMBER)
            t = TableDataSource::TYPE_TEXT;
        if (mDisplayMode == TableWindowCell::DISPLAY_DOT ||
            mDisplayMode == TableWindowCell::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,!mSource->GetSortAscending());
        else
            mSource->SetSortColumn(mColumnName);
    }

    virtual bool OnCloseWindow(Window *src, void* userData)
    {
        ReleaseConfigWindow();
        return true;
    }


    static int GetHeaderHeight()
    {
        return sHeaderHeight;
    }

    static bool GetUpdatingColumnWidths()
    {
        return sUpdatingColumnWidths;
    }

    static void SetUpdatingColumnWidths(bool value)
    {
        sUpdatingColumnWidths = value;
    }

    int GetColumnWidth()
    {
        return mColWidth;
    }

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

    bool GetColumnWidthDynamic()
    {
        return mColWidthDynamic;
    }

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

        UpdateHeader();
    }

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

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

private:

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

    // set filter events for a column:


    void OpenConfigWindow()
    {

        int zx = 0;
        int zy = 6;
        // RvB: To stop proliferation of constantly adding new MenuTopPanes
        if (mMenuTopPane)
            // RvB: Also results in destroying any previous menu's in it.
            delete mMenuTopPane;
        MenuTopPane* top = mMenuTopPane = new MenuTopPane(this);

        oglSys.VPToTopWndI(mColumnHeader->GetOGLWND(),&zx,&zy);
        oglSys.TopWndToVPI(top->GetOGLWND(),&zx,&zy);

        if(zx+320 > GetParent()->W())
            zx = GetParent()->W()-320;

        mConfigWindow = new TitledWindow(top, zx, zy-120, 320, 120,
                                         "Filter on column " + mColumnName,
                                         TitledWindow::BtnClose);
        // RvB: To prevent dragging or sizing the mConfigWindow
        mConfigWindow->SetAllowMoveDirections(TitledWindow::AllDir,false);
        mConfigWindow->SetAllowSizeDirections(TitledWindow::AllDir,false);
        mConfigWindow->SetToFrontOnMouseDown(false);
        mConfigWindow->SetBackground(0xddffffff);
        mConfigWindow->SetRoundness(0, 0, 0 ,0);
        mConfigWindow->SetCloseWindowListener(this, 0);
        top->Open();

        mFilterTextField = new TextField(mConfigWindow, 10, 50, 280, 20, "");
        mFilterTextField->SetTextFieldListener(this, 0);
        mFilterTextField->ConnectTo(mConfigWindow, OglGui::TOTOP | OglGui::TOLEFTRIGHT);

                mFilterHelpAsc = new StaticText(mConfigWindow, 10, 70, 280, 20, "Enter lowest number to show");
                mFilterAscButton = new CheckBox(mConfigWindow,280-120, 30, 120, 20, "invert filter", false);
        mFilterAscButton->ConnectTo(mConfigWindow,OglGui::TOTOP | OglGui::TOLEFTRIGHT);
        mFilterAscButton->SetVisible(false);
                mFilterAscButton->SetCheckBoxListener(this, 0);
                
        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("everything", 9);

        filterMenu->SetMenuListener(this, 0);

        mFilterValueButton =
            new MenuOnButton(mConfigWindow, 10, 60, 280, 20, "Filter", filterMenu);
        mFilterValueButton->ConnectTo(mConfigWindow, OglGui::TOTOP|OglGui::TOLEFTRIGHT);

        Button *apply = new Button(mConfigWindow, 200, 10, 100, 20, "Apply filter");
        Button *disable = new Button(mConfigWindow, 80, 10, 100, 20, "Remove filter");
        apply->SetButtonListener(this, BTN_APPLY_FILTER);
        disable->SetButtonListener(this, BTN_REMOVE_FILTER);

        // show only relevant config items:
                mFilterHelpAsc->SetVisible(false);
                mFilterAscButton->SetVisible(false);
        switch (mDisplayMode)
        {
                        case TableWindowCell::DISPLAY_TEXT:
                mFilterTextField->SetVisible(true);
                mFilterTextField->SetText(mFilter->GetTextFilter());
                mFilter->SetTextFilter(mFilterTextField->GetText());
                mFilterValueButton->SetVisible(false);
                break;
            case TableWindowCell::DISPLAY_NUMBER:
                mFilterTextField->SetVisible(true);
                mFilterTextField->SetText(mFilter->GetTextFilter());
                mFilter->SetTextFilter(mFilterTextField->GetText());
                mFilterValueButton->SetVisible(false);
                                mFilterHelpAsc->SetVisible(true);
                                mFilterAscButton->SetVisible(true);
                break;
            case TableWindowCell::DISPLAY_IMAGE:
                mFilterTextField->SetVisible(false);
                mFilterValueButton->SetVisible(false);
                break;
            case TableWindowCell::DISPLAY_DOT:
            case TableWindowCell::DISPLAY_FILLED:
                mFilterTextField->SetVisible(false);
                mFilterValueButton->SetVisible(true);
                break;
        }
if (mFilterTextField->GetVisible())
    oglFocusWnd = mFilterTextField->GetOGLWND();

        //if (!sOverlayWindow)
        //    return;
        //mConfigWindow->SetVisible(true);
        //sOverlayWindow->SetBackground(0xCC000000);
        //oglSys.SetNoMouseInput(sOverlayWindow->GetOGLWND(),0);
        return;
    }

    void ReleaseConfigWindow()
    {
        // RvB: To make sure it is not masking the complete window anymore
        if (mMenuTopPane)
            mMenuTopPane->Hide();

        UpdateHeader();
        //sOverlayWindow->SetBackground(0);
        //oglSys.SetNoMouseInput(sOverlayWindow->GetOGLWND(),1);
        //mConfigWindow->SetVisible(false);
    }



        
    // process filter events generated from the possible filters:

        
    virtual void // text filter
    TextFieldChangedEvent(TextField *src, void* userData)
    {
                
        if (mDisplayMode == TableWindowCell::DISPLAY_TEXT)
            mFilter->SetTextFilter(src->GetText());
                        
                if (mDisplayMode == TableWindowCell::DISPLAY_NUMBER)
                {
                        bool asc = mFilterAscButton->GetSelected();
                        int number = atoi(src->GetText());
                        ILOG_DEBUG("number = " << number << " asc= " << asc);
                        mFilter->SetValueFilter(number, asc);
                }

        UpdateHeader();
    }

        // checkbox
        virtual void CheckBoxEvent(CheckBox *src, bool checked, void* userData)
    {
                if (src == mFilterAscButton)
                        TextFieldChangedEvent(mFilterTextField, 0);
    }
        
    // 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;
        }
        UpdateHeader();
    }

    virtual void
    WindowReshapeEvent(Window *source, int w, int h, void *userData)
    {
        if (userData == (void*) 2 && !GetUpdatingColumnWidths())
        {
            ILOG_USER("Manual reshape of column " << mColumnName << ": " << w << " x " << h);
            if (w < 20)
                mColWidthDynamic = true;
            else
                mColWidthDynamic = false;
            SetDimensions(RETAIN, RETAIN, w, RETAIN);
            mColumnListener->ColumnWidthUpdated();
        }
    }


    virtual void
    WindowMouseEvent(Window *src, int msg, int but, int state,
                     int x, int y, void *userData )
    {
                if (userData == (void*) 2 && (x < mColumnHeaderButton->W()-2))
                        mColumnHeaderButton->MouseFunc(msg, but, state, x, y);
        if (userData == (void*) 1)
        {
            if (msg == oglMouseEnter)
                mSortButton->SetVisible(true);
            if (msg == oglMouseLeave)
            {
                if (!mIsActiveSortColumn)
                    mSortButton->SetVisible(false);
            }
        }
    }

    void
    UpdateHeader()
    {
        if (mFilter->IsDisabled())
        {
            mColumnHeaderButton->SetBackground(0xffffddee);
        }
        else
        {
            mColumnHeaderButton->SetBackground(0xffbbbbff);
        }
    }

    void
    Init(String name, Window *parent, ColumnListener *l, TableDataView *source, int w, int h)
    {
        mSource             = source;
        mColumnName         = name;
        mCache              = 0;
        mDisplayMode        = TableWindowCell::DISPLAY_TEXT;
        mDisplayAttr        = TableWindowCell::NONE;
        mColumnListener     = l;
        mIsActiveSortColumn = false;

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

        // build the column GUI
        oglSys.SetNoMouseInput(GetOGLWND(),1);
        //mColumnHeaderButton = new Button(this,0,h-20,w,20,w<40 ? "" : name,4,true);
        mColumnHeader = new SizableWindow(this, 0, h-20, w, 20);
        mColumnHeader->ConnectTo(this, OglGui::TOTOP| OglGui::TOLEFTRIGHT);

        mColumnHeader->SetAllowMoveDirections(SizableWindow::AllDir, false);
        mColumnHeader->SetAllowSizeDirections(SizableWindow::AllDir, false);
        mColumnHeader->SetAllowSizeDirections(SizableWindow::East, true);
        mColumnHeader->SetMoveCursor(oglCursorE);
        mColumnHeader->SetMoveFeedback(false);
        mColumnHeader->SetDoStateFeedback(false);
        mColumnHeader->SetBorderType(0);
        mColumnHeader->SetMinMaxSizes(10, 600, RETAIN, RETAIN);
        mColumnHeader->SetWindowListener(this, 2);

        mColumnHeaderButton = new Button(mColumnHeader,0,0,w,20,name,4,true);
        mColumnHeaderButton->SetAlign(oglLeftAlign);
        mColumnHeaderButton->SetAlignOffsets(4,0);
        mColumnHeaderButton->ConnectTo(mColumnHeader, OglGui::TOTOP| OglGui::TOLEFTRIGHT);
        mColumnHeaderButton->SetButtonListener(this, BTN_CONFIGURE);
        mColumnHeaderButton->SetBackground(0xffffddee);
        mColumnHeaderButton->SetWindowListener(this, 1);
                mColumnHeaderButton->SetNoMouseInput(true);

        mSortButton = new DirectionButton(mColumnHeaderButton,w-18,2,16,16,3,-1);
        mSortButton->SetBackground(0xffffddee);
        mSortButton->ConnectTo(mColumnHeaderButton,OglGui::TORIGHT);
        mSortButton->SetButtonListener(this, BTN_SORT);
        mSortButton->SetWindowListener(this, 1);
        mSortButton->SetVisible(false);
//        oglSys.SetNoMouseInput(mSortButton->GetOGLWND(),1);

        // set the items in the config window to 0:
        mFilterTextField = 0;
        mFilterValueButton = 0;

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

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

public:
    static bool                 sUpdatingColumnWidths;
        static int                  sHeaderHeight;
    int                         mDisplayMode;
    int                         mDisplayAttr;

private:
    bool                        mColWidthDynamic;
    int                         mSortType;
    int                         mColWidth;
    bool                        mIsActiveSortColumn;

    String                      mColumnName;

    TableDataView*              mSource;
    TableViewCache*             mCache;
    TableFilter*                mFilter;
    std::vector<TableWindowCell*>     mCellCache;

    SizableWindow*              mColumnHeader;
    Button*                     mColumnHeaderButton;

    TitledWindow*               mConfigWindow;
    DirectionButton*            mSortButton;
    TextField*                  mFilterTextField;
    MenuTopPane*                mMenuTopPane;
    MenuOnButton*               mFilterValueButton;
        StaticText*                                     mFilterHelpAsc;
        CheckBox*                                       mFilterAscButton;

    ColumnListener*             mColumnListener;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(TableWindowColumn, Application.MediaTable);

int     TableWindowColumn::sHeaderHeight = 20;
bool    TableWindowColumn::sUpdatingColumnWidths = false;

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

#endif // TableWindowColumn_h

---