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

---

OglWindow.h

Go to the documentation of this file.

#ifndef OglGui_OglWindow_h
#define OglGui_OglWindow_h

#ifndef OglGui_string_included
#include <string>
#define OglGui_string_included
#endif

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

#ifndef OglGui_LayoutListener_h
#include "OglGui/LayoutListener.h"
#endif
#ifndef OglGui_LayoutConnect_h
#include "OglGui/LayoutConnect.h"
#endif
#ifndef OglGui_LayoutScale_h
#include "OglGui/LayoutScale.h"
#endif

namespace OglGui
{


class OglWindow : public LayoutComponent
{
public:

    OglWindow(int x, int y, int width, int height)
    {
        mOglWnd = oglSys.CreateOGLWND(x, y, width, height);
        Init();
    }

    OglWindow(OglWindow* parent, int x, int y, int width, int height)
    {
        mOglWnd = oglSys.CreateOGLViewPort(parent->mOglWnd, x, y, width,height);
        Init();
    }

    OglWindow(OGLWND *oglWnd)
    {
        mOglWnd = oglWnd;
        Init();
    }

    OglWindow(OGLWND *parent, int x, int y, int width, int height)
    {
        mOglWnd = oglSys.CreateOGLViewPort(parent, x, y, width, height);
        Init();
    }

    virtual ~OglWindow()
    {
#ifdef DESTRUCT_VERBOSE
printf("virtual OglGui::OglWindow destructor %d\n", mOglWnd);
#endif
        mIsDestructing = true;
        if (!mIsExiting && mOglWnd)
            oglSys.ExitWindow(mOglWnd, 1);
    }

    // Layout handling
    virtual void OnLayoutChange()
    {
        for(unsigned int i=0 ; i<mLayoutFollowers.size() ; i++)
            if (mLayoutFollowers[i] != 0)
                mLayoutFollowers[i]->OnLayoutChange();
    }

    LayoutListener* ConnectTo(LayoutComponent* target, int mode=ALLSIDES)
    {
        if (target == GetParent())
            mode |= TPARENT;
        return new LayoutConnect(target, this, mode);
    }

    LayoutListener* ScaleTo(LayoutComponent* target, int mode=0)
    {
        return new LayoutScale(target, this, mode);
    }

    //----------------------------------------------------------------

    bool Valid() const
    {
        return (mOglWnd != 0);
    }

    OGLWND* GetOGLWND() const
    {
        return mOglWnd;
    }

    void UpdateScene(bool mode=true) const
    {
        oglSys.SetUpdateScene(mOglWnd, mode);
    }

    virtual void SetFocus()
    {
        oglFocusWnd = mOglWnd;
    }

    void SetAlwaysDraw(bool mode=true)
    {
        oglSys.SetAlwaysDraw(mOglWnd, mode);
    }

    void SetVisible(bool flag=true)
    {
        if (flag)
            SetTags((TAGABLE *) mOglWnd, visibleTag);
        else
            ClearTags((TAGABLE *) mOglWnd, visibleTag);
    }

    bool GetVisible()
    {
        return HasTags((TAGABLE *) mOglWnd, visibleTag) ? true : false;
    }

    void SetBackground(ULONG col)
    {
        oglSys.SetBackground(mOglWnd, col);
    }

    ULONG GetBackground()
    {
        return oglSys.GetBackground(mOglWnd);
    }

    int WndX()      { return mOglWnd->x; }      // Deprecated
    int WndY()      { return mOglWnd->y; }      // Deprecated
    int WndWidth()  { return mOglWnd->width; }  // Deprecated
    int WndHeight() { return mOglWnd->height; } // Deprecated

    int X()         { return mOglWnd->x; }
    int Y()         { return mOglWnd->y; }
    int W()         { return mOglWnd->width; }
    int H()         { return mOglWnd->height; }
    int Width()     { return mOglWnd->width; }
    int Height()    { return mOglWnd->height; }

    static void ToTopWindow(OglWindow* wnd, int& x, int& y)
    {
        oglSys.VPToTopWndI(wnd->GetOGLWND(),&x,&y);
    }
    static void TopWindowTo(OglWindow* wnd, int& x, int& y)
    {
        oglSys.TopWndToVPI(wnd->GetOGLWND(),&x,&y);
    }

    void SetDimensions(int x, int y, int w, int h)
    {
        bool workaround = (x!=mOglWnd->x || y!= mOglWnd->y) &&
                          (w==mOglWnd->width) && (h==mOglWnd->height);

        oglSys.SetDimensions(mOglWnd, x, y, w, h);
        if (workaround)
            OnLayoutChange();
    }

