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

---

Window.h

Go to the documentation of this file.

#ifndef OglGui_Window_h
#define OglGui_Window_h

// (RvB) Experimental mapping to old C functions.
// Maybe this should only be done in OglWindow and not here as well
//
// Discussion with Dennis and Michiel!!!
// IMPORTANT: I am strongly considering to combine OglWindow and Window
// Reason to split at first was:
//      1) to get a pure wrapper without extra functionality
//          (the purity however was offended when I added layout to it)
//      2) I initially thought that the mapping to OGLView2D3D prevented
//          overloading of existing C apps. This however is not the case

#ifndef OglGui_OglWindow_h
#include "OglGui/OglWindow.h"
#endif

#ifndef OglGui_WindowListener_h
#include "OglGui/WindowListener.h"
#endif

#ifndef OglGui_KeyListener_h
#include "OglGui/KeyListener.h"
#endif

#ifndef OglGui_RectTiler_h
// RvB: Ik wil nog een eigen versie hiervan om onafhankelijk te zijn
#include "OglGui/CxRectZTiler.h"
#define OglGui_RectTiler_h
#endif

#ifndef strconst
#define strconst    const std::string&
#endif

//using OglGui::OglWindow;

namespace OglGui
{

class Window : public OglWindow
{
public:
    Window(int x, int y, int width, int height, bool is2d=true) :
        OglWindow(x, y, width, height)
    {
        Init(is2d);
    }

    Window(Window* parent, int width, int height, bool is2d=true) :
        OglWindow(parent, 0, 0, width, height)
    {
        Init(is2d);
        parent->WindowAdded(this);
    }

    Window(Window* parent, int x, int y, int width, int height, bool is2d=true):
        OglWindow(parent, x, y, width, height)
    {
        Init(is2d);
        mAllowReposition = false;
        parent->WindowAdded(this);
    }

    Window(OGLWND *oglWnd, bool is2d=true) :
        OglWindow(oglWnd)
    {
        Init(is2d);
    }

    Window(OGLWND *oglWnd, int width, int height, bool is2d=true) :
        OglWindow(oglWnd, 0, 0, width, height)
    {
        Init(is2d);
    }

    Window(OGLWND *parent, int x, int y, int width, int height, bool is2d=true):
        OglWindow(parent, x, y, width, height)
    {
        Init(is2d);
        mAllowReposition = false;
    }

    virtual ~Window()
    {
#ifdef DESTRUCT_VERBOSE
printf("virtual OglGui::Window destructor\n");
#endif
//        ExitFunc();
        if (mOldUserCFunctions.exitFunc)
            mOldUserCFunctions.exitFunc(mOglWnd);
        else
        if (mIs2d)
            viewSys.ExitView2D(mOglWnd);
        else
           view3DSys.ExitView3D(mOglWnd);

        // RvB: 17-2-2009 Dangerous as mWindowListener may no longer live.
        // Commented for now since no one was using it yet.
        //if (mWindowListener)
        //  mWindowListener->WindowExitEvent(this, mListenerData);
    }

    static Window* CastToWindow(OglWindow *oWnd)
    {
        if (!oWnd)
            return 0;

        if (oWnd->GetRunTimeType() & 2)
            return (Window *) oWnd;
        return 0;
    }

    Window* GetParent() const
    {
       return CastToWindow(GetPeer(mOglWnd->parent));    
    }

    void OffsetXY(Window* someParent, int& x, int& y)
    {
        if (this == someParent)
            return;
        x += X();
        y += Y();
        GetParent()->OffsetXY(someParent, x, y);
    }

    bool Is2d() const
    {
        return mIs2d;
    }
    void SetIs2d(bool flag)
    {
        mIs2d = flag;
    }

    void RemoveViewports() const
    {
        while (mOglWnd->wndList)
        {
            OGLWND* child = (OGLWND *) mOglWnd->wndList->info;
            oglSys.ExitWindow(child, 1);
        }
    }


// Positioning and Scaling

    // For derived classes implementing RepositionViewers
    virtual void RepositionViewers()
    {
    }

