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

---

GridWindow.h

Go to the documentation of this file.

#ifndef MediaTable_GridWindow_h
#define MediaTable_GridWindow_h

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

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

#include "TableDataViewController.h"

namespace Impala {
namespace Application {
namespace MediaTable {

//using namespace OglGui;
//class TableWindowColumn;

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

    GridWindow(Window* parent, TableDataView *view, int width, int height) :
        Window(parent, width, height),
                TableDataViewController(view)
    {
        Init(width, height);
    }

    GridWindow(Window* parent, TableDataView *view, int x, int y,
               int width, int height) :
        Window(parent, x, y, width, height),
                TableDataViewController(view)
    {
        Init(width, height);
    }

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

    void HandleLayoutChange()
    {
        UpdateNumberOfRowsEvent();
    }

    void SetGetOglImageByIdInterface(OglGui::GetOglImageByIdInterface* i)
    {
        mCache->SetGetOglImageByIdInterface(i);
    }

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

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

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

        UpdateNumberOfRowsEvent();
        UpdateRowsEvent();
    }

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

        mCache->HideViews();

        int startRow = GetTableDataView()->GetStartRow();
        int nx       = GetGridColumns();
        int ny       = GetGridRows();
        int x        = 0;
        int y        = 0;
        for (int i=startRow; i<startRow+GetTableDataView()->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 GetTableDataView()->GetStartRow()+ py * GetGridColumns() + px;
    }

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

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

// Listeners

    virtual void UpdateRowsEvent()
    {
        ILOG_DEBUG("GridWindow: UpdateRowsEvent");
        mReady = false;
        if (GetTableDataView()->GetFilteredRows() == GetTableDataView()->GetNumberOfRows())
            mVertScrollBar->SetVisible(false);
        else
        {
            mVertScrollBar->SetVisible(true);
            ILOG_DEBUG("Setting scrollbar SIZE to " << GetTableDataView()->GetFilteredRows() << " vs " << GetTableDataView()->GetNumberOfRows());
            mVertScrollBar->SetRange(GetTableDataView()->GetFilteredRows(), GetTableDataView()->GetNumberOfRows());
        }
        if (mVertScrollBar->GetValue() > GetTableDataView()->GetFilteredRows())
        {
            ILOG_DEBUG("scrollbar out of range, resetting.");
            mReady = true;
            mVertScrollBar->SetValue(0);
            GetTableDataView()->SetStartRow(0);
            UpdateScene();
        }
//        GetTableDataView()->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.");
        GetTableDataView()->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:
        GetTableDataView()->SetStartRow(position / GetGridColumns() * GetGridColumns());

    }

    virtual void UpdateScrollFromSourceEvent()
    {
        ILOG_DEBUG("GridWindow: UpdateScrollFromSourceEvent()");
        mVertScrollBar->SetValue(GetTableDataView()->GetStartRow());
    }

    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);
            ILOG_USER("GridWindow mouse wheel up");
        }
        if (msg == oglMouseWheelDown)
        {
            mVertScrollBar->ChangePos(mVertScrollBar->LineIncrement() * nLine);
            ILOG_USER("GridWindow mouse wheel down");
        }

        int row = -1;
        if (mShowZoomView)
            UpdateZoomView(row, x,y);

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

        if (msg == oglMouseDown && but == oglLeftButton)
        {
            if (row == -1)
                row = GetRowForXY(x, y);
            if (row >= 0)
            {
                if (state & oglShift && mLastSelectedRow != -1)
                {
                    ILOG_USER("GridWindow mouse shift-select range " << mLastSelectedRow <<
                               " to " << row);
                    GetTableDataView()->MarkRange(mLastSelectedRow, row, 1, true);
                    mLastSelectedRow = -1;
                }
                else
                {
                    ILOG_USER("GridWindow mouse click mark row " << row);
                    GetTableDataView()->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)
        {
                        if (mSelecting)
                                ILOG_USER("grid mouse drag select completed");
            mSelecting = false;
            GetTableDataView()->DoUpdateSelectionEvent();
            ILOG_USER("GridWindow drag select finished");
        }
        if (msg == oglMouseDown && but == oglRightButton)
        {
                        ILOG_USER("mouse open right context menu");
            int rx=0, ry=0;
            ToTopWindow(this, rx, ry);
            OpenContextMenu(rx+x,ry+y);
        }
    }


    virtual void KeyboardFunc(int c, int state)
    {
        ILOG_USER("GridWindow keyboard func " << c << " state: " << state);
        switch (c)
        {
            case oglUP:
                ScrollRelative(-GetGridColumns());
                break;
            case oglDOWN:
                ScrollRelative(+GetGridColumns());
                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;
                        default:
                                TableDataViewController::KeyboardFunc(c, state);
                                break;
        }
    }

    bool GetShowPreview()
    {
        return mShowZoomView;
    }

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

    /* 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 mainMediaTable, 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 (zx + mZoomViewSize > mZoomViewTargetWindow->W())
            zx = mZoomViewTargetWindow->W() - mZoomViewSize;

        if (row == -1)
            row = GetRowForXY(x, y);
        if (mZoomViewFollowMouse)
            viewSys.SetDimensions(mZoomView, zx, zy, mZoomViewSize, mZoomViewSize);
        if (mZoomView->UserData1 != (void *) row)
        {
                        if(!GetTableDataView()->OutOfBounds(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;
            if (x + mZoomViewSize > mZoomViewTargetWindow->W())
                x = mZoomViewTargetWindow->W() - 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;

                unsigned long long quid = GetTableDataView()->GetSortedQuid(mImageColumn, row);
        OGLVIEW* v = mCache->GetViewFromCache(quid);
                if (!v || v->UserData2 == (void*)2 || v->im == 0) { // image not currently in cache?
                        ILOG_DEBUG("Could not find view " << quid << " (row: " << row << ") 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;
            GetTableDataView()->MarkAllRows(1, false);
        }

        for (int row = GetTableDataView()->GetStartRow(); row < GetTableDataView()->GetEndRow(); row++)
        {
            int px=0, py=0;
            GetXYForRow(row, px, py);
            
            if (mSelecting && mcy < py+mGridHeight && py < mcy + mch &&
                mcx < px+mGridWidth && px < mcx + mcw)
            {
                    GetTableDataView()->MarkRow(row, 1);
            }

            int mark = GetTableDataView()->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 :

    void
    Init(int w, int h)
    {
        mReady = false;

        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);

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

        mCache = new TableViewCache(this, GetTableDataView());
                
                InitContextMenu(this);

        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;

    TableViewCache*         mCache;

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

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(GridWindow, Application.MediaTable);

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

#endif // GridWindow_h

---