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

---

ViewStrip.h

Go to the documentation of this file.

/*
RvB: Still very immature. For now we concentrate on
    Impala::Visualization::ImageStrip.

    This view strip will be fully developed at a later time.
    -----------------------------------------------------------
    RvB: 08-06-2007
    At present using fixed aspectratio and non-smooth scrolling
    because of distorted display bug in partial visible viewers
    when not using texturing.
    This is only to allow the golden demo to work without distortion.
    The old ViewStrip is in ViewStripMargin.h. This one will be restored
    when the bug is solved.
    -----------------------------------------------------------

    FindIndexView and FindViewIndex work on OGLVIEW* rather
    than OglGui::View

    When you delete 1 or multiple views you must call
    viewStrip->LayoutViews.

RvB: Bij reshape misschien beeld ankeren en scrollPos daaraan aanpassen.
Zoals bij text editor.

NOTE: In toekomst nog veranderen dat ViewStrip zelf
niet met oglGui::View werkt, maar volledig op basis
van OGGLVIEW*. Dit omdat dan de caller makkelijk de
OGLVIEW* kan wrappen in een OglGui::View naar eigen keuze.
*/
/*
12345678901234567890123456789012345678901234567890123456789012345678901234567890
*/

#ifndef OglGui_ViewStrip_h
#define OglGui_ViewStrip_h

#include "OglGui/View.h"
#include "OglGui/WindowScrollBar.h"
#include "OglGui/ImagesListener.h"

namespace OglGui
{

class ViewStrip : public Window, public ScrollBarListener
{
public:

    ViewStrip(int x, int y, int w, int h, bool horizontal=true,
              bool stdSide=true) :
        Window(x, y, w, h, true)
    {
        Init(w, h, horizontal, stdSide);
    }

    ViewStrip(Window* parent, int x, int y, int w, int h, bool horizontal=true,
              bool stdSide=true) :
        Window(parent, x, y, w, h, true)
    {
        Init(w, h, horizontal, stdSide);
    }

    ViewStrip(Window* parent, int w, int h, bool horizontal=true,
              bool stdSide=true ) :
        Window(parent, w, h, true)
    {
        Init(w, h, horizontal, stdSide);
    }

    void SetImagesListener(ImagesListener* listener, void* listenerData = 0)
    {
        mImListener = listener;
        mListenerData = listenerData;
    }

    // When set, AddImage(im, 0) results in created OglGui::View
    // to get this listener
    void SetViewListener(ViewListener* listener)
    {
        mViewListener = listener;
    }

    void AspectRatio(float ratio)
    {
        mAspectRatio = ratio;
    }

    void SetFitImages(bool mode)
    {
        mFitImages = mode;

        if(mode) LayoutViews();
    }

    bool GetFitImages()
    {
        return mFitImages;
    }

    void SetExtraSpace(int nPix)
    {
        mExt = nPix;
    }

    void Spacing(int nPix)
    {
        mSpacing = nPix;
    }

    void SetMargin(int nPix)
    {
        mMargin = nPix;
    }

    void SetViewTags(int tags)
    {
        mViewTags = tags;
    }

    int Size()
    {
        return mNrIm;
    }

    OGLVIEW* FindViewWithImage(OGLIMAGE* im)
    {
        LIST    *obj;

        ForAllElements(obj, mOglWnd->objectList)
        {
            OGLVIEW* view = (OGLVIEW *) obj->info;
            if(im == view->im)
                return view;
        }
        return 0;
    }

    // Note: Works on OGLVIEW* NOT OglGui::View
    int FindViewIndex(OGLVIEW *view)
    {
        LIST    *obj;
        int     ind = 0;

        ForAllElements(obj, mOglWnd->objectList)
        {
            if(view == (OGLVIEW *) obj->info)
                return ind;
            ind++;
        }
        return -1;
    }

    // Note: Results in OGLVIEW* NOT OglGui::View
    OGLVIEW* FindIndexView(int ind)
    {
        LIST    *obj;
        int     n=0;

        if (ind < 0)
            return NULL;

        ForAllElements(obj, mOglWnd->objectList)
        {
            if(n++ == ind)
                return (OGLVIEW *) obj->info;
        }
        return NULL;
    }

    View* ViewFromOGLVIEW(OGLVIEW* oglView)
    {
        if (!oglView)
            return 0;
        return (View*) viewSys.GetSysData(oglView,1);
    }

    void OnScroll(ScrollBar *src, int pos, void* data)
    {
        if(mHorizontal)
            mOglWnd->docX = -pos * (mSpacing+mFixedSize*mAspectRatio);
        else
            mOglWnd->docY = /*H()*/ + (pos*(mSpacing+mFixedSize/mAspectRatio));
    }

    ScrollBar*  GetScrollBar()
    {
        return mScrollBar;
    }

    void SetScrollBarRange()
    {
        int pageSize;
        if (mHorizontal)
            pageSize = W()/(mSpacing+mFixedSize*mAspectRatio);
        else
            pageSize = H()/(mSpacing+mFixedSize/mAspectRatio);
        mScrollBar->SetRange(mNrIm, pageSize>0 ? pageSize : 1);
    }

