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

---

TableWindow.h

Go to the documentation of this file.

#ifndef VideoExcel_TableWindow_h
#define VideoExcel_TableWindow_h

#include "TableColumn.h"
#include "OglGui/WindowScrollBar.h"

namespace Impala {
namespace Application {
namespace VideoExcel {

class TableWindow : public OglGui::Window,
                    OglGui::ScrollBarListener,
                    public TableUpdateListener
{
public:
    typedef OglGui::Window                          Window;
    typedef OglGui::ScrollBar                       ScrollBar;
    typedef OglGui::ScrollBarListener               ScrollBarListener;
    typedef OglGui::WindowScrollBar                 WindowScrollBar;
    typedef Impala::Core::Array::Array2dVec3UInt8   Array2dVec3UInt8;
    typedef OglGui::MenuTopPane                     MenuTopPane;
    typedef OglGui::Menu                            Menu;

    TableWindow(Window* parent, TableDataSource *source, int width, int height):
        Window(parent, width, height)
    {
        Init(source, width, height);
    }

    TableWindow(Window* parent, TableDataSource *source, int x, int y,
                int width, int height) :
        Window(parent, x, y, width, height)
    {
        Init(source, width, height);
    }

private:
    void AddColumnFromDescription(TableSourceColumnDescription d,
                                  bool dynamicWidth=false)
    {
        TableColumn *p = new TableColumn(this,mSource,d.GetName(),d.GetWidth());
        if (dynamicWidth)
            p->SetColumnWidthDynamic(true);
        switch (d.GetType())
        {
            case TableDataSource::TYPE_TEXT:
                p->SetDisplayMode(TableCell::DISPLAY_TEXT);
                break;
            case TableDataSource::TYPE_INT:
                p->SetSortType(TableDataSource::TYPE_INT);
                break;
            case TableDataSource::TYPE_DOUBLE:
                p->SetSortType(TableDataSource::TYPE_DOUBLE);
                break;
            case TableDataSource::TYPE_IMAGE:
                p->SetDisplayMode(TableCell::DISPLAY_IMAGE);
                if (mZoomViewCache == 0)
                    SetZoomViewCache(p->GetViewCache());
                break;
            case TableDataSource::TYPE_NORMALIZEDVALUE:
                if (dynamicWidth)
                    p->SetDisplayMode(TableCell::DISPLAY_FILLED,d.GetVisParam());
                else
                    p->SetDisplayMode(TableCell::DISPLAY_DOT, d.GetVisParam());
                break;
        }
        AddColumn(p);
    }

    void AddColumn(TableColumn* col, int insertAt=-1)
    {
        if (insertAt==-1 || insertAt>mColumns.size()-1)
            mColumns.push_back(col);
        else
            mColumns.insert(mColumns.begin()+insertAt+1,col);
        col->SetAllowReposition(false);
    }

public:
    void AddColumnsFromDataSource()
    {
        std::vector<TableSourceColumnDescription> c = mSource->GetColumns();
        ILOG_DEBUG("Adding " << c.size() << " fixed columns from datasource");
        int swidth = 0;
        for (int i=0; i<c.size();i++)
        {
            AddColumnFromDescription(c[i]);
            swidth += c[i].GetWidth();
        }

        mStaticColumnWidth = swidth;
        mStaticColumnCount = c.size();

        std::vector<TableSourceColumnDescription> d=mSource->GetExtraColumns();
        ILOG_DEBUG("Adding " << d.size() << " dynamic columns from datasource");
        for (int i=0; i<d.size();i++)
        {
            AddColumnFromDescription(d[i], true);
        }

        HandleColumnPositions();
        HandleLayoutChange();
    }

    void HandleColumnPositions()
    {
        int x,y,w,h;
        int mx = 0;
        int maxw = W() - 60;
        int wpc = 0;
        if (mColumns.size() - mStaticColumnCount > 0)
           wpc = (maxw-mStaticColumnWidth)/(mColumns.size()-mStaticColumnCount);

        for (int i=0; i<mColumns.size(); i++)
        {
            mColumns[i]->GetDimensions(x,y,w,h);
            x = mx;
            if (mColumns[i]->GetColumnWidthDynamic())
                w = wpc;

            mx += w + 2;
            mColumns[i]->SetDimensions(x,y,w,h);
            /*
            ILOG_DEBUG("Col " << i << " dyn?" <<
                       mColumns[i]->GetColumnWidthDynamic() << " x=" << x <<
                       " w=" << w);
            */
        }
    }

    void HandleLayoutChange()
    {
        UpdateNumberOfRowsEvent();
    }

    void ResetFilters()
    {
        ILOG_DEBUG("Reset filters");
        for (int x = 0; x < mColumns.size(); x++)
            mColumns[x]->ResetFilter(false);
        mSource->ApplyFilters();
    }

// Listeners

    virtual void UpdateRowsEvent()
    {
        mReady = false;
        if (mSource->GetFilteredRows() == mSource->GetNumberOfRows())
            mVertScrollBar->SetVisible(false);
        else
        {
            mVertScrollBar->SetVisible(true);
            mVertScrollBar->SetRange(mSource->GetFilteredRows(),
                                     mSource->GetNumberOfRows());
        }
        if (mVertScrollBar->GetValue() > mSource->GetFilteredRows())
        {
            ILOG_DEBUG("scrollbar out of range, resetting.");
            mReady = true;
            mVertScrollBar->SetValue(0);
            mSource->SetStartRow(0);
            UpdateScene();
        }
        mReady = true;
    }

    virtual void UpdateNumberOfRowsEvent()
    {
        mSource->SetNumberOfRowsInPixels(H() - TableColumn::GetHeaderHeight());
    }

    virtual void OnScroll(ScrollBar *src, int position, void *userData)
    {
        if (!mReady) return;
        mSource->SetStartRow(position);

    }

    virtual void UpdateScrollFromSourceEvent()
    {
        mVertScrollBar->SetValue(mSource->GetStartRow());
    }

    void ScrollRelative(int nr)
    {
        mSource->SetStartRow(mSource->GetStartRow() + nr);
        UpdateScrollFromSourceEvent();
    }

    virtual void MouseFunc(int msg, int but, int state, int x, int y)
    {
        mMouseX = x; mMouseY = y;

        int nLine = ((state&oglShift) ? 5 : 1);
        if (msg == oglMouseWheelUp)
            mVertScrollBar->ChangePos(-mVertScrollBar->LineIncrement() * nLine);
        if (msg == oglMouseWheelDown)
            mVertScrollBar->ChangePos(mVertScrollBar->LineIncrement() * nLine);

        if (!mAutoZoom)
            UnZoomRows();
        else if (!mSelecting)
            ZoomRow(GetRowForY(y));

        if (msg == oglMouseEnter && mShowZoomView && mZoomView)
            viewSys.SetTags(mZoomView, visibleTag);
        if (msg == oglMouseLeave && mShowZoomView && mZoomView)
            viewSys.ClearTags(mZoomView, visibleTag);

        if (msg == oglMouseDown && but == oglLeftButton)
        {
            int row = GetRowForY(y);
            if (row >= 0)
            {
                if (state & oglShift && mLastSelectedRow != -1)
                {
                    ILOG_DEBUG("shift-select range " << mLastSelectedRow <<
                               " to " << row);
                    mSource->MarkRange(mLastSelectedRow, row, 1, true);
                    mLastSelectedRow = -1;
                }
                else
                {
                    mSource->MarkRow(row, 1, true, true);
                    mLastSelectedRow = row;
                }
            }
        }
        if (msg == oglMouseMove && (state & oglLeftButton))
        {
            mMouseXE = x;
            mMouseYE = y;
            if (!mSelecting)
            {
                mMouseXS = x;
                mMouseYS = y;
                mSelecting = true;
            }
        }
        if (msg == oglMouseUp && but == oglLeftButton)
        {
            mSelecting = false;
            mSource->DoUpdateSelectionEvent();
        }

        if (msg == oglMouseDown && but == oglRightButton)
        {
            int rx=0, ry=0;
            ToTopWindow(this, rx, ry);
            mContext->Open(rx+x,ry+y);
        }

    }

    virtual void KeyboardFunc(int c, int state)
    {
        switch (c)
        {
            case oglPAGEDOWN:
                ScrollRelative(mSource->GetNumberOfRows());
                break;
            case oglPAGEUP:
                ScrollRelative(-mSource->GetNumberOfRows());
                break;

            case oglUP:
                ScrollRelative(-1);
                break;

            case oglDOWN:
                ScrollRelative(+1);
                break;

            // 1-6 colorize mouse-marked selection
            case '1': TransformMarkedSelectionTo(1, 4); break;
            case '2': TransformMarkedSelectionTo(1, 8); break;
            case '3': TransformMarkedSelectionTo(1, 16); break;
            case '4': TransformMarkedSelectionTo(1, 32); break;
            case '5': TransformMarkedSelectionTo(1, 64); break;
            case '6': TransformMarkedSelectionTo(1, 128); break;

            // shift 1-6 recall colored selection to mouse-marked
            case '!': TransformMarkedSelectionTo(4, 1); break;
            case '@': TransformMarkedSelectionTo(8, 1); break;
            case '#': TransformMarkedSelectionTo(16, 1); break;
            case '$': TransformMarkedSelectionTo(32, 1); break;
            case '%': TransformMarkedSelectionTo(64, 1); break;
            case '^': TransformMarkedSelectionTo(128, 1); break;

            case 138: // Escape: unmark selection
                mSource->MarkAllRows(1, false);
                break;

            // debug toggle
            case 'z':
                mAutoZoom = !mAutoZoom;
                break;

            case 'x':
                   mSource->SetDefaultRowSizes(20, 80); break;
            case 'c':
                   mSource->SetDefaultRowSizes(15, 40); break;
            case 'v':
                   mSource->SetDefaultRowSizes(10, 80); break;
            case 'b':
                   mSource->SetDefaultRowSizes(10, 120); break;

            case '`':
                ShowZoomView(!mShowZoomView);
                break;
            case '~':
                ToggleZoomViewSize();
                break;
        }
    }

    bool GetAutoZoom()
    {
        return mAutoZoom;
    }

    void SetAutoZoom(bool zoom)
    {
        mAutoZoom = zoom;
    }

    bool GetShowPreview()
    {
        return mShowZoomView;
    }

    void SetShowPreview(bool zoom)
    {
        ShowZoomView(zoom);
    }

    void TransformMarkedSelectionTo(int sourcemask, int targetmask)
    {
        mSource->TransformMarkedTo(sourcemask, targetmask);
        mSource->DoUpdateSelectionEvent();
    }

    int GetRowForY(int sy)
    {
        int my = 0, h=H();
        for (int y = mSource->GetStartRow(); y < mSource->GetEndRow(); y++)
        {
            my += mSource->GetRowHeight(y);
            if ((h - TableColumn::GetHeaderHeight() - my) < sy)
                return y;
        }
        return -1;
    }

    void ZoomRow(int row)
    {
        mSource->SetZoomRow(row);
    }

    void UnZoomRows()
    {
        mSource->UnsetZoom();
    }

    /* zoom view */
    void ShowZoomView(bool show)
    {
        if (!mZoomViewCache)
            ILOG_WARNING("Zoom view disabled: no cache set.");
        if (!mZoomView)
            ILOG_WARNING("Zoom view disabled: no target window set.");

        if (mShowZoomView = show)
        {
            oglSys.SetAlwaysDraw(mZoomViewTargetWindow->GetOGLWND(), true);
            viewSys.SetTags(mZoomView, visibleTag);
        }
        else
        {
            viewSys.ClearTags(mZoomView, visibleTag);
            mZoomView->UserData1 = (void *) -1;
            oglSys.SetAlwaysDraw(mZoomViewTargetWindow->GetOGLWND(), false);
        }
    }

    void UpdateZoomView(int row, int x, int y)
    {
        int zx = x;
        int zy = y;

        oglSys.VPToTopWndI(mOglWnd,&zx,&zy);
        oglSys.TopWndToVPI(mZoomViewTargetWindow->GetOGLWND(),&zx,&zy);
        if (zy + mZoomViewSize > mZoomViewTargetWindow->H())
            zy = mZoomViewTargetWindow->H() - mZoomViewSize;

        if (row == -1)
            row = GetRowForY(y);
        if (mZoomViewFollowMouse)
            viewSys.SetDimensions(mZoomView,zx,zy,mZoomViewSize,mZoomViewSize);
        if (mZoomView->UserData1 != (void *) row)
            SetZoomView(row);
    }

    void ToggleZoomViewSize()
    {
        int newsize;
        switch (mZoomViewSize)
        {
            case 128: newsize = 256; break;
            case 256: newsize = 384; break;
            case 384: newsize = 512; break;
            case 512: newsize = 768; break;
            case 768: newsize = 1024; break;
            case 1024: newsize = 128; break;
        }
        mZoomViewSize = newsize;
        int x,y,w,h;
        viewSys.GetDimensions(mZoomView,&x,&y,&w,&h);
        viewSys.SetDimensions(mZoomView,x,y,mZoomViewSize,mZoomViewSize);
/*
        if (y + mZoomViewSize > mZoomViewTargetWindow->H())
            y = mZoomViewTargetWindow->H() - mZoomViewSize;
        viewSys.SetDimensions(mZoomView,x,y,mZoomViewSize,mZoomViewSize);
*/
    }

    void UpdateVideoFrame()
    {
        if (!mZoomViewVideoEnabled || !mZoomImage || !mShowZoomView) return;

        Array2dVec3UInt8 *v = mSource->GetSortedVideoData("", mZoomViewRow);
        if (!v)
            return;

        Array2dVec3UInt8* old = (Array2dVec3UInt8*)mZoomImage->imageHandle;
        if (old)
            delete old;
        if (mZoomImage->imageHandle = v)
        {
            mZoomImage->w = v->CW();
            mZoomImage->h = v->CH();
        }
    }

    void SetZoomView(int row)
    {
        if (!mZoomViewCache || !mShowZoomView || mZoomViewRow == row)
            return;

        mZoomViewRow = row;
        // mode 1: show video, if available
        Array2dVec3UInt8 *frame = mSource->GetSortedVideoData("", row);
        if (frame)
        {
            ILOG_DEBUG("SetZoomView: showing video preview for row " << row);
            mZoomViewVideoEnabled = true;
            if (!mZoomImage)
                mZoomImage = Visualization::RgbOglImage::OglImage(frame);
            else
            {
                if (mZoomImage->imageHandle)
                    delete mZoomImage->imageHandle;
                mZoomImage->imageHandle = frame;
                mZoomImage->w = frame->CW();
                mZoomImage->h = frame->CH();
            }
            viewSys.SetImage(mZoomView, mZoomImage);
            return;
        }

        // mode 2: use active image cache:
        mZoomViewVideoEnabled = false;
        OGLVIEW* v = mZoomViewCache->GetViewFromCache(mSource->GetID(row));
        if (!v || v->UserData2 == (void*)2) // image not currently in cache?
            return;
        OGLIMAGE* im = v->im;
        viewSys.SetImage(mZoomView, im);
    }

    void SetZoomViewCache(TableViewCache *c)
    {
        mZoomViewCache = c;
    }

    void SetZoomViewTargetWindow(Window *t, bool followMouse=false)
    {
        mZoomViewTargetWindow = t;
        mZoomView =
            viewSys.View2D(t->GetOGLWND(),0,0,0,mZoomViewSize, mZoomViewSize);
        viewSys.SetTags(mZoomView, FlexViewTags);
        int clearTags = visibleTag|showBorderTag|showBgTag|selectableTag;
        viewSys.ClearTags(mZoomView, clearTags);
        viewSys.SetColor(mZoomView, OGL_BG, oglTrLIGHTGREY);
        mZoomView->UserData1 = (void *) -1;
        mZoomViewFollowMouse = followMouse;
    }

// Overloaded standard OGL functions

    virtual void ReshapeFunc(int w, int h)
    {
        Window::ReshapeFunc(w,h);
        HandleColumnPositions();
        HandleLayoutChange();
    }

    virtual void DisplayFunc()
    {
        OGC     myOGC;
        OGCSave(&myOGC);

        int h = H(), w = W();
        int mx = 0, my = 0;
        int cx, cy, cw, ch;
        int mcx, mcy, mcw, mch;

        if (mSelecting)
        {
            mcx = (mMouseXS < mMouseXE) ? mMouseXS : mMouseXE;
            mcw = (mMouseXS < mMouseXE) ? mMouseXE-mMouseXS : mMouseXS-mMouseXE;
            mcy = (mMouseYS < mMouseYE) ? mMouseYS : mMouseYE;
            mch = (mMouseYS < mMouseYE) ? mMouseYE-mMouseYS : mMouseYS-mMouseYE;
            mSource->MarkAllRows(1, false);
        }

        SetStipple((short)oglDot);
        SetSolidLineColor(0xff777777);
        for (int x = 0; x < mColumns.size(); x++)
        {
            mColumns[x]->GetDimensions(cx,cy,cw,ch);
            mx += cw + 2;
            DrawLine(mx, 0, mx, h);
        }
        int hheight = TableColumn::GetHeaderHeight();
        my = hheight;
        for (int y = mSource->GetStartRow(); y < mSource->GetEndRow(); y++)
        {
            my += mSource->GetRowHeight(y);

            if (mSelecting && (mcy < (h-my) && (h-my) < mcy + mch))
                mSource->MarkRow(y, 1);

            int mark = mSource->GetMark(y);
            if (mark)
            {
                int markCol = MarkToColor(mark); // RvB: To prevent 4 calls
                SetSolidFillColor(markCol);
                FillRectangle(0, h - my, w - 20, mSource->GetRowHeight(y));
            }

            DrawLine(0, h - my, w - 20, h - my);
        }

        SetStipple((short)oglSolid);
        DrawLine(0, h - hheight, w - 20, h - hheight);
        DrawLine(w - 20, 0, w - 20, h - hheight);

        if (mSelecting)
        {
            // draw the current mouse selection:
            SetStipple((short)oglSolid);
            SetLineWidth(2.0f);
            SetSolidLineColor(0xff444466);
            DrawRectangle(mcx,mcy,mcw,mch);
        }

        OGCRestore(&myOGC);
        HandleZoomView();
        Window::DisplayFunc();
    }

private :

    void FitImageToZoomView()
    {
        if (mZoomView && mZoomView->im)
        {
            float zoom = (mZoomView->h)/(float)mZoomView->im->h;
            viewSys.SetZoom(mZoomView, zoom, zoom);
        }
    }

    void HandleZoomView()
    {
        if (mShowZoomView && mZoomView && viewSys.HasTags(mZoomView,visibleTag))
        {
            UpdateZoomView(-1, mMouseX, mMouseY);
            UpdateVideoFrame();
            FitImageToZoomView();
        }
    }

    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 = 160;
        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);
    }

