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

---

ImageSet.h

Go to the documentation of this file.

#ifndef Impala_Visualization_ImageSet_h
#define Impala_Visualization_ImageSet_h

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

namespace Impala
{
namespace Visualization
{


class ImageSet : public ImagesWindow, public OglGui::RepeatTimer,
                 public OglGui::ScrollBarListener
{
public:
    ImageSet(OglGui::Window* parent, int x, int y, int imW, int imH, double scale,
             int nrVisibleX, int nrVisibleY, int distance = 3) :
        ImagesWindow(parent, x, y, (imW*scale + distance) * nrVisibleX + 16,
                     (imH*scale + distance) * nrVisibleY + 4, true)
    {
        Init(imW, imH, scale, nrVisibleX, nrVisibleY, distance);
    }

    ImageSet(OglGui::Window* parent, int imW, int imH, double scale,
             int nrVisibleX, int nrVisibleY, int distance = 3) :
        ImagesWindow(parent, (imW*scale + distance) * nrVisibleX + 16,
                     (imH*scale + distance) * nrVisibleY + 4, true)
    {
        Init(imW, imH, scale, nrVisibleX, nrVisibleY, distance);
    }

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

    void
    SetImageSelected(int idx)
    {
        mImSelected = idx;
        SetViewSelected(mImSelected - (mFirstVisY * mNrVisibleX));
    }

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

    int
    GetFirstVisY()
    {
        return mFirstVisY;
    }

    void
    SetFirstVisY(int nr, bool signalScrollBar = false)
    {
        if (signalScrollBar)
        {
            mScrollBar->SetNewPos(nr*mImSteps);
            return;
        }
        if (nr == mFirstVisY)
            return;
        int nrLines = (mImages.size() == 0)
            ? 0 : (mImages.size()-1) / mNrVisibleX + 1;
        if ((nr < 0) || (nr > nrLines-(mNrVisibleY-mExtraLines)))
            return;
        mFirstVisY = nr;
        Redraw();
    }

    int
    GetIndexForId(int id)
    {
        for (int i=0 ; i<mImages.size() ; i++) {
            if (mImages[i]->Idx() == id)
                return i;
        }
        return mImages.size();
    }

    int
    GetIdForIndex(int idx)
    {
        if (idx >= 0 && idx < mImages.size())
            return mImages[idx]->Idx();
        return -1;
    }

    void
    RemoveImageById(int id)
    {
        RemoveImageByIndex(GetIndexForId(id));
    }

    void
    RemoveImageByIndex(int index)
    {
        if (index >= mImages.size())
            return;
        mImages.erase(mImages.begin() + index);

        // redraw and scroll if necessary
        if (mImages.size() <= (mLines-1)*mNrVisibleX)
        {
            mLines--;
            UpdateScrollBarRange();
        }
        if ((mImages.size()-1)/mNrVisibleX+1 < mFirstVisY+(mNrVisibleY-mExtraLines)
            && mFirstVisY > 0)
        {
            SetFirstVisY(mFirstVisY - 1);
        }
        else
        {
            Redraw();
        }
        if (index < mImSelected)
            mImSelected = -1;

        // todo consider selection
        /*
        // select and notify listener
        if (index >= mImages.size())
            index = mImages.size() - 1;
        if (index >= 0)
        {
            SetViewSelected(index - (mFirstVisY * mNrVisibleX));
            if(mImagesListener)
                mImagesListener->ImageSelectionEvent(this, index, mImagesListenerData);
        }
        */
    }

    void 
    Redraw()
    {
        int nrV = mNrVisibleX * mNrVisibleY;
        int start = mFirstVisY * mNrVisibleX;
        for (int i=0 ; i<nrV ; i++)
        {
            if (ViewHasImage(i))
            {
                SetViewVisible(i, true);
                UpdateViewWithImage(i, start + i);
            }
            else
            {
                SetViewVisible(i, false);
            }
        }
        SetImageSelected(mImSelected);
        if (mDragImId != -1)
            UpdateViewWithImage(mDragViewNr, mDragImId);
    }

    // specialization of base classes

    virtual void
    DisplayFunc()
    {
        int cnt = 0;
        OGC oldOGC;
        int offY = mScrollBar->GetValue() % mImSteps;
        int nrV = mNrVisibleX * mNrVisibleY;
        int start = mFirstVisY * mNrVisibleX;

        OGCSave(&oldOGC);
        for (int i=0 ; i<mNrVisibleY ; i++)
        {
            int y = mOglWnd->height - (i+1) * (mViewHeight+mDistance) +
                    offY * (mViewHeight/mImSteps);
            for (int j=0 ; j<mNrVisibleX ; j++)
            {
                int x = j * (mViewWidth+mDistance);
                if (ViewHasImage(cnt))
                {
                    View* view = GetView(cnt);
                    view->SetDimensions2D(x, y, mViewWidth, mViewHeight);
                    bool vis = start + cnt != mDragImId;
                    view->SetVisible(vis);
                    if (vis)
                        view->SetText(mImages[start+cnt]->Caption());
                }
                cnt++;
            }
        }

        if (mDragImId != -1)
        {
            View* view = GetView(mDragViewNr);
            view->SetVisible(true);
            view->SetText(mImages[mDragImId]->Caption());
            view->SetDimensions2D(mDragX-mViewWidth/2, mDragY-mViewHeight/2,
                                  mViewWidth, mViewHeight);
        }


        Window::DisplayFunc();

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

        if (mDragImId != -1)
        {
            View* dragView = GetView(mDragViewNr);
            dragView->SetVisible(false);
            View* view = FindView(mDragX, mDragY);
            if (view)
            {
                mDragInsertId = mFirstVisY * mNrVisibleX + GetViewIdx(view);
                int x, y, w;
                view->GetDimensions2D(&x, &y, &w, 0);
                if (mDragX > x + w/2)
                {
                    x += mViewWidth;
                    mDragInsertId++;
                }
                SetLineWidth(3);
                SetSolidLineColor(0xffff00ff);
                DrawLine(x, y, x, y + mViewHeight);
            }
            else
                mDragInsertId = -1;
            dragView->SetVisible(true);
        }
        OGCRestore(&oldOGC);
    }


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

        int visIdx = mFirstVisY * mNrVisibleX;
        mNrVisibleX = w / (mViewWidth+mDistance);
mNrVisibleX = Max(mNrVisibleX,1);
        mNrVisibleY = h / (mViewHeight+mDistance) + mExtraLines;
        mLines = (mImages.size() == 0)
            ? 0 : (mImages.size()-1) / mNrVisibleX + 1;
        Redraw();
        UpdateScrollBarRange();
        SetFirstVisY((mNrVisibleX == 0) ? 0 : visIdx / mNrVisibleX, false);
    }

    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 = mFirstVisY * mNrVisibleX + GetViewIdx(view);
                SetImageSelected(imIdx);
                int orgIdx = mImages[imIdx]->Idx();
                mImagesListener->ImageSelectionEvent(this, orgIdx,
                                                     mImagesListenerData);
            } 
        }

        if (mAllowDragging && msg==oglMouseDown && but==oglRightButton)
        {
            View* dragView = FindView(x, y);
            if (dragView)
            {
                mDragX = x;
                mDragY = y;
                mDragImId = mFirstVisY * mNrVisibleX + GetViewIdx(dragView);
                mDragViewNr = NrViewers();
                if (mDragViewNr > mNrVisibleX * mNrVisibleY)
                    mDragViewNr = mNrVisibleX * mNrVisibleY;
                UpdateViewWithImage(mDragViewNr, mDragImId);
                StartRepeatTime();
                oglSys.SetAlwaysDraw(mOglWnd, 1);
            }
        }
        if (mAllowDragging && msg==oglMouseMove && (state & oglRightButton))
        {
            mDragX = x;
            mDragY = y;

            if (mDragY >= mOglWnd->height - mViewHeight/4)
            {
                mDragY = mOglWnd->height - mViewHeight/4; 
                mPropagateScrolling = y > mOglWnd->height ? -mImSteps : -1;
            }
            else if (mDragY <= mViewHeight/4)
            {
                mDragY = mViewHeight/4;
                mPropagateScrolling = y < 0 ? mImSteps : 1;
            }
            else
                mPropagateScrolling = 0;

        }
        if (msg==oglMouseUp && but==oglRightButton && mDragImId != -1)
        {
            if (mDragInsertId != -1)
            {
                MoveImageTo(mDragImId, mDragInsertId);
                if (mDragImId == mImSelected)
                    mImSelected = mDragImId < mDragInsertId ? mDragInsertId-1
                                                            : mDragInsertId;
            }
            mDragImId = -1;
            SetViewVisible(mDragViewNr, false);
            mDragViewNr = -1;
            Redraw();
            oglSys.SetAlwaysDraw(mOglWnd, 0);
        }

    }

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

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

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