    virtual void RepositionViewports()
    {
        LIST* obj;

        mViewportTiler.ResetWnd(mOglWnd->width, mOglWnd->height, 5);

        ForAllElements(obj, mOglWnd->wndList)
        {
            OGLWND* child = (OGLWND *) obj->info;
            if (child->tags & visibleTag)
            {
                Window* Window = CastToWindow(GetPeer(child));
                if (Window && Window->mAllowReposition)
                {
                    int x, y, w, h;
                    oglSys.GetDimensions(child, &x, &y, &w, &h);
                    mViewportTiler.GetPos2d((float)w, (float)h, x, y);
                    // RvB: Added 2 here rather than in the recttiler itself
                    oglSys.SetDimensions(child, x+2, y, w, h);
                    Window->RepositionViewports();
                }
            }
        }
    }

    void SetReposChildren(bool mode, bool recursive)
    {
        LIST        *obj;
        OGLWND      *child;
        Window      *wnd;

        ForAllElements (obj, mOglWnd->wndList)
        {
            child = (OGLWND *) obj->info;
            if (wnd = CastToWindow(GetPeer(child)))
            {
                wnd->mAllowReposition = mode;
                if (recursive)
                    wnd->SetReposChildren(mode, true);
            }
        }
    }

    void ScaleChildren(int mode=0, bool recursive=0)
    {
        LIST    *obj;
        OGLWND  *child;
        Window  *wnd;

        if (!mAllowChildScaling)
            return;

        ForAllElements (obj, mOglWnd->wndList)
        {
            child = (OGLWND *) obj->info;
            wnd = CastToWindow(GetPeer(child));
            if (wnd && wnd->mAllowScaling)
            {
                wnd->ScaleTo(this, mode);
                if (recursive)
                    wnd->ScaleChildren(mode, true);
            }
        }
    }
    /*
    void ScaleChildren(int mode=0, bool recursive=0)
    {
        LIST    *obj;
        OGLWND  *child;
        Window  *wnd = CastToWindow(GetPeer(mOglWnd));

        if (!wnd || !wnd->mAllowChildScaling)
            return;

        ForAllElements (obj, mOglWnd->wndList)
        {
            child = (OGLWND *) obj->info;
            wnd = CastToWindow(GetPeer(child));
            if (wnd && wnd->mAllowScaling)
            {
                wnd->ScaleTo(this, mode);
                if (recursive)
                    wnd->ScaleChildren(mode, true);
            }
        }
    }
    */

// Set/Get methods

    void SetWindowListener(WindowListener* listener, void* listenerData = 0)
    {
        mWindowListener = listener;
        mListenerData = listenerData;
    }
    void SetWindowListener(WindowListener* listener, int listenerData)
    {
        SetWindowListener(listener, (void*) listenerData);
    }

    // RvB: Experimental
    // allowing multiple listeners with chain of responsibility
    WindowListener* GetWindowListener(void*& userData)
    {
        userData = mListenerData;
        return mWindowListener;
    }

    // RvB: In destructor of Classes that set the globalKeyListener
    // a check should be made if they are the global key listener and
    // set it to 0, otherwise we risk calling a non-existing object.
    // Should we allow for multiple global key listeners? Discuss with Dennis!
    static void SetGlobalKeyListener(KeyListener* listener)
    {
        sGlobalKeyListener = listener;
    }

    void SetDisableOGLViewKeys(bool flag)
    {
        mDisableOGLViewKeys = flag;
    }

    bool GetDisableOGLViewKeys() const
    {
        return mDisableOGLViewKeys;
    }

    void SetDisableOGLViewMouse(bool flag)
    {
        mDisableOGLViewMouse = flag;
    }

    bool GetDisableOGLViewMouse() const
    {
        return mDisableOGLViewMouse;
    }

    static void GlobalKeyListeningDisabled(bool flag)
    {
        sGlobalKeyListeningDisabled = flag;
    }

    static bool GlobalKeyListeningDisabled()
    {
        return sGlobalKeyListeningDisabled;
    }

    void SetDisableGlobalKeyListener(bool flag)
    {
        mDisableGlobalKeyListener = flag;
    }

    bool GetDisableGlobalKeyListener() const
    {
        return mDisableGlobalKeyListener;
    }

    void SetAllowReposition(bool mode=true)
    {
        mAllowReposition = mode;
    }

    bool GetAllowReposition() const
    {
        return mAllowReposition;
    }

    void SetAllowScaling(bool mode)
    {
        mAllowScaling = mode;
    }