    void Init(TableDataSource *source, int w, int h)
    {
        mSource                 = source;
        mReady                  = false;
        mSelecting              = false;
        mAutoZoom               = false;
        mZoomViewTargetWindow   = 0;
        mStaticColumnWidth      = 0;
        mStaticColumnCount      = 0;
        mLastSelectedRow        = -1;

        // init zoom view:
        mZoomViewSize           = 384;
        mZoomView               = 0;
        mZoomImage              = 0;
        mZoomViewVideoEnabled   = false;
        mZoomViewCache          = 0;
        mShowZoomView           = false;
        mZoomViewFollowMouse    = false;

        SetBackground(0xffffffff);
        SetBorderType(1);
        SetBorderFillShaded(-2);

        mSource->AddTableUpdateListener(this);

        mVertScrollBar = new WindowScrollBar(this, false);
        mVertScrollBar->SetRange(mSource->GetTotalRows(),
                                 mSource->GetNumberOfRows());
        mVertScrollBar->SetScrollBarListener(this, 0);
        oglSys.SetAllMouseMotion( mOglWnd, 1 );
        mReady = true;

        MenuTopPane* top = new MenuTopPane(this);
        mContext = new Menu(top, 1, 180);
        mContext->AddItem("Show more results like this", 1);
        mContext->AddItem("Add selection to bucket:", 2);
        mContext->AddItem("red", 3);
        mContext->AddItem("green", 4);
        mContext->AddItem("blue", 5);
        mContext->AddItem("yellow", 6);
        mContext->AddItem("cyan", 7);
        mContext->AddItem("orange", 8);
        mContext->SetOptions(2, Menu::SEPARATOR, true);

        //mContext->SetMenuListener(this, 0);
    }

    bool                        mReady;
    bool                        mSelecting;
    bool                        mAutoZoom;
    bool                        mShowZoomView;
    bool                        mZoomViewFollowMouse;
    bool                        mZoomViewVideoEnabled;

    int                         mMouseX;
    int                         mMouseY;
    int                         mStaticColumnWidth;
    int                         mStaticColumnCount;
    int                         mZoomViewRow;
    int                         mZoomViewSize;
    int                         mLastSelectedRow;
    int                         mMouseXS, mMouseYS, mMouseXE, mMouseYE;

    TableDataSource*            mSource;
    std::vector<TableColumn*>   mColumns;
    TableViewCache*             mZoomViewCache;
    OGLVIEW*                    mZoomView;
    OGLIMAGE*                   mZoomImage;

    Window*                     mHeaderWindow;
    Window*                     mZoomViewTargetWindow;
    WindowScrollBar*            mVertScrollBar;

    Menu*                       mContext;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(TableWindow, Application.VideoExcel);

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

#endif // TableWindow_h

---