    void SetDimensions(int w, int h)
    {
        SetDimensions(mOglWnd->x, mOglWnd->y, w, h);
        //oglSys.SetDimensions(mOglWnd, mOglWnd->x, mOglWnd->y, w, h);
    }

    void GetDimensions(int& x, int& y, int& w, int& h)
    {
        x = mOglWnd->x;
        y = mOglWnd->y;
        w = mOglWnd->width;
        h = mOglWnd->height;
    }

    void GetDimensions(int& w, int& h)
    {
        w = mOglWnd->width;
        h = mOglWnd->height;
    }

    bool IsRounded()
    {
        OGLWND *w = GetOGLWND();
        return w->r0 != 0.0f || w->r1 != 0.0f || w->r2 != 0.0f || w->r3 != 0.0f;
    }

    void SetRoundness(float r0, float r1, float r2, float r3)
    {
        oglSys.SetRoundness(mOglWnd, r0, r1, r2, r3);
    }

    bool GetRoundness(float& r0, float& r1, float& r2, float& r3)
    {
        r0 = mOglWnd->r0;
        r1 = mOglWnd->r1;
        r2 = mOglWnd->r2;
        r3 = mOglWnd->r3;
        return r0 != 0.0f || r1 != 0.0f || r2 != 0.0f || r3 != 0.0f;
    }

    void SetClipRounded(bool mode)
    {
        mOglWnd->clipRounded = mode;
    }

    virtual void SetBorderType(int type)
    {
        mOglWnd->borderType = type;
    }

    int GetBorderType()
    {
        return mOglWnd->borderType;
    }

    void SetBorderBackground(ULONG col)
    {
        mOglWnd->borderBgCol = col;
    }

    ULONG GetBorderBackground()
    {
        return mOglWnd->borderBgCol;
    }

    virtual void SetBorderFillShaded(int sh=2)
    {
        mOglWnd->borderFillShaded = sh;
    }

    int GetBorderFillShaded()
    {
        return mOglWnd->borderFillShaded;
    }

    void SetBorderFillOpacity(float op=0.5f)
    {
        mOglWnd->borderFillOpacity = op;
    }

    float GetBorderFillOpacity()
    {
        return mOglWnd->borderFillOpacity;
    }

    void SetNoMouseInput(bool mode=true)
    {
        oglSys.SetNoMouseInput(mOglWnd,mode);
    }

    int GetId() const
    {
        return mID;
    }

    int GetRunTimeType()
    {
        return mRunTimeType;
    }

    static OglWindow* GetPeer(OGLWND* oglWnd)
    {
        if (!oglWnd)
            return 0;
        return (OglWindow*) oglSys.GetSysData(oglWnd, 1);
    }

    OglWindow* GetParent()
    {
        if (mOglWnd->parent)
            return (OglWindow*) oglSys.GetSysData(mOglWnd->parent, 1);
        return 0;
    }

    static OglWindow* GetOglWindow(OGLWND* oglWnd)
    {
        return static_cast<OglWindow*>(oglSys.GetSysData(oglWnd, 1));
        // RvB: Wat is het verschil tussen static_cast en gewone.
        // return (OglWindow*)(oglSys.GetSysData(oglWnd, 1));
    }

// C++ OVERLOADABLE OGL USER FUNCS.
//
// In support of overloading C OGL apps, default mapped to execute
// old C user functions, if any.

    virtual void InitFunc()
    {
        if (mOldUserCFunctions.initFunc)
            mOldUserCFunctions.initFunc(mOglWnd);
    }

    virtual void ExitFunc()
    {
        mIsExiting = true;
        if (mOldUserCFunctions.exitFunc)
        {
            OGLUSERFUNCS funcs = mOldUserCFunctions;
            mOldUserCFunctions.exitFunc = 0;
            funcs.exitFunc(mOglWnd);
        }

        if (!mIsDestructing)
            delete this;
    }

/*    
    virtual void ExitFunc()
    {
        if (mOldUserCFunctions.exitFunc)
        {
            mOldUserCFunctions.exitFunc(mOglWnd);
            mOldUserCFunctions.exitFunc = 0;
        }

        mIsExiting = true;

        if (!mIsDestructing)
            delete this;
    }
*/    

    virtual void InitDisplayFunc()
    {
        if (mOldUserCFunctions.initDisplayFunc)
            mOldUserCFunctions.initDisplayFunc(mOglWnd);
    }

    virtual void DisplayFunc()
    {
        if (mOldUserCFunctions.displayFunc)
            mOldUserCFunctions.displayFunc(mOglWnd);
    }

    virtual void MouseFunc(int msg, int but, int state, int x, int y)
    {
        if (mOldUserCFunctions.mouseFunc)
            mOldUserCFunctions.mouseFunc(mOglWnd, msg, but, state, x, y);
    }

