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

---

TableViewCache.h

Go to the documentation of this file.

#ifndef MediaTable_TableViewCache_h
#define MediaTable_TableViewCache_h

#include "TableDataView.h"
#include "TableDataStore.h"

#include "OglImageCacheStore.h"
#include "OglGui/GetOglImageByIdInterface.h"
#include "ImageLoader.h"

namespace Impala {
namespace Application {
namespace MediaTable {

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

    void SetGetOglImageByIdInterface(OglGui::GetOglImageByIdInterface* i)
    {
        mGetOglImageByIdI = i;
    }
        
    OGLVIEW* GetViewFromCache(unsigned long long quid)
    {
                if (mQuidToView.find(quid) != mQuidToView.end())
                {
                        return mViews[mQuidToView[quid]];
                }
                return 0;
    }

    int GetUnusedIndexFromCache()
    {
        int item = mLRU.front();
        UpdateLRU(item);
                std::map<unsigned long long, int>::iterator iter;
                for(iter = mQuidToView.begin(); iter != mQuidToView.end(); iter++)
                        if(iter->second == item)
                        {
                                ILOG_DEBUG("Bye bye " << iter->first);
                                mQuidToView.erase(iter);
                                break;
                        }
        return 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);
                unsigned long long quid = mSource->GetSortedQuid(column, row);
        OGLVIEW *v = GetViewFromCache(quid);
        if (v)
        {
            if (v->UserData2 != (void*)2 && v->im)
            {
                UpdateZoom(v, w, h);
//                              mViewsToQuid[quid] = GetViewIndexFromCache(quid);
//                v->UserData1 = (void*)quid;
                viewSys.SetDimensions(v, x,y,w,h);
                viewSys.SetTags(v,visibleTag);
            }
        }
        if (!v)
        {
            int index = GetUnusedIndexFromCache();
                        v = mViews[index];
            viewSys.SetDimensions(v,x,y,w,h);
            AddDelayLoad(quid, index);
        }
    }

    /* AddDelayLoad:
       enqueues the image for an id to be loaded into v, and reserves v for
       this purpose.
    */
    void AddDelayLoad(unsigned long long quid, int index)
    {
                OGLVIEW *v = mViews[index];
                mQuidToView[quid] = index;
        SetViewUserData(v, index, 2);
        mDelayedLoadQueue.push( quid );
        ILOG_DEBUG("Enqueing delayed load for " << quid << ", 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())
        {
                        ImageLoader* loader = dynamic_cast<ImageLoader*> (mGetOglImageByIdI);
                if(loader)
                                return loader->IsLoading();
                        else
                                return false;

        }

        OGLVIEW* v;
        for (int batch=0; batch < 45; batch++)
        {
            if (mDelayedLoadQueue.empty())
                return true;
            unsigned long long quid = mDelayedLoadQueue.front();
            mDelayedLoadQueue.pop();
                        if (mSource->OutOfBoundsByQuid(quid))
            {
                //ILOG_DEBUG("Delayed loading of " << row <<
                //           " cancelled. Out of screen area.");

                // if cashed unhook v, to be requeued again when visible.
                if (v = GetViewFromCache(quid))
                    SetViewUserData(v, -1, 0);
                continue;
            }
            //ILOG_DEBUG("Delayed loading of " << row << ", " <<
            //           "mDelayedLoadQueue.size() << " items remaining.");
            if (!(v = GetViewFromCache(quid)))
            {
                //ILOG_ERROR("QUID " << quid << " was added to the queue, " <<
                //           "but its view got stolen!");
                continue;
            }
            v->UserData2 = (void *) 0;
            OGLIMAGE* oglIm  = mOglImageCache->GetImage(quid);

            if ((oglIm == 0) && mGetOglImageByIdI)
            {
                oglIm = mGetOglImageByIdI->GetOglImageById(quid);
                mOglImageCache->Add(oglIm, quid);
//                batch+=2; // don't process too many pictures per DelayLoad
            }
            if (oglIm == 0)
                continue;
            viewSys.SetImage(v, oglIm);
                        ReleaseOglImage(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, TableDataView* source)
    {
        mTable      = table;
        mSource     = source;
        mCacheSize  = 400;
        ILOG_DEBUG("Init(" << mCacheSize << " items)");

        mGetOglImageByIdI = 0;
        mOglImageCache    = OglImageCacheStore::GetInstance();
        if (!mOglImageCache)
        {
            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;

    TableDataView*                              mSource;
    OglGui::OglImageCache*                  mOglImageCache;
        OglGui::GetOglImageByIdInterface*               mGetOglImageByIdI;

    std::queue< unsigned long long >            mDelayedLoadQueue;
    std::vector<OGLVIEW*>                                       mViews;
        std::map<unsigned long long, int>               mQuidToView;
    std::list<int>                          mLRU;

    OglGui::Window*                         mTable;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(TableViewCache, Application.MediaTable);

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

#endif // TableViewCache_h

---