protected:

    virtual void
    ImageAdded(int idx, bool intelliScroll)
    {
        int dispPos = idx - mFirstVisY * mNrVisibleX;
        if (idx >= mLines*mNrVisibleX)
        {
            mLines++;
            UpdateScrollBarRange();
        }
        if (dispPos < mNrVisibleX * mNrVisibleY)
        {
            UpdateViewWithImage(dispPos, idx);
            return;
        }
        if (intelliScroll &&
            (mFirstVisY * mNrVisibleX ==
             idx - mNrVisibleX * (mNrVisibleY - mExtraLines)))
        {
            SetFirstVisY(mFirstVisY + 1);
        }
    }

    virtual void
    ImagesRemoved()
    {
        mFirstVisY = 0;
        mLines = 0;
        mImSelected = -1;
        UpdateScrollBarRange();
    }

private:

    void
    Init(int imW, int imH, double scale, int nrVisibleX, int nrVisibleY,
         int distance)
    {
        mImSteps = 10;
        mExtraLines = 2;
        mAllowDragging = true;
        mDragViewNr = -1;
        mDragImId = -1;
        mDragInsertId = -1;
        mPropagateScrolling = 0;
        SetRepeatDelays(400, 25);

        mViewWidth = imW * scale;
        mViewHeight = imH * scale;
        mNrVisibleX = nrVisibleX;
        mNrVisibleY = nrVisibleY + mExtraLines;
        mFirstVisY = 0;
        mDistance = distance;
        mLines = 0;
        mImSelected = -1;
        mScrollBar = new OglGui::WindowScrollBar(this, false); 
        mScrollBar->SetBackground(oglLIGHTGREY);
        mScrollBar->SetScrollBarListener(this, 0);
        UpdateScrollBarRange();
        SetBorderType(BEV_ETCHED);
//        ScaleChildren(0, true);
//        SetReposChildren(false, true);
    }

    void
    UpdateScrollBarRange()
    {
        int pageSize = (mNrVisibleY - mExtraLines) * mImSteps;
        if (pageSize < 1)
            pageSize = 1;
        mScrollBar->SetRange(mLines * mImSteps, pageSize);
    }

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


    int  mNrVisibleX; // Number of viewers on a row
    int  mNrVisibleY; // Number of rows of viewers (including mExtraLines)
    int  mExtraLines; // Number of partially visible rows (at top and bottom)
    int  mFirstVisY; // The first row of viewers that is (partially) visible
    int  mDistance; // Distance between viewers
    int  mLines;    // Number of rows of viewers needed to show all images
    int  mImSelected;

    int  mImSteps; // Nr of steps in which 1 viewer row is scrolled.
                   // mViewWidth must be dividable by mImSteps.

    int  mPropagateScrolling; // Propagate scrolling when dragging a view to
                              // or beyond a boundary
    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, mDragY; // Coordinate of mouse while dragging

    OglGui::WindowScrollBar* mScrollBar;

    ILOG_VAR_DEC;
};
ILOG_VAR_INIT(ImageSet, Visualization);


} // namespace Visualization
} // namespace Impala

#endif

---