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

---

ImageStrip.h

Go to the documentation of this file.

#ifndef Impala_Visualization_ImageStrip_h
#define Impala_Visualization_ImageStrip_h

#include "Visualization/ImagesWindow.h"
#include "OglGui/WindowScrollBar.h"

namespace Impala
{
namespace Visualization
{


/*
 * RvB: To introduce viewer movement and dragging, rather than image jumping
 * behaviour.  3 extra viewers are introduced: mExtraView
 */
class ImageStrip : public ImagesWindow, public OglGui::RepeatTimer,
                   public OglGui::ScrollBarListener
{
public:

    // Still need a constructor like the other controls with parent, x, y, w, h.
    // However problem with overloading as it maps to an existing constructor
    /* RvB: Suggestion: And implemented. NOTE still need to adress first 2 strange constructors
        ImageStrip(OglGui::Window* parent, int width, int height, int distance = 3) :

        ImageStrip(OglGui::Window* parent, int x, int y, int width, int height, int distance = 3) :

        ImageStrip(OglGui::Window* parent, int x, int y, double scale, int imW, int imH,
                   int nrVisible, int distance = 3) :

        ImageStrip(OglGui::Window* parent, int imW, int imH, double scale,
                   int nrVisible, int distance = 3) :
    */

    ImageStrip(OglGui::Window* parent, int width, int height,
               int distance = 3, float vSpace=30) :
        ImagesWindow(parent, width, height)
    {
        // RvB: Strange constructor with preset w == 1.5 * h
        int imW, imH;
        imH = height - vSpace; 
        imW = imH * 1.5;
        Init(imW, imH, 1.0, width / (imW+distance), distance, vSpace);
    }

    ImageStrip(OglGui::Window* parent, int x, int y, int width, int height,
               int distance = 3, float vSpace=30.) :
        ImagesWindow(parent, x, y, width, height)
    {
        int imW, imH;
        imH = height - vSpace; 
        imW = imH * 1.5;
        Init(imW, imH, 1.0, width / (imW+distance), distance, vSpace);
    }
        
    ImageStrip(OglGui::Window* parent, int x, int y, double scale, int imW,
               int imH, int nrVisible, int distance = 3, float vSpace=30.) :
        ImagesWindow(parent, x, y,
                     ((int)(imW*scale)+distance)*nrVisible-distance+6,
                     (int)(imH*scale) + distance + vSpace, true)
    {
        Init(imW, imH, scale, nrVisible, distance, vSpace);
    }

    ImageStrip(OglGui::Window* parent, int imW, int imH, double scale,
               int nrVisible, int distance = 3, float vSpace=30.) :
        ImagesWindow(parent, (imW*scale+distance)*nrVisible-distance+6,
                     imH*scale + vSpace, true)
    {
        Init(imW, imH, scale, nrVisible, distance, vSpace);
    }

    OglGui::ScrollBar*
    ScrollBar()
    {
        return mScrollBar;
    }

    void
    SetImageSelected(int idx)
    {
        mImSelected = idx;
        SetViewSelected(mImSelected - mFirstVis);
    }

    void
    SetAllowDragging(bool mode)
    {
        if (!(mAllowDragging = mode))
            mDragImId = -1;
    }

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

    void
    OnScroll(OglGui::ScrollBar *src, int position, void* data)
    {
        SetFirstVis(position/mImSteps);
    }

    void
    SetFirstVis(int nr)
    {
        if (nr == mFirstVis)
            return;
        if ((nr < 0) || (nr > mImages.size() - (mNrViews-mExtraView)))
            return;
        mFirstVis = nr;
        Redraw();
    }

    void
    Redraw()
    {
        int nrV = mNrViews - 1;
        for (int i=0 ; i<nrV ; i++)
        {
            if (ViewHasImage(i))
            {
                SetViewVisible(i, true);                
                UpdateViewWithImage(i, mFirstVis + i);
            }
            else
            {
                SetViewVisible(i, false);
            }
        }
        SetImageSelected(mImSelected);
    }

    // specialization of base classes

    virtual void
    DisplayFunc()
    {
        OGC oldOGC;
        int offX = (mScrollBar->GetValue() % mImSteps) * (mViewWidth/mImSteps);

        OGCSave(&oldOGC);
        for (int j=0 ; j<mNrViews ; j++)
        {
            View* view = GetView(j);
            if (!view)
                break;
            int imId = mFirstVis + j;
            bool vis = (imId < mImages.size() && imId != mDragImId);
            if (vis)
            {
                int pos = 3 + j * (mViewWidth+mDistance) - offX;
                view->SetDimensions2D(pos, mVSpace, mViewWidth, mViewHeight);
            }
            view->SetVisible(vis);
        }

        if (mDragImId != -1)
        {
            View* view = GetView(mNrViews-1);
            if (view)
            {
                view->SetVisible(true);
                view->SetDimensions2D(mDragX-mViewWidth/2, mVSpace, mViewWidth,
                                      mViewHeight);
            }
        }

        Window::DisplayFunc();

        if (mDragImId != -1 && mPropagateScrolling && RepeatTime())
            mScrollBar->ChangePos(mPropagateScrolling);

        if (mDragImId != -1)
        {
            int pos = (mDragX+mViewWidth/2+offX) / (mViewWidth+mDistance);
            if (mFirstVis+pos > mImages.size())
                pos = mImages.size() - mFirstVis;
            mDragInsertId = mFirstVis + pos;
            pos = 3 + pos * (mViewWidth+mDistance) - offX;
            SetLineWidth(3);
            SetSolidLineColor(0xffff00ff);
            DrawLine(pos, 0, pos, mOglWnd->height);
        }

        for (int i=0 ; i<mNrViews && mFirstVis + i < mImages.size() ; i++)
        {
            int x, y;
            View* view = GetView(i);
            if (view != 0)
            {
                int imId = mFirstVis + i;
                if (mDragImId != -1 && i==mNrViews-1)
                    imId = mDragImId;
                view->GetDimensions2D(&x, &y, 0, 0);
                oglSys.PosColPrintf(mOglWnd, x+4, y-16+4,
                                    imId==mDragImId ? oglRED : oglBLACK,
                                    "%s", mImages[imId]->Caption().c_str());
            }
        }
        OGCRestore(&oldOGC);
    }

    virtual void
    ReshapeFunc(int w, int h)
    {
        int totalRange, pageSize;
        int n = (w-6) / ((mViewWidth) + mDistance) + mExtraView;
        if (n != mNrViews)
        {
            mNrViews = n;
            DeleteViewers();
            // RvB: After quite a lot of debugging!!!!!
            // Making sure that we actually get the nr of viewers we want
            for (int i=0 ; i<mNrViews; i++)
                UpdateViewWithImage(i, mFirstVis);

            Redraw();
            totalRange = mImages.size() * mImSteps;
            if ((pageSize = (mNrViews - mExtraView) * mImSteps) < 1)
                pageSize = 1;
            mScrollBar->SetRange(totalRange, pageSize);
        }
        OglGui::Window::ReshapeFunc(w, h);
    }


    virtual void
    MouseFunc(int msg, int but, int state, int x, int y)
    {
        Window::MouseFunc(msg, but, state, x, y); // skip ImagesWindow

        if (msg == oglMouseWheelUp)
            mScrollBar->ChangePos( (state&oglShift) ? -5 : -1);
        if (msg == oglMouseWheelDown)
            mScrollBar->ChangePos( (state&oglShift) ? 5 : 1);

        // todo : use ViewListener
        if (mImagesListener && (msg==oglMouseDown) && (but==oglLeftButton))
        {
            View* view = FindView(x, y);
            if (view)
            {
                int imIdx = mFirstVis + GetViewIdx( view );
                SetImageSelected(imIdx);
                mImagesListener->ImageSelectionEvent(this, imIdx,
                                                     mImagesListenerData);
            }
        }

        if (mAllowDragging && msg==oglMouseDown && but==oglRightButton)
        {
            View* dragView;
            if (dragView = FindView(x, y))
            {
                mDragX = x;
                mDragImId = mFirstVis + GetViewIdx(dragView);
                if (!mDragInitialized)
                {
                    mDragInitialized = true;
                    ReshapeFunc(mOglWnd->width, mOglWnd->height);
                }
                UpdateViewWithImage(mNrViews - 1, mDragImId);
                StartRepeatTime();
                oglSys.SetAlwaysDraw(mOglWnd, 1);
            }
        }
        if (mAllowDragging && msg==oglMouseMove && (state & oglRightButton))
        {
            mDragX = x;
            if (mDragX >= mOglWnd->width - mViewWidth/4)
            {
                mDragX = mOglWnd->width - mViewWidth/4; 
                mPropagateScrolling = x > mOglWnd->width ? mImSteps : 1;
            }
            else if (mDragX <= mViewWidth/4)
            {
                mDragX = mViewWidth/4;
                mPropagateScrolling = x < 0 ? -mImSteps : -1;
            }
            else
                mPropagateScrolling = 0;
        }
        if (msg==oglMouseUp && but==oglRightButton && mDragImId != -1)
        {
            MoveImageTo(mDragImId, mDragInsertId);
            if (mDragImId == mImSelected)
                mImSelected = mDragImId < mDragInsertId ? mDragInsertId-1
                                                        : mDragInsertId;
            Redraw();
            mDragImId = -1;
            oglSys.SetAlwaysDraw(mOglWnd, 0);
        }
    }

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

protected:

    virtual void
    ImageAdded(int idx, bool intelliScroll)
    {
        mScrollBar->SetRange((idx+1) * mImSteps, (mNrViews-mExtraView)*mImSteps);
        if (idx < mNrViews)
        {
            UpdateViewWithImage(idx, idx);
            return;
        }
        if (intelliScroll & (mFirstVis == idx - mNrViews))
        {
            SetFirstVis(mFirstVis + 1);
            mScrollBar->SetNewPos(mFirstVis*mImSteps);
        }
//        if (intelliScroll & (mFirstVis == idx - mNrViews))
//            SetFirstVis(mFirstVis + 1);
    }

    virtual void
    ImagesRemoved()
    {
        mFirstVis = 0;
        mImSelected = -1;
        mScrollBar->SetRange(0, (mNrViews-mExtraView)*mImSteps);
    }

private:

    void
    Init(int imW, int imH, double scale, int nrVisible, int distance,int space)
    {
        mVSpace = space;
        mDragInitialized = false;
        mImSteps = 8;
        mExtraView = 3;
        mAllowDragging = true;
        mDragViewNr = -1;
        mDragImId = -1;
        mDragInsertId = -1;
        mPropagateScrolling = 0;
        SetRepeatDelays(400, 25);
        mNrViews = nrVisible + mExtraView;
        mFirstVis = 0;
        mDistance = distance;
        mImSelected = -1;
        mViewWidth = imW * scale;
        mViewHeight = imH * scale;
        mScrollBar = new OglGui::WindowScrollBar(this, true /*hor*/);
        mScrollBar->SetScrollBarListener(this, 0);
        mScrollBar->SetRange(0, (mNrViews-mExtraView)*mImSteps);
        SetBorderType(BEV_ETCHED);
    }

    bool
    ViewHasImage(int v)
    {
        if (v == mDragViewNr)
            return false;
        return mFirstVis + v < mImages.size();
    }

// RvB: Added mVSpace
    int  mVSpace;

    int  mNrViews;   // Number of viewers (including mExtraView)
    int  mExtraView; // Extra viewers for movement when scroling and dragging
    int  mFirstVis;  // The first viewer that is (partially) visible
    int  mDistance;  // Distance between viewers
    int  mImSelected;

    int  mImSteps;  // Nr of steps in which 1 viewer width is scrolled.
                    // mViewWidth must be dividable by mImSteps
    int  mPropagateScrolling; // Propagate scrolling when dragging a view to
                              // or beyond a boundary
    bool mDragInitialized;
    bool mAllowDragging; // Must be set to allow for drag and drop of viewer
    int  mDragViewNr;    // Viewer used to display dragged image.
                         // Must be the last viewer to remain visible.
    int  mDragImId;      // Image being dragged
    int  mDragInsertId;  // Image before which dragged im should be inserted
    int  mDragX;         // Coordinate of mouse while dragging

    OglGui::WindowScrollBar* mScrollBar;
};

} // namespace Visualization
} // namespace Impala

#endif

---