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

---

GridWindow.h

Go to the documentation of this file.

#ifndef VideoExcel_GridWindow_h
#define VideoExcel_GridWindow_h

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

#ifndef OglGui_StaticText_h
#include "OglGui/StaticText.h"
#endif

namespace Impala {
namespace Application {
namespace VideoExcel {

//using namespace OglGui;
//class TableColumn;

class GridWindow : public OglGui::Window,
                   OglGui::ScrollBarListener,
                   public TableUpdateListener
{
public:
    typedef OglGui::Window                      Window;
    typedef OglGui::ScrollBar                   ScrollBar;
    typedef OglGui::WindowScrollBar             WindowScrollBar;

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

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

    void AddColumnsFromDataSource()
    {
        std::vector<TableSourceColumnDescription> c = mSource->GetColumns();
        ILOG_DEBUG("Searching for image column...");
        for (int i=0; i<c.size(); i++)
        {
            TableSourceColumnDescription d = c[i];
            if (d.GetType() == TableDataSource::TYPE_IMAGE)
            {
                ILOG_DEBUG("Found image column: " << d.GetName());
                mImageColumn = d.GetName();
                break;
            }
        }
        HandleLayoutChange();
    }

    void HandleLayoutChange()
    {
        UpdateNumberOfRowsEvent();
    }


    inline int GetGridRows()
    {
        int viewheight = H() - mGridHeaderHeight;
        return viewheight / mGridHeight;
    }

    inline int GetGridColumns()
    {
        // remove width of scrollbar too
        return (W() - 20) / mGridWidth;
    }

    void SetGridSize(int gx, int gy)
    {
        mGridHeight = gy;
        mGridWidth = gx;

        UpdateNumberOfRowsEvent();
        UpdateRowsEvent();
    }

    void UpdateGrid()
    {
        if (mImageColumn == "")
            return;

        mCache->HideViews();

        int startRow = mSource->GetStartRow();
        int nx       = GetGridColumns();
        int ny       = GetGridRows();
        int x        = 0;
        int y        = 0;
        for (int i=startRow; i<startRow+mSource->GetNumberOfRows(); i++)
        {
            int px = x * (mGridWidth + 4);
            int py = H() - mGridHeaderHeight-mGridHeight-(y * (mGridHeight+4));

            mCache->ShowView(mImageColumn, i, px+2, py+2, mGridWidth-4,
                             mGridHeight-4);
            if (++x>=nx)
            {
                y++;
                x = 0;
            }
        }
    }

    int GetRowForXY(int x, int y)
    {
        if (x == 0 || y == 0) return -1;

        y = H() - mGridHeaderHeight - y;

        int px = x / (mGridWidth+4);
        int py = y / (mGridHeight+4);
        //ILOG_DEBUG("GetRowForXY: " << px << ", " << py << " = " <<
        //           py*GetGridColumns()+px);
        return mSource->GetStartRow()+ py * GetGridColumns() + px;
    }

    void GetXYForRow(int row, int &px, int &py)
    {
        row-=mSource->GetStartRow();
        int y = row / GetGridColumns();
        int x = row % GetGridColumns();

        px = x * (mGridWidth + 4);
        py = H() - mGridHeaderHeight - mGridHeight - (y * (mGridHeight + 4));   
    }

// 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();
        }
//        mSource->MarkVisibleRows(2, true);
        UpdateGrid();
        mReady = true;
    }

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

    virtual void UpdateNumberOfRowsEvent()
    {
        ILOG_DEBUG("UpdateNumberOfRowsEvent: " << GetGridRows() << " rows, " <<
                   GetGridColumns() << " columns.");
        mSource->SetNumberOfRows(GetGridRows() * GetGridColumns());

        mVertScrollBar->SetLineIncrement(GetGridColumns());
    }

