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

---

View.h

Go to the documentation of this file.

//345678901234567890123456789012345678901234567890123456789012345678901234567890
#ifndef OglGui_View_h
#define OglGui_View_h

#ifndef OglGui_Sys_h
#include "OglGui/Sys.h"
#endif

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

#ifndef OglGui_SetGetDimensions2dIntI_h
#include "OglGui/SetGetDimensions2dIntI.h"
#endif

#ifndef _STRING_
#include <string>
#endif

#ifndef OglGui_ViewListener_h
#include "OglGui/ViewListener.h"
#endif

namespace OglGui
{

class View : public SetGetDimensions2dIntI
{
public:
    View(Window* wnd, OGLIMAGE *oglIm, int x, int y, int w, int h,
         ViewListener* li=0)
    {
        mView2D = viewSys.View2D(wnd->GetOGLWND(), oglIm, x, y, w, h);
        Init(true, li);
    }

    // NOTE: Deliberately following similar signature as oglSys.View2D(..)
    // 2D ogl view
    View(OGLWND* oglWnd, OGLIMAGE *oglIm, int x, int y, int w, int h,
         ViewListener* li=0)
    {
        mView2D = viewSys.View2D(oglWnd, oglIm, x, y, w, h);
        Init(true, li);
    }

    View(OGLVIEW *view2D, ViewListener* li=0)
    {
        mView2D = view2D;
        Init(true, li);
    }

    View(Window* wnd, OGLIMAGE *oglIm, float x, float y, float z,
         float w, float h, float d, ViewListener* li=0)
    {
        mView3D = view3DSys.View3D(wnd->GetOGLWND(), oglIm, x, y, z, w, h, d);
        Init(false, li);
    }

    // NOTE: Deliberately following similar signature as oglSys.View3D(..)
    // 3D ogl view
    View(OGLWND* oglWnd, OGLIMAGE *oglIm, float x, float y, float z,
         float w, float h, float d, ViewListener* li=0)
    {
        mView3D = view3DSys.View3D(oglWnd, oglIm, x, y, z, w, h, d);
        Init(false, li);
    }

    View(OGLVIEW3D *view3D, ViewListener* li=0)
    {
        mView3D = view3D;
        Init(false, li);
    }

    virtual ~View()
    {
#ifdef DESTRUCT_VERBOSE
printf("OglGui::View d %d\n", --sNrCreated);
#endif
        mIsDestructing = true;
        if (!mIsDestroying)
        {
            if (mIs2D)
                viewSys.DeleteView(mView2D);
            else
                view3DSys.DeleteView(mView3D);
        }
    }

    void SetListener(ViewListener *listener, int lData=0, bool oldDelete=false)
    {
        if (oldDelete && mListener != 0)
            delete mListener;
        mListener = listener;
    }

    ViewListener *GetListener()
    {
        return mListener;
    }

    OGLVIEW* GetOGLVIEW2D()
    {
        return mIs2D ? mView2D : 0;
    }

    OGLVIEW3D* GetOGLVIEW3D()
    {
        return !mIs2D ? mView3D : 0;
    }

    // Deprecated: use GetImage
    OGLIMAGE* GetOGLIMAGE()
    {
        return GetImage();
/*
        if (mIs2D && mView2D != 0 && mView2D->im)
        {
            mView2D->im->refCount++;
            return mView2D->im;
        }
        else if (!mIs2D && mView3D != 0 && mView3D->im)
        {
            mView3D->im->refCount++;
            return mView3D->im;
        }
        return NULL;
*/
    }

    OGLIMAGE* GetImage()
    {
        if (mIs2D)
            return viewSys.GetImage(mView2D);
        else
            return view3DSys.GetImage(mView3D);
    }
    void SetImage(OGLIMAGE* im)
    {
        if (mIs2D)
            viewSys.SetImage(mView2D, im);
        else
            view3DSys.SetImage(mView3D, im);
    }

    int GetId() const
    {
        return mID;
    }

    // Next 2 funcs to be compliant with interface: SetGetDimensions2dIntI
    void SetDimensions(int x, int y, int w, int h)
    {
        if (mIs2D)
            viewSys.SetDimensions(mView2D, x, y, w, h);
    }
    void GetDimensions(int& x, int& y, int& w, int& h)
    {
        if (mIs2D)
            viewSys.GetDimensions(mView2D, &x, &y, &w, &h);
    }

