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

---

WindowView2DWithRect.h

Go to the documentation of this file.

#ifndef Application_IDash_WindowView2DWithRect_h
#define Application_IDash_WindowView2DWithRect_h

#ifndef OglGui_RepeatTimer_h
#include "OglGui/RepeatTimer.h"
#endif

#ifndef OglGui_Window_h
#include "OglGui/Window.h"
#endif

#ifndef OglGui_WindowView2DListener_h
#include "OglGui/WindowView2DListener.h"
#endif

#ifndef OglGui_SetImageInterface_h
#include "OglGui/SetImageInterface.h"
#endif

#include "Core/Geometry/Rectangle.h"

namespace OglGui
{

class WindowView2DWithRectListener
{
public:
    virtual void
    OnRectangleSelect(float x, float y, float w, float h)
    {

    }
};

class WindowView2DWithRect : public StaticText,
                     public RepeatTimer,
                     public SetImageInterface
{
public:

    WindowView2DWithRect(int x, int y, int w, int h, OGLIMAGE *oglIm=0):
        StaticText(x, y, w, h, "")
    {
        Init(oglIm, "");
    }

    WindowView2DWithRect(Window* parent, int x, int y, int w, int h, OGLIMAGE *oglIm=0):
        StaticText(parent, x, y, w, h, "")
    {
        Init(oglIm, "");
    }

    WindowView2DWithRect(Window* parent, int w, int h, OGLIMAGE *oglIm=0) :
        StaticText(parent, w, h, "")
    {
        Init(oglIm, "");
    }

    void
    SetWndView2DListener(WindowView2DListener* listener, void* listenerData = 0)
    {
        mWndView2DListener = listener;
        mListenerData = listenerData;
    }

/*
    void CenterStr(int dX, int dY)
    {
        int     tW, tH;
        oglSys.GetTextExtent(mOglWnd, (char *) mLabel.c_str(), &tW, &tH);

        ULONG   shadCol = GetState() ? oglLIGHTGREY : oglGREY;
        ULONG   foreCol = GetState() ? oglBLACK : oglLIGHTGREY;
        int w = WndWidth(), h = WndHeight();
        oglSys.ShadowPrintf(mOglWnd, w/2 - tW/2 + dX, h/2 - tH/2 + dY,
                            shadCol, foreCol, "%s", mLabel.c_str());
    }
*/
    virtual void DisplayFunc()
    {
        int w = mOglWnd->width;
        int h = mOglWnd->height;

        viewSys.SetDimensions(mView, 0, 0, w, h);

        if (mScaleToWnd && mView->im)
            viewSys.SetZoom(mView, w / (float) mView->im->w,
                            h / (float) mView->im->h);

        if (mActAsButton && mIsPressed)
        {
            mOldBorderType = GetBorderType();
            mView->x++; mView->y--;
        }
        StaticText::DisplayFunc();

        if (mActAsButton && mIsPressed){
            SetBorderType(mOldBorderType);
            mView->x--; mView->y++;
        }

        if (mIsDragging) {
            OGC prevOGC;
            OGCSave( &prevOGC );
            SetLineWidth(2);
            SetSolidLineColor(0xffdddd22);
            DrawRectangle(mDragLX, mDragLY, mDragHX - mDragLX, mDragHY - mDragLY);
            OGCRestore( &prevOGC );
        }

        //CenterStr(mIsPressed ? 1 : 0, mIsPressed ? 2 : 3);
    }

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

        int w = mOglWnd->width;
        int h = mOglWnd->height;


        if (msg == oglMouseDown && but == oglLeftButton) {
            if (mIsDragging) {
                // execute if click within box, cancel if outside:
                if (mDragLX <= x && x <= mDragHX && mDragLY <= y && y <= mDragHY) {
                    float sx, sy, sw, sh;
                    sx = mDragLX;
                    sy = mDragLY;
                    sw = mDragHX - mDragLX;
                    sh = mDragHY - mDragLY;
                    if (sw > 1 && sh > 1) {
                        // coordinates based on upper-left = 0,0 instead of lower-left = 0,0
//                        ILOG_DEBUG(" SELECT: " << sx / w << ", " << 1.0 - (sy/h + sh/h) << ", " << sw/w << ", " <<sh/h);
                        if (mListener)
                        mListener->OnRectangleSelect(sx/w, 1.0 - (sy/h + sh/h), sw/w, sh/h);
                    }
                }
                mIsDragging = false;
                return;
            } else {
                mDragLX = mDragHX = x;
                mDragLY = mDragHY = y;
                mIsDragging = true;
            }
        }

        if (msg == oglMouseMove && mIsDragging) {
            if (x < mDragLX) mDragLX = x;
            if (x > mDragHX) mDragHX = x;
            if (y < mDragLY) mDragLY = y;
            if (y > mDragHY) mDragHY = y;

            if (mDragLX < 0) mDragLX = 0;
            if (mDragLY < 0) mDragLY = 0;
            if (mDragHX > w) mDragHX = w;
            if (mDragHY > h) mDragHY = h;
        }
    }

    virtual void
    KeyboardFunc(INT c, INT state)
    {
        if (!mActAsButton && c >= oglUP && c <= oglESC)
            Window::KeyboardFunc(c, state | oglControl);
    }

    void SetActAsButton(bool b)
    {
        mActAsButton = b;
    }

    void SetRepeatMode(bool b=true)
    {
        mRepeatMode = b;
    }

    bool IsPressed()
    {
        return mIsPressed;
    }

    void SetPressed(bool pressed)
    {
        mIsPressed = pressed;
    }

    void SetScaleToWindow(bool scale=true)
    {
        mScaleToWnd = scale;
    }

    bool GetScaleToWindow() const
    {
        return mScaleToWnd;
    }

    virtual void SetImage(OGLIMAGE* oglIm)
    {
        viewSys.SetImage(mView, oglIm);
    }

    OGLVIEW* GetOglView() const
    {
        return mView;
    }

    void
    SetListener(WindowView2DWithRectListener* listener)
    {
        mListener = listener;
    }

private:

    void Init(OGLIMAGE *oglIm, strconst label)
    {
        mWndView2DListener = 0;
        mRepeatMode = false;
        SetRepeatDelays(400, 20);
        mIsPressed = false;
        mActAsButton = false;
        mScaleToWnd = true;

        SetBorderType(BEV_ETCHED);
        mOglWnd->clipRounded = 1;
        mImageH = oglIm->h;
        mImageW = oglIm->w;
        mView = viewSys.View2D(mOglWnd, oglIm, 0, 0, WndWidth(), WndHeight());
        mView->texturing = 1;
        viewSys.SetTags(mView, selectedTag | visibleTag | showTitleTag |
                        showTextTag | zoomableTag | panableTag);

        mIsDragging = false;
        mListener = NULL;
    }

protected:
    WindowView2DListener*   mWndView2DListener;
    void*                   mListenerData;
    OGLVIEW*                mView;
    int                     mImageW;
    int                     mImageH;
    bool                    mActAsButton;
    bool                    mRepeatMode;
    bool                    mIsPressed;
    bool                    mScaleToWnd;
    int                     mOldBorderType;
    WindowView2DWithRectListener *mListener;

    int mDragLX, mDragHX;
    int mDragLY, mDragHY;
    bool mIsDragging;
    int mKeyframeID;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(WindowView2DWithRect, Application.IDash);


} // namespace OglGui
#endif

---