    bool GetAllowScaling() const
    {
        return mAllowScaling;
    }

    void SetAllowChildScaling(bool mode)
    {
        mAllowChildScaling = mode;
    }

    bool GetAllowChildScaling() const
    {
        return mAllowChildScaling;
    }

    void SetForeground(ULONG col)
    {
        mForeGroundColor = col;
    }

    ULONG GetForeground() const
    {
        return mForeGroundColor;
    }

    virtual int SetState(int nState)
    {
        int oldState = mState;
        mState = nState;
        return oldState;
    }

    int GetState() const
    {
        return mState;
    }

    void SetDoStateFeedback(bool on)
    {
        mDoStateFeedback = on;
    }

    void SetStateFeedbackColor(ULONG col)
    {
        mStateFeedbackColor = col;
    }

    bool GetDoStateFeedback() const
    {
        return mDoStateFeedback;
    }

    void SetExternWindowReference(Window *refWnd)
    {
        mExternWindowReference = refWnd;
    }

    Window* GetExternWindowReference() const
    {
        return mExternWindowReference;
    }

    void SetWindowText(char *txt)
    {
        OGLWND* oglWnd = oglSys.GetTopOGLWND(mOglWnd);
//#ifndef OGL_USING_GLUT
#if !defined(OGL_USING_GLUT) && !defined(OGL_USING_QT)
        if (oglWnd->hWnd)
            ::SetWindowText((HWND)oglWnd->hWnd, txt);
#endif
        oglWnd->topTitle = txt;
    }

    virtual void MapKeysTo(Window* wnd)
    {
        mMapKeysTarget = wnd;
    }

    void        GuiGeneralName(std::string name)  { mGuiGeneralName = name; }
    std::string GuiGeneralName()                  { return mGuiGeneralName; }

    void        GuiName(std::string name) { mGuiName = name;}
    std::string GuiName()                 { return mGuiName;}


// OGL standard callback functions

    virtual void InitFunc()
    {
        if (mOldUserCFunctions.initFunc != 0)
            OglWindow::InitFunc();
        else if (mIs2d)
            viewSys.InitView2D(mOglWnd);
        else
            view3DSys.InitView3D(mOglWnd);

        RepositionViewports();
        RepositionViewers();

        if (mWindowListener)
            mWindowListener->WindowInitEvent(this, mListenerData);
    }

    //Still somewhat experimental phase.
    //For now handled by destructor.
//    virtual void ExitFunc()
//    {
//    }

    virtual void InitDisplayFunc()
    {
        if (mOldUserCFunctions.initDisplayFunc)
            OglWindow::InitDisplayFunc();
        else if (mIs2d)
            viewSys.InitDrawScene(mOglWnd);
        else
            view3DSys.InitDrawScene(mOglWnd);

        mOldBorderBackground = mOglWnd->borderBgCol;

        if ((GetState() == 2) && mDoStateFeedback)
            mOglWnd->borderBgCol = mStateFeedbackColor;

        if (mWindowListener)
            mWindowListener->WindowInitDisplayEvent(this, mListenerData);
    }

    virtual void DisplayFunc()
    {
        mOglWnd->borderBgCol = mOldBorderBackground;

        if (mOldUserCFunctions.displayFunc)
            OglWindow::DisplayFunc();
        else if (mIs2d)
            viewSys.DrawScene(mOglWnd);
        else
            view3DSys.DrawScene(mOglWnd);

        if (mWindowListener)
            mWindowListener->WindowDisplayEvent(this, mListenerData);
    }

    virtual void MouseFunc(int msg, int but, int state, int x, int y)
    {
        if (!GetState())
            return;

        if (msg == oglMouseEnter)
        {
            SetState(2);
            oglSys.UpdateSceneFlag(mOglWnd, 1);
        }
        if (msg == oglMouseLeave)
        {
            SetState(1);
            oglSys.UpdateSceneFlag(mOglWnd, 1);
        }

        if (mOldUserCFunctions.mouseFunc)
            OglWindow::MouseFunc(msg, but, state, x, y);
        else if (!mDisableOGLViewMouse)
        {
            if (mIs2d)
                viewSys.MouseFunc(mOglWnd, msg, but, state, x, y);
            else
                view3DSys.MouseFunc(mOglWnd, msg, but, state, x, y);
        }

        if (mWindowListener)
            mWindowListener->WindowMouseEvent(this, msg, but, state, x, y,
                                              mListenerData);
    }

