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

---

TableOverviewWindow.h

Go to the documentation of this file.

#ifndef MediaTable_TableOverviewWindow_h
#define MediaTable_TableOverviewWindow_h

#include "TableDataView.h"

namespace Impala {
namespace Application {
namespace MediaTable {

class TableOverviewWindow : public OglGui::Window,
                            public TableDataViewListener
{
public:
    typedef OglGui::Window                  Window;

    TableOverviewWindow(OglGui::Window* parent, TableDataView *source,
                        int width, int height) :
    Window(parent, width, height)
    {
        Init(source, width, height);
    }

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

// Listeners

    virtual void UpdateSelectionEvent()
    {
        mPixelCacheSynced = false;
    }

    virtual void MouseFunc(int msg, int but, int state, int x, int y)
    {
        if ((msg==oglMouseDown || msg==oglMouseMove) && state==oglLeftButton)
        {
            //mDrawHeight = H() - 32;
            //mDrawOffset = 16;
            int row = PixelToRow(mDrawOffset+mDrawHeight - y);
                        ILOG_USER("overview window scroll event to "<<row);
            mSource->SetStartRow(row);
                        if (row + mSource->GetNumberOfRows() > mSource->GetTotalRows()) 
                                row = mSource->GetTotalRows() - mSource->GetNumberOfRows();
                        if (row != mSource->GetStartRow())
                        mSource->SetStartRow(row);
            mSource->DoUpdateScrollFromSourceEvent();
        }
    }

    // RvB: Empty???
    virtual void
    KeyboardFunc(int c, int state)
    {
    }

    virtual void ReshapeFunc(int w, int h)
    {
        Window::ReshapeFunc(w,h);
        mPixelCacheSynced = false;
    }

    inline int RowToPixel(int row)
    {
        return row * mDrawHeight / mSource->GetFilteredRows();
    }

    inline int PixelToRow(int pixel)
    {
        return pixel * mSource->GetFilteredRows() / mDrawHeight;
    }

    inline void PixelToRows(int pixel, int *startrow, int *endrow)
    {
        *startrow = PixelToRow(pixel);
        *endrow   = PixelToRow(pixel+1) -1 ;
        // RvB: Next line is nonsense
        // if (endrow < startrow) endrow = startrow;
    }

    void UpdatePixelCache(int height)
    {
        mSelPixelCache.clear();

        if (height < mSource->GetFilteredRows())
        {
            ILOG_DEBUG("Updating selection cache...");
            // more rows than pixels: sample the rows
            for (int pixelrow = 0; pixelrow < height; pixelrow++)
            {
                int start, stop;
                PixelToRows(pixelrow, &start, &stop);
                unsigned long avgcol = 0;
                for (int y=start; y<=stop; y++)
                {
                    int mark = mSource->GetMark(y);
                    if (mark)
                    {
                        avgcol = MarkToColor(mark);
                        break; // only take first color found,instead of average
                    }
                }

                mSelPixelCache.push_back(avgcol);
            }
            mPixelCacheSynced = true;
        }
    }

// Overloaded standard OGL functions

    virtual void DisplayFunc()
    {
        if (mSource->GetFilteredRows() == 0)
        {
            Window::DisplayFunc();
            return;
        }

        OGC     myOGC;
        OGCSave(&myOGC);
        SetStipple((short)oglDot);
        SetSolidLineColor(0xff777777);

        mDrawHeight = H() - 32 - mHeaderHeight;
        mDrawOffset = 16;
        // mark marked areas:
        if (mDrawHeight < mSource->GetFilteredRows())
        {
            if (mDrawHeight > mSelPixelCache.size())
                mPixelCacheSynced=false;

            // more rows than pixels: use cached version of sampled rows
            if (!mPixelCacheSynced)
                UpdatePixelCache(mDrawHeight);

            for (int i=0; i<mDrawHeight; i++)
            {
                unsigned long avgcol = mSelPixelCache[i];
                if (avgcol > 0)
                {
                    SetSolidFillColor(avgcol);
                    FillRectangle(0, mDrawOffset+mDrawHeight-i, W(), 1);
                }
            }
        }
        else
        {
            // less rows than pixels, draw blocks
            for (int y = 0; y < mSource->GetFilteredRows(); y++)
            {
                int mark = mSource->GetMark(y);
                if (mark)
                {
                    SetSolidFillColor(MarkToColor(mark));
                    int l = RowToPixel(1);
                    int s = RowToPixel(y) + l;
                    FillRectangle(0, mDrawOffset+mDrawHeight-s, W(), l+1);
                }
            }
        }

        // mark current visible area:
        SetSolidFillColor(0xffffffff);
        int l = RowToPixel(mSource->GetNumberOfRows());
        int s = RowToPixel(mSource->GetStartRow()) + l;
        FillRectangle(0,mDrawOffset+mDrawHeight-s, 8,l);
        FillRectangle(W()-8,mDrawOffset+mDrawHeight-s, 8,l);

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

    void
    SetHeaderHeight(int height)
    {
        ILOG_DEBUG("SetHeaderHeight(" << height << ")");
        mPixelCacheSynced = false;
        mHeaderHeight = height;
                mPixelCacheSynced = false;
    }

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 = 80;
        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(TableDataView *source, int w, int h)
    {
        mSource             = source;
        mReady              = true;
        mPixelCacheSynced   = false;
        mDrawHeight         = H();
        mDrawOffset         = 8;
        mHeaderHeight       = 0;

        mSource->AddTableDataViewListener(this);
        SetBackground(oglBLACK);
        SetBorderFillShaded(DEEP_SHADE_DOWN);
        SetBorderType(1);
    }

    TableDataView*            mSource;
    std::vector<unsigned long>  mSelPixelCache;

    bool                        mPixelCacheSynced;
    bool                        mReady;
    int                         mDrawHeight;
    int                         mDrawOffset;
    int                         mHeaderHeight;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(TableOverviewWindow, Application.MediaTable);

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

#endif // TableOverviewWindow_h

---