    virtual void PlaceView(OGLVIEW* oglView)
    {
        OGLIMAGE*   im = oglView->im;
        int         imW = (im ? im->w : mFixedSize*mAspectRatio);
        int         imH = (im ? im->h : mFixedSize/mAspectRatio);
        int         vX, vY, vW, vH;

        vH = vW = mFixedSize;
        vX = vY = mFixedPos;

        if (mHorizontal)
        {
            vW = mAspectRatio * mFixedSize;
            vX = mNextViewPos;
            mNextViewPos += vW + mSpacing;
        }
        else
        {
            vH = mFixedSize / mAspectRatio;
            vY = mNextViewPos;
            mNextViewPos -= vH + mSpacing;
        }
        viewSys.SetDimensions(oglView,vX,vY,vW,vH);
        if(oglView->im && mFitImages)
            viewSys.SetZoom(oglView, vW/(float)imW, vH/(float)imH);
    }

    View* AddImage(OGLIMAGE *im, ViewListener *listener = 0)
    {
        View        *view;
        OGLVIEW     *oV;

        if(!im) return 0;

        if(listener == 0 && mViewListener != 0)
            listener = mViewListener;

        view = new View(mOglWnd, im, 0, 0, 10, 10,listener);
        oV = view->GetOGLVIEW2D();
        if (oV->im && mAspectRatio <= 0)
            mAspectRatio = oV->im->w / (float) oV->im->h;
        PlaceView(oV);
        mNrIm++;

        viewSys.SetColor(oV, OGL_BORDER, oglBLACK);

        view->SetTags(mViewTags);
        SetScrollBarRange();
        return view;
    }

    virtual int SetState(int nState)
    {
        mScrollBar->SetState(nState);
        return Window::SetState(nState);
    }

    void LayoutViews()
    {
        LIST*       obj;
        int         i = 0;

        mFixedPos    = mMargin + (mHorizontal ? (mStdSide ? mExt+1:3) :
                                                (mStdSide ? 3:mExt+1));
        mFixedSize   = (mHorizontal ? H() : W()) - (mExt+4) - 2*mMargin;
        mNextViewPos = (mHorizontal ? mMargin + 2 : H() - (mFixedSize+mMargin+2));
        ForAllElements(obj, mOglWnd->objectList)
        {
            OGLVIEW* view = (OGLVIEW *) obj->info;
            PlaceView(view);
            i++;
        }
        mNrIm = i;
        SetScrollBarRange();
        // RvB: 20-04-2010 To anchor the views to ScrollBar value
        if (mNrIm)
            OnScroll(0, mScrollBar->GetValue(), 0);
    }

    virtual void ReshapeFunc(int w, int h)
    {
        Window::ReshapeFunc(w, h);
        LayoutViews();
    }

    virtual void MouseFunc(INT msg, INT but, INT state, INT x, INT y)
    {
        Window::MouseFunc(msg, but, state, x, y);

        int incr = mScrollBar->LineIncrement();
        if(msg == oglMouseWheelUp) mScrollBar->ChangePos(-incr);
        if(msg == oglMouseWheelDown) mScrollBar->ChangePos(incr);

        if ((msg==oglMouseDown || msg==oglMouseDblClick) && mImListener)
        {
            OGLVIEW *view = viewSys.FindView(mOglWnd, x, y);
            if (view) {
                int id = FindViewIndex(view);
                mImListener
                    ->ImageSelectionEvent(this,id,msg,but,state,mListenerData);
            }
        }
    }

    virtual void KeyboardFunc(INT c, int state)
    {
        Window::KeyboardFunc(c, state);
        if(mScrollBar)
            mScrollBar->ScrollKeys(c, state);
    }

private:

    void Init(int w, int h, bool horizontal, bool stdSide )
    {
        mHorizontal = horizontal;
        mNrIm = 0;
        mAspectRatio = 0;
        mSpacing = 2;
        mMargin = 2;
        mExt = 16;

        mViewTags = FlexViewTags;

        mStdSide = stdSide;
        oglSys.SetAllowCameraMove(mOglWnd, 0);
        SetBorderType(BEV_ETCHED);
        mScrollBar = new WindowScrollBar(this, horizontal, stdSide);
        mScrollBar->SetScrollBarListener(this, 0);
        mScrollBar->SetLineIncrement(1);

        mViewListener = 0;
        mImListener = 0;
        mFitImages = true;
        LayoutViews();
    }

    WindowScrollBar*  mScrollBar;
    bool              mHorizontal;
    bool              mStdSide;
    bool              mFitImages;
    float             mAspectRatio;
    int               mNrIm;
    int               mFixedSize;
    int               mFixedPos;
    int               mNextViewPos;
    int               mExt;
    int               mMargin;
    int               mSpacing;

    int               mViewTags;  // Normally FlexViewTags, tags when view is created

    ViewListener*     mViewListener;
    ImagesListener*   mImListener;
    void*             mListenerData;

};

} // namespace OglGui
#endif

---