    virtual void OnScroll(ScrollBar *src, int position, void *userData)
    {
        if (!mReady) return;
        // round down to nearest whole line of images:
        mSource->SetStartRow(position / GetGridColumns() * GetGridColumns());

    }

    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)
    {
        int nLine = ((state&oglShift) ? 5 : 1);
        if (msg == oglMouseWheelUp)
            mVertScrollBar->ChangePos(-mVertScrollBar->LineIncrement() * nLine);
        if (msg == oglMouseWheelDown)
            mVertScrollBar->ChangePos(mVertScrollBar->LineIncrement() * nLine);

        int row = -1;
        if (mShowZoomView)
            UpdateZoomView(row, x,y);
        
        if (msg == oglMouseDown && but == oglLeftButton)
        {
            if (row == -1)
                row = GetRowForXY(x, 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();
        }
    }


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

            case oglUP:
                ScrollRelative(-GetGridColumns());
                break;

            case oglDOWN:
                ScrollRelative(+GetGridColumns());
                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;

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

            case 'x':
                   SetGridSize(96, 96); break;
            case 'c':
                   SetGridSize(128, 128); break;
            case 'v':
                   SetGridSize(256, 256); break;
            case 'b':
                   SetGridSize(384, 384); break;


        }
    }

    bool GetShowPreview()
    {
        return mShowZoomView;
    }

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


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

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

        mShowZoomView = show;
        if (mShowZoomView)
            viewSys.SetTags(mZoomView, visibleTag);
        else
        {
            viewSys.ClearTags(mZoomView, visibleTag);
            mZoomView->UserData1 = (void *) -1;
        }
    }

    void UpdateZoomView(int row, int x, int y)
    {
        // Richard:
        //  what I want to do here is to translate/scale the coordinates from this WindowTable view
        // to the window I designated as an overlay window in mainVideoExcel, there ought to be a nice
        // OGL function which handles this coordinate translation somewhere.

        // translation is now set manually for this layout:
        int transX = 0, transY = 140;

        int zx=x + transX;
        int zy=y + transY;
        if (zy + mZoomViewSize > mZoomViewTargetWindow->H())
            zy = mZoomViewTargetWindow->H() - mZoomViewSize;
        
        if (row == -1)
            row = GetRowForXY(x, 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;
        if (mZoomViewFollowMouse)
        {
            int x,y,w,h;
            viewSys.GetDimensions(mZoomView, &x,&y,&w,&h);
            if (y + mZoomViewSize > mZoomViewTargetWindow->H())
                y = mZoomViewTargetWindow->H() - mZoomViewSize;
            viewSys.SetDimensions(mZoomView, x,y,mZoomViewSize,mZoomViewSize);
            float zoom = (mZoomView->h)/(float)mZoomView->im->h;
            viewSys.SetZoom(mZoomView, zoom, zoom);
        }
    }

    void SetZoomView(int row)
    {
        if (!mCache || !mShowZoomView)
            return;

        OGLVIEW* v = mCache->GetViewFromCache(mSource->GetID(row));
        if (!v || v->UserData2 == (void*)2) // image not currently in cache?
            return;
        OGLIMAGE* im = v->im;
        viewSys.SetImage(mZoomView, im);

        float zoom = (mZoomView->h)/(float)im->h;
        viewSys.SetZoom(mZoomView, zoom, zoom);
    }

    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
    DisplayFunc()
    {
        OGC     myOGC;
        OGCSave(&myOGC);

        UpdateGrid();

        if (mCache && mCache->ProcessDelayLoad())
            UpdateScene();
        
        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);
        }

        for (int row = mSource->GetStartRow(); row < mSource->GetEndRow(); row++)
        {
            int px=0, py=0;
            GetXYForRow(row, px, py);

            if (mSelecting && mcy < py && py+mGridHeight < mcy + mch &&
                mcx < px && px+mGridWidth < mcx + mcw)
            {
                    mSource->MarkRow(row, 1);
            }

            int mark = mSource->GetMark(row);
            if (mark)
            {
                SetSolidFillColor(MarkToColor(mark));
                FillRectangle(px-1, py-1, mGridWidth+2, mGridHeight+2);
            }
        }

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

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

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 = 150;
        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)
    {
        mReady = false;

        mSource                 = source;
        mGridHeight             = 128;
        mGridWidth              = 128;
        mGridHeaderHeight       = 20;
        mImageColumn            = "";
        mSelecting              = false;
        mAutoZoom               = false;
        mZoomViewTargetWindow   = 0;
        mLastSelectedRow        = -1;

        // init zoom view:
        mZoomViewSize           = 384;
        mZoomView               = 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 );

        mCache = new TableViewCache(this, mSource);

        mReady = true;
    }

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

    int                     mZoomViewSize;
    int                     mGridHeight;
    int                     mGridWidth;
    int                     mGridHeaderHeight;
    int                     mMouseXS, mMouseYS, mMouseXE, mMouseYE;
    int                     mLastSelectedRow;

    String                  mImageColumn;

    TableDataSource*        mSource;
    TableViewCache*         mCache;

    Window*                 mHeaderWindow;
    Window*                 mZoomViewTargetWindow;
    WindowScrollBar*        mVertScrollBar;
    OGLVIEW*                mZoomView;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(GridWindow, Application.VideoExcel);

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

#endif // GridWindow_h

---