    // RvB: 2D/3D suffix not necessary, remained for BWC
    void GetDimensions2D(int* x, int* y, int* w, int* h)
    {
        if (mIs2D)
            viewSys.GetDimensions(mView2D, x, y, w, h);
    }

    void SetDimensions2D(int x, int y, int w, int h)
    {
        if (mIs2D)
            viewSys.SetDimensions(mView2D, x, y, w, h);
    }

    void
    GetDimensions3D(float* x, float* y, float* z, float* w, float* h, float* d)
    {
        if (!mIs2D)
            view3DSys.GetDimensions(mView3D, x, y, z, w, h, d);
    }

    void
    SetDimensions3D(float x, float y, float z, float w, float h, float d)
    {
        if (!mIs2D)
            view3DSys.SetDimensions(mView3D, x, y, z, w, h, d);
    }

    void SetText(std::string text)
    {
        if (mIs2D)
        {
            viewSys.SetStr(mView2D, OGL_TEXT, (char*) text.c_str());
            viewSys.SetTags(mView2D, showTextTag);
        }
    }

    void SetZoom(float zoomX, float zoomY)
    {
        if (mIs2D)
            viewSys.SetZoom(mView2D, zoomX, zoomY);
        else
            view3DSys.SetZoom(mView3D, zoomX, zoomY);
    }

    void SetPan(float panX, float panY)
    {
        if (mIs2D)
            viewSys.SetPan(mView2D, panX, panY);
        else
            view3DSys.SetPan(mView3D, panX, panY);
    }

    void SetTags(ULONG tags)
    {
        if (mIs2D)
            viewSys.SetTags(mView2D, tags);
        else
            view3DSys.SetTags(mView3D, tags);
    }

    void ClearTags(ULONG tags)
    {
        if (mIs2D)
            viewSys.ClearTags(mView2D, tags);
        else
            view3DSys.ClearTags(mView3D, tags);
    }

    void SetTagsTo(int tags, bool mode)
    {
        if (mIs2D)
           viewSys.SetTagsTo(mView2D, tags, mode);
        else
           view3DSys.SetTagsTo(mView3D, tags, mode);
    }

    bool HasTags(int tags)
    {
        return ((mIs2D ? mView2D->tags : mView3D->tags) & tags) != 0;
/* Use above: optimized for speed
        if (mIs2D)
           return viewSys.HasTags(mView2D, tags);
        else
           return view3DSys.HasTags(mView3D, tags);
*/
    }

    void SetSelected(bool flag)
    {
        SetTagsTo(selectedTag, flag);
    }

    bool GetSelected()
    {
        if (mIs2D)
            return viewSys.HasTags(mView2D, selectedTag) != 0;
        else
            return view3DSys.HasTags(mView3D, selectedTag) != 0;
    }

    void SetVisible(bool mode)
    {
        SetTagsTo(visibleTag, mode);
    }

    bool GetVisible()
    {
        return HasTags(visibleTag);
    }

    void SetBorderColor(ULONG color)
    {
        if (mIs2D)
            mView2D->borderCol = color;
    }

    ULONG BorderColor()
    {
        if (mIs2D)
            return mView2D->borderCol;
        return 0;
    }


    // More natural image coordinate system. Origin top left.
    // NOTE: C based OGL works on graphics origin bottom,left
    void WndToIm(int wndX, int wndY, int& imX, int& imY)
    {
        OGLIMAGE* oglIm = mIs2D ? mView2D->im : mView3D->im;
        FLOAT x = (FLOAT)wndX;
        FLOAT y = (FLOAT)wndY;
        if (oglIm == 0)
            return;
        if (mIs2D)
        {
            viewSys.WndToIm(mView2D, &x, &y);
            imX = (int) x;
            imY = (int) (oglIm->h-y);
        }
        else
        {
            view3DSys.WndToIm(mView3D, &x, &y);
            imX = (int) x;
            imY = (int) (oglIm->h-y);
        }
    }