    virtual void KeyboardFunc(int c, int state)
    {
        if (!GetState())
            return;
        if (mMapKeysTarget)
            mMapKeysTarget->KeyboardFunc(c, state);

        if (mOldUserCFunctions.keyboardFunc)
            OglWindow::KeyboardFunc(c, state);
        else if (!mDisableOGLViewKeys)
        {
            if (mIs2d)
                viewSys.KeyFunc(mOglWnd, c, state);
            else
                view3DSys.KeyFunc(mOglWnd, c, state);
        }

        if (!mMapKeysTarget && sGlobalKeyListener && !mDisableGlobalKeyListener &&
            !sGlobalKeyListeningDisabled)
            sGlobalKeyListener->KeyEvent(this, c, state);

        if (mWindowListener)
            mWindowListener->WindowKeyboardEvent(this, c, state, mListenerData);
    }

    virtual void ViewportFunc(int width, int height)
    {
        if (mOldUserCFunctions.viewportFunc)
            OglWindow::ViewportFunc(width, height);
        else if (mIs2d)
            viewSys.Viewport(mOglWnd, width, height);
        else
            view3DSys.Viewport(mOglWnd, width, height);

        if (mWindowListener)
            mWindowListener->WindowViewportEvent(this, width, height,
                                                 mListenerData);
    }

    virtual void ReshapeFunc(int width, int height)
    {
        if (mOldUserCFunctions.reshapeFunc)
            OglWindow::ReshapeFunc(width, height);
        else if (mIs2d)
            viewSys.Reshape(mOglWnd, width, height);
        else
            view3DSys.Reshape(mOglWnd, width, height);

        RepositionViewports();
        RepositionViewers();
        OnLayoutChange();

        if (mWindowListener)
            mWindowListener->WindowReshapeEvent(this, width, height,
                                                mListenerData);
    }

protected:

    bool                mDoStateFeedback;
    ULONG               mStateFeedbackColor;
    ULONG               mForeGroundColor;

    Window*             mMapKeysTarget;

    bool                mIs2d;
    bool                mAllowReposition;
    bool                mAllowScaling;
    bool                mAllowChildScaling;

    std::string         mGuiName;
    std::string         mGuiGeneralName;

    static std::string  mClipboardString;

    virtual void WindowAdded(Window* wnd)
    {
    }

private:

    void
    Init(bool is2d)
    {
        //GuiGeneralName("Window");
        mWindowListener = 0;
        mListenerData = 0;

        mDisableGlobalKeyListener = false;
        mMapKeysTarget = 0;

        oglSys.SetAllowDeleteView(mOglWnd, FALSE);
        oglSys.SetAllowCameraMove(mOglWnd, FALSE);
        oglSys.SetAllowPick(mOglWnd, FALSE);
        oglSys.SetAllowRubber(mOglWnd, FALSE);

        // RvB: Maybe next 2 even standard true, and those needing them
        // have to set to false
        mDisableOGLViewKeys = false;
        mDisableOGLViewMouse = false;

        mRunTimeType |= 2;
        mExternWindowReference = 0; // Reference to some external wnd
        mState = 1; // 0: disabled, 1:normal, 2:mouse in wnd (highlight)
        mDoStateFeedback = false;
        mStateFeedbackColor = 0x80e08080;
        mForeGroundColor = 0xff000000;
        mOldBorderBackground = 0x0;
        mAllowReposition = true;
        mAllowScaling = true;
        mAllowChildScaling = true;
        mIs2d = is2d;
    }

    static KeyListener*   sGlobalKeyListener;
    static bool           sGlobalKeyListeningDisabled; // Globally
    bool                  mDisableGlobalKeyListener;   // Per window

    Window*               mExternWindowReference;
    WindowListener*       mWindowListener;
    void*                 mListenerData;
    int                   mState;
    ULONG                 mOldBorderBackground;
    CxRectZTiler          mViewportTiler;
    // RvB: Maybe introduce mDisableOGLViewKeys so that components not
    // using the viewer modules can prevent things like popping up help on ?
    // Decided to implement!
    bool                  mDisableOGLViewKeys;
    bool                  mDisableOGLViewMouse;
};

} // namespace OglGui
#endif

---