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

---

RandomImageWindow.h

Go to the documentation of this file.

/*
 *  RandomImageWindow.h
 *  MediaTable
 *
 *  Created by Daan Odijk on 14-01-10.
 *  Copyright 2010 UvA. All rights reserved.
 *
 */

#ifndef Impala_Application_MediaTable_RandomImageWindow_h
#define Impala_Application_MediaTable_RandomImageWindow_h

#ifndef OglGui_WindowView2D_h
#include "OglGui/WindowView2D.h"
#endif

#include "../TableDataView.h"
#include "../TableViewCache.h"

#include "../TableDataViewController.h"

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

namespace Impala { namespace Application { namespace MediaTable {
                        
class RandomImageWindow : public OglGui::Window,
        public OglGui::WindowListener,
        public TableDataViewController
{
public:
        typedef OglGui::Window                                          Window;
        typedef OglGui::WindowView2D                            WindowView2D;
        typedef OglGui::StaticText                                      StaticText;
        typedef OglGui::GetOglImageByIdInterface        GetOglImageByIdInterface;
        typedef OglGui::OglImageCache                           OglImageCache;
        
        RandomImageWindow(Window* parent, TableDataView* view, 
                                          std::string &imageColumn, 
                                          int x, int y, int w, int h) :
                Window(parent,x,y,w,h),
                TableDataViewController(view)
        {
                Init(imageColumn, w,h);
        }
                                                
        virtual void DisplayFunc()
        {
                OGC oldOGC;
                OGCSave(&oldOGC);
                Window::DisplayFunc();
                if (GetTableDataView() != 0)
                {
                        ShowImages();
                }
                OGCRestore(&oldOGC);
        }
        
    void SetGetOglImageByIdInterface(GetOglImageByIdInterface* i)
    {
        mGetOglImageByIdI = i;
    }
        
    void SetOglImageCache(OglImageCache* oglImageCache)
    {
        mOglImageCache = oglImageCache;
    }
        
protected:

    OGLIMAGE* LoadViewImage(long long id)
    {
        if (!mOglImageCache || !mGetOglImageByIdI)
            return 0;
                
        OGLIMAGE* im = mOglImageCache->GetImage(id);
                
        if (!im && (im = mGetOglImageByIdI->GetOglImageById(id)))
            mOglImageCache->Add(im, id);
        return im;
    }
        
        virtual void InitViews()
        {
                mViews.clear();
                for (int i=0; i<GetTableDataView()->GetFilteredRows(); i++)
                {
                        int x = ABSRND(W()-64), y = ABSRND(H()-64);
                        OGLVIEW* view = viewSys.View2D(GetOGLWND(), 0, x, y, 64, 64);
                        viewSys.SetTags(view, FlexViewTags);
                        viewSys.ClearTags(view, deletableTag|showBgTag);
                        mViews.push_back(view);
                }
        }
        
        virtual void ShowImages()
        {
                if(mViews.size() != GetTableDataView()->GetFilteredRows())
                        InitViews();
                
                int px, py, pcol, w, h;
                for (int i=0; i<GetTableDataView()->GetFilteredRows(); i++)
        {
                        int x, y;
                        int col = TableDataViewController::MarkToColor(GetTableDataView()->GetMark(i));
                        OGLVIEW *view = mViews[i];
                        viewSys.SetColor(view, OGL_BORDER, col);
                        viewSys.GetDimensions(view, &x, &y, &w, &h);
                        
                        if(i > 0)
                                DrawColLine(px, py, x, y, pcol, col);

                        view->im=LoadViewImage(GetTableDataView()->GetSortedQuid(mImageColumn, i));
                                                
                        if (view->im)
                        {
                                view->zoomX = view->h / (float) view->im->w;
                                view->zoomY = view->w / (float) view->im->h;
                        }
                        viewSys.GetDimensions(view, &px, &py, &w, &h);
                        pcol = col;
                }
                SetSolidLineColor(oglGREEN);
                DrawRectangle(10, 10, 100, 100);
                DrawColLine     (50, 50, 50, 150, oglBLUE, oglRED);
                
        }
        
        virtual void KeyboardFunc(int c, int state)
        {
                switch (c)
                {
                        case ' ':
                                UpdateScene();
                                break;
                        default:
                                TableDataViewController::KeyboardFunc(c, state);
                }
        }
        
        virtual void MouseFunc(int msg, int btn, int state, int x, int y)
        {
        }
        
        // TODO: Implement listeners to TableDataView
        void UpdateNumberOfRows() {}
        void UpdateSelectionEvent() {}
        
private:
        void Init(std::string imageColumn, int w, int h)
        {
                mOglImageCache = 0;
                mGetOglImageByIdI = 0;
                mImageColumn = imageColumn;
                InitViews();
        }
        
protected:
        std::string                                     mImageColumn;
        OglImageCache*              mOglImageCache;
        GetOglImageByIdInterface*   mGetOglImageByIdI;
        
        std::vector<OGLVIEW*>           mViews;         
                
private:
        ILOG_VAR_DEC;
};

ILOG_VAR_INIT(RandomImageWindow, Application.MediaTable);
                        
} } } // namespace Impala::Application::MediaTable

#endif

---