    void ViewToIm(int vX, int vY, int& imX, int& imY)
    {
        OGLIMAGE* oglIm = mIs2D ? mView2D->im : mView3D->im;
        FLOAT x = (FLOAT)vX;
        FLOAT y = (FLOAT)vY;
        if (oglIm == 0)
            return;
        if (mIs2D)
        {
            viewSys.View2DToIm(mView2D, &x, &y);
            imX = (int) x;
            imY = (int) (oglIm->h-y);
        }
        else
        {
            view3DSys.View3DToIm(mView3D, &x, &y);
            imX = (int) x;
            imY = (int) (oglIm->h-y);
        }
    }

// virtual overloadable OnImViewer functions
// NOTE: Also supports overloading of existing C based OnImView functions
    virtual void OnSelection(bool selected)
    {
        if (mIs2D && mOldView2DFuncs.OnSelection != 0)
            mOldView2DFuncs.OnSelection(mView2D, selected);
        if (!mIs2D && mOldView3DFuncs.OnSelection != 0)
            mOldView3DFuncs.OnSelection(mView3D, selected);

        if (mListener != 0)
            mListener->OnSelectView(this, selected);
    }

    virtual void OnMouse(int msg, int btn, int state, float x, float y)
    {
        if (mIs2D && mOldView2DFuncs.OnMouse != 0)
            mOldView2DFuncs.OnMouse(mView2D, msg, btn, state, x, y);
        if (!mIs2D && mOldView3DFuncs.OnMouse != 0)
            mOldView3DFuncs.OnMouse(mView3D, msg, btn, state, x, y);

        if (mListener != 0)
            mListener->OnViewMouse(this, msg, btn, state, x, y);
    }

    virtual void OnPreDrawView()
    {
        if (mIs2D && mOldView2DFuncs.OnPreDrawView != 0)
            mOldView2DFuncs.OnPreDrawView(mView2D);
        if (!mIs2D && mOldView3DFuncs.OnPreDrawView != 0)
            mOldView3DFuncs.OnPreDrawView(mView3D);

        if (mListener != 0)
            mListener->OnPreDrawView(this);
    }

    virtual void OnDrawView()
    {
        if (mIs2D && mOldView2DFuncs.OnDrawView != 0)
            mOldView2DFuncs.OnDrawView(mView2D);
        if (!mIs2D && mOldView3DFuncs.OnDrawView != 0)
            mOldView3DFuncs.OnDrawView(mView3D);

        if (mListener)
            mListener->OnDrawView(this);
    }

    virtual void OnDestroyView()
    {
        if (mIs2D && mOldView2DFuncs.OnDestroyView != 0)
            mOldView2DFuncs.OnDestroyView(mView2D);
        if (!mIs2D && mOldView3DFuncs.OnDestroyView != 0)
            mOldView3DFuncs.OnDestroyView(mView3D);

        if (mListener)
            mListener->OnDestroyView(this);

        mIsDestroying = true;
        if (!mIsDestructing)
            delete this;
    }

protected:


struct VIEW2DFUNCS {
    void (*OnSelection)(HOGLVIEW view, GLBOOL selected);
    void (*OnMouse)(HOGLVIEW view,int msg,int btn,int state,float x,float y);
    void (*OnPreDrawView)(HOGLVIEW); 
    void (*OnDrawView)(HOGLVIEW);
    void (*OnDestroyView)(HOGLVIEW);
};

struct VIEW3DFUNCS {
    void (*OnSelection)(HOGLVIEW3D view, GLBOOL selected);
    void (*OnMouse)(HOGLVIEW3D view,int msg,int btn,int state,float x,float y);
    void (*OnPreDrawView)(HOGLVIEW3D);
    void (*OnDrawView)(HOGLVIEW3D);
    void (*OnDestroyView)(HOGLVIEW3D);
};

    bool            mIs2D;
    bool            mIsDestructing;
    bool            mIsDestroying;
    int             mID;
    OGLVIEW*        mView2D;
    OGLVIEW3D*      mView3D;
    VIEW2DFUNCS     mOldView2DFuncs;
    VIEW3DFUNCS     mOldView3DFuncs;

private:

