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

---

TableWindow.h

Go to the documentation of this file.

#ifndef MediaTable_TableWindow_h
#define MediaTable_TableWindow_h

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

#include "TableDataViewController.h"

namespace Impala {
namespace Application {
namespace MediaTable {

class TableWindow : public OglGui::Window,
                    OglGui::ScrollBarListener,
                                        ColumnListener,
                    public TableDataViewController
{
public:
    typedef OglGui::Window                          Window;
    typedef OglGui::ScrollWnd                       ScrollWnd;
    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, TableDataView* view, int width, int height):
        Window(parent, width, height),
                TableDataViewController(view)
    {
        Init(width, height);
    }

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

private:
    void AddColumnFromDescription(TableColumn* d,
                                  bool dynamicWidth=false)
    {
        TableWindowColumn *p = new TableWindowColumn(this,this,GetTableDataView(),d->GetName(),d->GetWidth());

        if (dynamicWidth)
            p->SetColumnWidthDynamic(true);
        switch (d->GetType())
        {
            case TableDataSource::TYPE_TEXT:
                p->SetDisplayMode(TableWindowCell::DISPLAY_TEXT);
                break;
            case TableDataSource::TYPE_INT:
                p->SetSortType(TableDataSource::TYPE_INT);
                p->SetDisplayMode(TableWindowCell::DISPLAY_NUMBER);
                break;
            case TableDataSource::TYPE_DOUBLE:
                p->SetSortType(TableDataSource::TYPE_DOUBLE);
                p->SetDisplayMode(TableWindowCell::DISPLAY_NUMBER);
                break;
            case TableDataSource::TYPE_IMAGE:
                p->SetDisplayMode(TableWindowCell::DISPLAY_IMAGE);
                if (mZoomViewCache == 0)
                    SetZoomViewCache(p->GetViewCache());
                break;
            case TableDataSource::TYPE_NORMALIZEDVALUE:
                if (dynamicWidth)
                    p->SetDisplayMode(TableWindowCell::DISPLAY_FILLED,d->GetVisParam());
                else
                    p->SetDisplayMode(TableWindowCell::DISPLAY_DOT, d->GetVisParam());
                break;
        }
        AddColumn(p);
    }

    void AddColumn(TableWindowColumn* 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<TableColumn*> c = GetTableDataView()->GetColumns(true, false);
        ILOG_DEBUG("Adding " << c.size() << " fixed columns from datasource");
        int swidth = 0;
        for (int i=0; i<c.size();i++)
        {
            AddColumnFromDescription(c[i]);
            if (c[i]->GetType() == TableDataSource::TYPE_IMAGE)
            {
                ILOG_DEBUG("Found image column: " << c[i]->GetName());
                mImageColumn = c[i]->GetName();
                        }
                        swidth += c[i]->GetWidth();
        }

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

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

        HandleColumnPositions();
        HandleLayoutChange();
    }

    void SetGetOglImageByIdInterface(OglGui::GetOglImageByIdInterface* i)
    {
        std::vector<TableWindowColumn*>::iterator iter;
        for(iter = mColumns.begin(); iter != mColumns.end(); iter++)
        {
                TableViewCache* cache = (*iter)->GetViewCache();
                if(cache)
                        cache->SetGetOglImageByIdInterface(i);
        }
    }


    void HandleColumnPositions()
    {
        int x,y,w,h;
        int mx = 0;
        int maxw = W() - 60;
        int wpc = 20;

        // phase 1: establish where each column should be displayed in an infinite table:
        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;
        }
        mHorScrollBar->SetRange(mx, W());

        // phase 2: redraw using the current scrollbar position:
        UpdateHorColumnPositions();
    }

    int GetColumnForX(int mx)
    {
        int x,y,w,h,xp = -mHorScrollPosition;
        for (int i=0; i<mColumns.size(); i++)
        {
            mColumns[i]->GetDimensions(x,y,w,h);
            xp += (w + 2);
            if (xp > mx)
                return i;
        }
        return 0;
    }
            

