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

---

TableViewCache.h

Go to the documentation of this file.

#ifndef VideoExcel_TableViewCache_h
#define VideoExcel_TableViewCache_h

#include "TableDataSource.h"
#include "ImageCache.h"

namespace Impala {
namespace Application {
namespace VideoExcel {

class TableViewCache
{
public:
    TableViewCache(OglGui::Window *table, TableDataSource* source)
    {
        Init(table, source);
    }

    OGLVIEW* GetViewFromCache(int id)
    {
        for (int i=0; i<mViews.size(); i++)
        {
            if ((void*)id == (mViews[i]->UserData1))
            {
                UpdateLRU(i);
                return mViews[i];
            }
        }
        return 0;
    }

    OGLVIEW *GetUnusedViewFromCache()
    {
        int item = mLRU.front();
        UpdateLRU(item);
        return mViews[item];
    }

    void HideViews()
    {
        for (int i=0; i<mViews.size(); i++)
            viewSys.ClearTags(mViews[i], visibleTag);
    }

    /* ShowView:
       positions a cached view with the specified image at the specified location
       or creates one if there wasn't already one.
       */
    void ShowView(String column, int row, int x, int y, int w, int h)
    {
        int id = mSource->GetID(row);
        OGLVIEW *v = GetViewFromCache(id);
        if (v)
        {
            if (v->UserData2 != (void*)2 && v->im)
            {
                UpdateZoom(v, w, h);
                v->UserData1 = (void*)id;
                viewSys.SetDimensions(v, x,y,w,h);
                viewSys.SetTags(v,visibleTag);
            }
        }
        if (!v)
        {
            v = GetUnusedViewFromCache();
            viewSys.SetDimensions(v,x,y,w,h);
            AddDelayLoad(column, id, v);
        }
    }

    /* AddDelayLoad:
       enqueues the image for an id to be loaded into v, and reserves v for
       this purpose.
    */
    void AddDelayLoad(String column, int id, OGLVIEW *v)
    {
        SetViewUserData(v, id, 2);
        mDelayedLoadQueue.push( std::make_pair(id, column) );
        //ILOG_DEBUG("Enqueing delayed load for " << id << ", now " <<
        //           mDelayedLoadQueue.size() << " items queued.");
    }

    /*  ProcessDelayLoad:
        looks which views where recently made visible (in mDelayedLoadeQueue)
        and loads their images. This function is to be called repeatedly, f.e.
        from DisplayFunc.
        returns; false when done.
                 true when there is more to do

        There is a limit to the numer of items loaded at once (even when multithreading),
        because there is a check here to see if an image which is still in the queue is
        still needed (which is not the case when the user scrolls rapidly)

        FUTURE:
            pending talks with Richard I'd like to rewrite this, all images in the
            load queue get pushed into the thread pool, when a thread is ready to
            actually load the image a verification is done if the image is still on
            screen. If this is not the case the load gets cancelled.

    */
    bool ProcessDelayLoad()
    {
        if (mDelayedLoadQueue.empty())
        {
            if (mImageCache->IsLoadingImages())
                return true;
            else
                return false;
        }

        OGLVIEW* v;
        for (int batch=0; batch < 45; batch++)
        {
            if (mDelayedLoadQueue.empty())
                return true;
            std::pair <int, String> cell = mDelayedLoadQueue.front();
            mDelayedLoadQueue.pop();
            int id = cell.first;
            while (mSource->OutOfBoundsByID(id))
            {
                //ILOG_DEBUG("Delayed loading of " << row <<
                //           " cancelled. Out of screen area.");

                // if cashed unhook v, to be requeued again when visible.
                if (v = GetViewFromCache(id))
                    SetViewUserData(v, -1, 0);
                if (mDelayedLoadQueue.empty())
                    return true;
                cell = mDelayedLoadQueue.front();
                mDelayedLoadQueue.pop();
                id = cell.first;
            }
            //ILOG_DEBUG("Delayed loading of " << row << ", " <<
            //           "mDelayedLoadQueue.size() << " items remaining.");
            if (!(v = GetViewFromCache(id)))
            {
                ILOG_ERROR("ID " << id << " was added to the queue, " <<
                           "but its view got stolen!");
                continue;
            }
            SetViewUserData(v, id, 0);

            String    column = cell.second;
            OGLIMAGE* oglIm  = mImageCache->GetImageFromCache(id, column);

            if (oglIm == 0)
            {
                oglIm = mImageCache->LoadImage(id, column);
//                batch+=2; // don't process too many pictures per DelayLoad
            }
            if (oglIm == 0)
                continue;
            viewSys.SetImage(v, oglIm);
        }
        return true;
    }

    void UpdateZoom(OGLVIEW *v, int w, int h)
    {
        if (!v || !v->im) return;

        float zoomX, zoomY;
        zoomY = zoomX = (v->w)/(float)v->im->w;
        viewSys.SetZoom(v, zoomX, zoomY);
    }
    
    void UpdateLRU(int index)
    {
        mLRU.remove(index);
        mLRU.push_back(index);
    }

private:

    void SetViewUserData(OGLVIEW* oglView, int data1, int data2)
    {
        if (!oglView) return;
        oglView->UserData1 = (void *) data1;
        oglView->UserData2 = (void *) data2;
    }

    // mCacheSize must be equal or smaller than that of ImageCache,
    // to allow ImageCache to still contain all OGLIMAGE's, so that
    // ImageCache actually works.

    // mCacheSize must be equal or larger than the maximum possible
    // amount of views on a single screen
    void Init(OglGui::Window *table, TableDataSource* source)
    {
        mTable      = table;
        mSource     = source;
        mCacheSize  = 400;
        ILOG_DEBUG("Init(" << mCacheSize << " items)");

        mImageCache = ImageCache::GetInstance();
        if (!mImageCache)
        {
            ILOG_ERROR("Could not retrieve image cache, segfault in a few " <<
                       "moments, please stand by.");
        }

        for (int i=0; i<mCacheSize; i++)
        {
            OGLVIEW* view = viewSys.View2D(mTable->GetOGLWND(),0,0,0,128,128);
            viewSys.SetTags(view, FlexViewTags);
            int clearTags = visibleTag|showBorderTag|showBgTag|selectableTag;
            viewSys.ClearTags(view, clearTags);
            viewSys.SetColor(view, OGL_BG, oglTrLIGHTGREY);
            SetViewUserData(view,-1, 0);
            mViews.push_back(view);
            mLRU.push_back(i);
        }
    }

    int                                     mCacheSize;

    TableDataSource*                        mSource;
    ImageCache*                             mImageCache;

    std::queue< std::pair<int, String> >    mDelayedLoadQueue;
    std::vector<OGLVIEW*>                   mViews;
    std::list<int>                          mLRU;

    OglGui::Window*                         mTable;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(TableViewCache, Application.VideoExcel);

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

#endif // TableViewCache_h

---