    void Init(bool is2D, ViewListener* listener)
    {
#ifdef DESTRUCT_VERBOSE
printf("OglGui::View c %d\n", ++sNrCreated);
#endif
        mID = sNr++;
        mListener = listener;
        mIsDestructing = false;
        mIsDestroying = false;
        memset(&mOldView2DFuncs, 0, sizeof(VIEW2DFUNCS));
        memset(&mOldView3DFuncs, 0, sizeof(VIEW3DFUNCS));
        if (mIs2D = is2D)
        {
            viewSys.SetSysData(mView2D, 1, this);
            mOldView2DFuncs.OnSelection = mView2D->OnSelection;
            mOldView2DFuncs.OnMouse = mView2D->OnMouse;
            mOldView2DFuncs.OnPreDrawView = mView2D->OnPreDrawView;
            mOldView2DFuncs.OnDrawView = mView2D->OnDrawView;
            mOldView2DFuncs.OnDestroyView = mView2D->OnDestroyView;

            mView2D->OnSelection = MyOnSelection;
            mView2D->OnMouse = MyOnMouse;
            mView2D->OnPreDrawView = MyOnPreDrawView;
            mView2D->OnDrawView = MyOnDrawView;
            mView2D->OnDestroyView = MyOnDestroyView;
        }
        else
        {
            view3DSys.SetSysData(mView3D, 1, this);
            mOldView3DFuncs.OnSelection = mView3D->OnSelection;
            mOldView3DFuncs.OnMouse = mView3D->OnMouse;
            mOldView3DFuncs.OnPreDrawView = mView3D->OnPreDrawView;
            mOldView3DFuncs.OnDrawView = mView3D->OnDrawView;
            mOldView3DFuncs.OnDestroyView = mView3D->OnDestroyView;

            mView3D->OnSelection = MyOnSelection3D;
            mView3D->OnMouse = MyOnMouse3D;
            mView3D->OnPreDrawView = MyOnPreDrawView3D;
            mView3D->OnDrawView = MyOnDrawView3D;
            mView3D->OnDestroyView = MyOnDestroyView3D;
        }
    }

// Interface to C based OGL viewers: OGLVIEW and OGLVIEW3D
    // 2D part

    static void MyOnSelection(OGLVIEW* view, GLBOOL selected)
    {
        View* v = (View *) viewSys.GetSysData(view, 1);
        v->OnSelection((selected != 0) ? true : false);
    }

    static void
    MyOnMouse(OGLVIEW* view, int msg, int btn, int state, float x, float y)
    {
        View* v = (View *) viewSys.GetSysData(view, 1);
        v->OnMouse(msg, btn, state, x, y);
    }

    static void MyOnPreDrawView(OGLVIEW* view)
    {
        View* v = (View *) viewSys.GetSysData(view, 1);
        v->OnPreDrawView();
    }

    static void MyOnDrawView(OGLVIEW* view)
    {
        View* v = (View *) viewSys.GetSysData(view, 1);
        v->OnDrawView();
    }

    static void MyOnDestroyView(OGLVIEW* view)
    {
        View* v = (View *) viewSys.GetSysData(view, 1);
        v->OnDestroyView();
    }

    // 3D part
    static void MyOnSelection3D(OGLVIEW3D* view, GLBOOL selected)
    {
        View* v = (View *) view3DSys.GetSysData(view, 1);
        v->OnSelection((selected != 0) ? true : false);
    }

    static void MyOnMouse3D(OGLVIEW3D* view, int msg, int btn, int state,
                            float x, float y)
    {
        View* v = (View *) view3DSys.GetSysData(view, 1);
        v->OnMouse(msg, btn, state, x, y);
    }

    static void MyOnPreDrawView3D(OGLVIEW3D* view)
    {
        View* v = (View *) view3DSys.GetSysData(view, 1);
        v->OnPreDrawView();
    }

    static void MyOnDrawView3D(OGLVIEW3D* view)
    {
        View* v = (View *) view3DSys.GetSysData(view, 1);
        v->OnDrawView();
    }

    static void MyOnDestroyView3D(OGLVIEW3D* view)
    {
        View* v = (View *) view3DSys.GetSysData(view, 1);
        v->OnDestroyView();
    }

    // private data:

    static int      sNr; // Static counter to give each viewer a unique ID
static int sNrCreated;

    ViewListener  *mListener;
};
int View::sNrCreated = 0;
} // namespace OglGui

#endif

---