    void UpdateHorColumnPositions()
    {
        int x,y,w,h;
        int mx = -mHorScrollPosition;
        int maxw = W() - 60;
        int wpc = 20;

        TableWindowColumn::SetUpdatingColumnWidths(true);
        for (int i=0; i<mColumns.size(); i++)
        {
            mColumns[i]->GetDimensions(x,y,w,h);
            x = mx;
            if (mColumns[i]->GetColumnWidthDynamic())
            {
                if (mColumnCondenseEnabled)
                {                    
                    int dc = (mColumnCondense-i);
                    if (dc<0) dc=-dc;
                    double multiplier = 1.0;
                    if (dc == 4) multiplier = 1.1;
                    if (dc == 3) multiplier = 1.2;
                    if (dc == 2) multiplier = 1.6;
                    if (dc == 1) multiplier = 2.2;
                    if (dc == 0) multiplier = 6.0;
                    w = wpc * multiplier;
                } else {
                    w = wpc;
                }
            }
            mx += w + 2;
            mColumns[i]->SetDimensions(x,y,w,h);
        }
        UpdateRows();
        TableWindowColumn::SetUpdatingColumnWidths(false);
    }

    void ColumnCondense(int column)
    {
        if (column != mColumnCondense)
        {
            mColumnCondense = column;
            HandleColumnPositions();
        }
    }



    virtual void ColumnWidthUpdated()
    {
        HandleColumnPositions();
    }

    void HandleLayoutChange()
    {
        UpdateNumberOfRowsEvent();
    }

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

    void UpdateRows()
    {
        for (int col=0; col<mColumns.size(); col++)
        {
                if (mColumns[col]->GetDisplayMode() == TableWindowCell::DISPLAY_IMAGE)
                        mColumns[col]->GetViewCache()->HideViews();

                        int cindex  = 0;
                        int yoffset = TableWindowColumn::sHeaderHeight;
                        int startR  = GetTableDataView()->GetStartRow();
                        for (int i=startR; i<startR+GetTableDataView()->GetNumberOfRows(); i++)
                        {
                                TableWindowCell *c = mColumns[col]->GetCell(cindex++);
                                int yheight  = GetRowHeight(i);
                                yoffset += yheight;
                                c->UpdateRow(yoffset, i, yheight, mColumns[col]->mDisplayMode, mColumns[col]->mDisplayAttr);
                        }

                        // ensure the rest is not used/invisible:
                        mColumns[col]->HideCellsFrom(cindex);
        }
        UpdateScene();
    }


// Listeners

    virtual void UpdateRowsEvent()
    {
        //ILOG_DEBUG("TableWindow: UpdateRowsEvent");
                
        mReady = false;
        if (GetTableDataView()->GetFilteredRows() == GetTableDataView()->GetNumberOfRows())
            mVertScrollBar->SetVisible(false);
        else
        {
            mVertScrollBar->SetVisible(true);
            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();
        }
        mReady = true;
        UpdateRows();
    }

    virtual void UpdateNumberOfRowsEvent()
    {
                if(mLastSelectedRow != -1)
                {
                        // Show first selected row
                        GetTableDataView()->SetStartRowToFirstMarked(1);
                        UpdateScene();
        }
                mLastSelectedRow = -1;

        SetNumberOfRowsInPixels(H() - TableWindowColumn::GetHeaderHeight());
        }

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

        if (src == mHorScrollBar)
        {
            mHorScrollPosition = position;
            UpdateHorColumnPositions();
        }

    }

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