    virtual void KeyboardFunc(int c, int state)
    {
        if (mOldUserCFunctions.keyboardFunc)
            mOldUserCFunctions.keyboardFunc(mOglWnd, c, state);
    }

    virtual void ViewportFunc(int width, int height)
    {
        if (mOldUserCFunctions.viewportFunc)
            mOldUserCFunctions.viewportFunc(mOglWnd, width, height);
    }

    virtual void ReshapeFunc(int width, int height)
    {
        if (mOldUserCFunctions.reshapeFunc)
            mOldUserCFunctions.reshapeFunc(mOglWnd, width, height);
        OnLayoutChange();
    }

// END OF C++ OGL USER FUNCS.
 
    virtual void Start()
    {
        Sys::Instance().Start(mOglWnd);
    }

protected:

    OGLWND*         mOglWnd;
    int             mRunTimeType;
    OGLUSERFUNCS    mOldUserCFunctions;
    bool            mDone;
    bool            mIsDestructing;
    bool            mIsExiting;

    void GlueFuncs()
    {
        memcpy((void*) &mOldUserCFunctions, &(mOglWnd->userFuncs),
               sizeof(OGLUSERFUNCS));

        mOglWnd->userFuncs.initFunc = GlueInitFunc;
        mOglWnd->userFuncs.exitFunc = GlueExitFunc;
        mOglWnd->userFuncs.initDisplayFunc = GlueInitDisplayFunc;
        mOglWnd->userFuncs.displayFunc = GlueDisplayFunc;
        mOglWnd->userFuncs.mouseFunc = GlueMouseFunc;
        mOglWnd->userFuncs.keyboardFunc = GlueKeyboardFunc;
        mOglWnd->userFuncs.viewportFunc = GlueViewportFunc;
        mOglWnd->userFuncs.reshapeFunc = GlueReshapeFunc;
    }

private:

    static int      mNr;
    int             mID;

    void
    Init()
    {
        if (!mOglWnd)
        {
            fprintf(stderr, "CreateOGLWND/ViewPort failed\n");
            return;
        }

        mRunTimeType = 1;

        oglSys.SetSysData(mOglWnd, 1, this);
        mID = mNr++;
        mIsDestructing = false;
        mIsExiting = false;

        GlueFuncs();
    }

/*
    void GlueFuncs()
    {
        memcpy((void*) &mOldUserCFunctions, &(mOglWnd->userFuncs),
               sizeof(OGLUSERFUNCS));

        mOglWnd->userFuncs.initFunc = GlueInitFunc;
        mOglWnd->userFuncs.exitFunc = GlueExitFunc;
        mOglWnd->userFuncs.initDisplayFunc = GlueInitDisplayFunc;
        mOglWnd->userFuncs.displayFunc = GlueDisplayFunc;
        mOglWnd->userFuncs.mouseFunc = GlueMouseFunc;
        mOglWnd->userFuncs.keyboardFunc = GlueKeyboardFunc;
        mOglWnd->userFuncs.viewportFunc = GlueViewportFunc;
        mOglWnd->userFuncs.reshapeFunc = GlueReshapeFunc;
    }
*/

    static void
    GlueInitFunc(OGLWND* oglWnd)
    {
        GetOglWindow(oglWnd)->InitFunc();
    }

    static void 
    GlueExitFunc(OGLWND* oglWnd)
    {
        OglWindow *wnd = GetOglWindow(oglWnd);
        wnd->ExitFunc();
    }
    
    static void 
    GlueInitDisplayFunc(OGLWND* oglWnd)
    {
        GetOglWindow(oglWnd)->InitDisplayFunc();
    }
    
    static void 
    GlueDisplayFunc(OGLWND* oglWnd)
    {
        GetOglWindow(oglWnd)->DisplayFunc();
    }
    
    static void 
    GlueMouseFunc(OGLWND* oglWnd, INT msg, INT but, INT state, INT x, INT y)
    {
        oglSys.UpdateSceneFlag(oglWnd, 1);
        GetOglWindow(oglWnd)->MouseFunc(msg, but, state, x, y);
    }
    
    static void 
    GlueKeyboardFunc(OGLWND* oglWnd, INT c, INT state)
    {
        GetOglWindow(oglWnd)->KeyboardFunc(c, state);
        oglSys.UpdateSceneFlag(oglWnd, 1);
    }
    
    static void 
    GlueViewportFunc(OGLWND* oglWnd, INT width, INT height)
    {
        GetOglWindow(oglWnd)->ViewportFunc(width, height);
    }
    
    static void 
    GlueReshapeFunc(OGLWND* oglWnd, INT width, INT height)
    {
        GetOglWindow(oglWnd)->ReshapeFunc(width, height);
    }

};

} // namespace OglGui
#endif

---