    void ScrollRelative(int nr)
    {
        GetTableDataView()->SetStartRow(GetTableDataView()->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);
            ILOG_USER("TableWindow mouse wheel up");
        }
        if (msg == oglMouseWheelDown)
        {
            mVertScrollBar->ChangePos(mVertScrollBar->LineIncrement() * nLine);
            ILOG_USER("TableWindow mouse wheel down");
        }
        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_USER("TableWindow shift-select range " << mLastSelectedRow <<
                               " to " << row);
                    GetTableDataView()->MarkRange(mLastSelectedRow, row, 1, true);
                }
                                else
                {
                                        if (!(state & oglControl))
                                        {
                                                ILOG_USER("TableWindow no ctrl -> unmark all " << row);
                                                GetTableDataView()->MarkAllRows(1, false); // unselect all
                                        }
                    ILOG_USER("TableWindow mouse click mark row " << row);
                    GetTableDataView()->MarkRow(row, 1, true, true);
                    mLastSelectedRow = row;                                     
                                }
                                GetTableDataView()->DoUpdateSelectionEvent();
            }
        }
        

        ColumnCondense(GetColumnForX(x));

        /* Dragging
                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("TableWindow drag select finished");
            mSelecting = false;
            GetTableDataView()->DoUpdateSelectionEvent();
        }*/

        if (msg == oglMouseDown && but == oglRightButton)
        {
                        ILOG_USER("mouse open right context menu on row " << GetRowForY(y));
            int rx=0, ry=0;
            ToTopWindow(this, rx, ry);
            OpenContextMenu(rx+x,ry+y);
        }

    }

    virtual void KeyboardFunc(int c, int state)
    {
        ILOG_USER("TableWindow keyboard func " << c << " | " << (char) c << " state: " << state);
        switch (c)
        {
            case 'x':
                   SetDefaultRowSizes(20, 80); break;
            case 'c':
                   SetDefaultRowSizes(15, 40); break;
            case 'v':
                   SetDefaultRowSizes(10, 80); break;
            case 'b':
                   SetDefaultRowSizes(10, 120); break;

            case '`':
                ShowZoomView(!mShowZoomView);
                break;
            case '~':
                ToggleZoomViewSize();
                break;
                        default:
                                TableDataViewController::KeyboardFunc(c, state);
        }
    }

    void SetNumberOfRowsInPixels(int pixels)
    {
        if (pixels <= 0)
            return;

        int yoff = 0;
        int rows = 0;
        for (int i=GetTableDataView()->GetStartRow(); i<GetTableDataView()->GetTotalRows(); i++)
        {
            if ((yoff += GetRowHeight(i)) > pixels)
                break;
            rows++;
        }
        // TODO: if (rows != GetTableDataView()->mDisplayRows)
        {
            ILOG_DEBUG("SetNumberOfRowsInPixels: " << pixels << " yields " <<
                       rows << " rows.");
            GetTableDataView()->SetNumberOfRows(rows);
        }
    }

    bool GetAutoZoom()
    {
        return mAutoZoom;
    }

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

    bool GetColumnCondense()
    {
        return mColumnCondenseEnabled;
    }

    void SetColumnCondense(bool val)
    {
        mColumnCondenseEnabled = val;
        UpdateHorColumnPositions();
    }

    bool GetShowPreview()
    {
        return mShowZoomView;
    }

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

    void TransformMarkedSelectionTo(int sourcemask, int targetmask)
    {
                ILOG_SYSTEM("transform marked from " << sourcemask << " to " << targetmask);
        GetTableDataView()->TransformMarkedTo(sourcemask, targetmask);
        GetTableDataView()->DoUpdateSelectionEvent();
    }

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

    /* individual row zooming support ****/
    // TODO: View Updaten

    void SetDefaultRowSizes(int unzoom, int zoom)
    {
        ILOG_DEBUG("SetDefaultRowSizes");
        mDefaultRowHeight = unzoom;
        mDefaultZoomRowHeight = zoom;
        GetTableDataView()->DoUpdateNumberOfRowsEvent();
        GetTableDataView()->DoUpdateRowsEvent();
    }

    virtual int GetRowHeight(int row)
    {
        if (mZoomRow > -1)
        {
            int dist = abs((row) - mZoomRow);
            if (dist > 5) return mDefaultRowHeight;
            double div;
            if (dist == 0) div = 1.0;
            if (dist == 1) div = 0.45;
            if (dist == 2) div = 0.25;
            if (dist == 3) div = 0.15;
            if (dist == 4) div = 0.1;
            if (dist == 5) div = 0.05;
            return (int)(mDefaultZoomRowHeight*div+mDefaultRowHeight*(1.0-div));
        }
        return mDefaultRowHeight;
    }

    void ZoomRow(int row)
    {
                if (row == mZoomRow)
                        return;
                if (GetTableDataView()->OutOfBounds(row))
                        return;
                if (mZoomRow == -1)
                        GetTableDataView()->DoUpdateNumberOfRowsEvent();
                mZoomRow = row;
                GetTableDataView()->DoUpdateRowsEvent();
    }

    void UnZoomRows()
    {
                if (mZoomRow == -1)
                        return;
                mZoomRow = -1;
                GetTableDataView()->DoUpdateNumberOfRowsEvent();
                GetTableDataView()->DoUpdateRowsEvent();
        }

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

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

        Array2dVec3UInt8 *v = GetTableDataView()->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 = GetTableDataView()->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;
                unsigned long long quid = GetTableDataView()->GetSortedQuid(mImageColumn, row);
        OGLVIEW* v = mZoomViewCache->GetViewFromCache(quid);
                if (!v || v->UserData2 == (void*)2) { // 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);
    }

    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 = -mHorScrollPosition, 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;
            GetTableDataView()->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;
            if (mx > 0)
                DrawLine(mx, 0, mx, h);
        }
        int hheight = TableWindowColumn::GetHeaderHeight();
        my = hheight;
        for (int y = GetTableDataView()->GetStartRow(); y < GetTableDataView()->GetEndRow(); y++)
        {
            my += GetRowHeight(y);

            /*if (mSelecting && (mcy < (h-my + GetRowHeight(y)) && (h-my) < mcy + mch))
                GetTableDataView()->MarkRow(y, 1);*/

            int mark = GetTableDataView()->GetMark(y);
            if (mark)
            {
                int markCol = MarkToColor(mark); // RvB: To prevent 4 calls
                SetSolidFillColor(markCol);
                FillRectangle(0, h - my, w - 20, 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);

        /* Disabled to fix MediaTable issue #32
                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();
        }
    }

    void Init(int w, int h)
    {
        mReady                  = false;
        //mSelecting              = false;
        mAutoZoom               = false;
        mColumnCondense         = false;
        mZoomViewTargetWindow   = 0;
        mStaticColumnWidth      = 0;
        mLastSelectedRow        = -1;

        mDefaultRowHeight               = 20;
        mDefaultZoomRowHeight   = 80;
        mZoomRow                                = -1;

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

        mHorScrollPosition      = 0;

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

        GetTableDataView()->AddTableDataViewListener(this);

        mVertScrollBar = new WindowScrollBar(this, false);
        mVertScrollBar->SetRange(GetTableDataView()->GetTotalRows(),
                                 GetTableDataView()->GetNumberOfRows());
        mVertScrollBar->SetScrollBarListener(this, 0);
        mVertScrollBar->SetBackground(0xffffffff);

        mHorScrollBar = new WindowScrollBar(this, true);
        mHorScrollBar->SetRange(1024,
                                 4000);
        mHorScrollBar->SetScrollBarListener(this, 0);
        mHorScrollBar->SetBackground(0xffffffff);


        oglSys.SetAllMouseMotion( mOglWnd, 1 );
        mReady = true;

                InitContextMenu(this);
    }

    bool                        mReady;
    bool                        mAutoZoom;
    bool                        mColumnCondenseEnabled;
    bool                        mShowZoomView;
    bool                        mZoomViewFollowMouse;
    bool                        mZoomViewVideoEnabled;

    int                         mMouseX;
    int                         mMouseY;
    int                         mStaticColumnWidth;
    int                         mStaticColumnCount;
    int                                                 mDefaultRowHeight;
    int                                                 mDefaultZoomRowHeight;
    int                                                 mZoomRow;
    int                         mZoomViewRow;
    int                         mZoomViewSize;
    int                         mLastSelectedRow;
    int                         mMouseXS, mMouseYS, mMouseXE, mMouseYE;
    int                         mHorScrollPosition;
    int                         mColumnCondense;


    std::vector<TableWindowColumn*>   mColumns;
    TableViewCache*             mZoomViewCache;
    OGLVIEW*                    mZoomView;
    OGLIMAGE*                   mZoomImage;
        String                                          mImageColumn;

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

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(TableWindow, Application.MediaTable);

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

#endif // TableWindow_h

---