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

---

TitledWindow.h

Go to the documentation of this file.

#ifndef OglGui_TitledWindow_h
#define OglGui_TitledWindow_h

#ifndef OglGui_SizableWindow_h
#include "OglGui/SizableWindow.h"
#endif

#ifndef OglGui_StaticText_h
#include "OglGui/StaticText.h"
#endif

#ifndef OglGui_Button_h
#include "OglGui/Button.h"
#endif

#ifndef OglGui_CloseWindowListener_h
#include "OglGui/CloseWindowListener.h"
#endif

// RvB: There should be a possibility to react on close,
// allowing to cancel it.
// Maybe later indicate autoClosing of CloseListener: AutoClose=32 oid
// For now as test automatically delete on close

namespace OglGui
{

//class TitledWindow : public SizableWindow, public ButtonListener
class TitledWindow : public SizableWindow
{
public:

    TitledWindow(Window *parent, int x, int y, int w, int h, strconst title,
                 int extInfo=0, bool is2D=true) :
        SizableWindow(parent, x, y, w, h, is2D)
    {
        Init(title, extInfo, is2D);
    }

    TitledWindow(Window *parent, int w, int h, strconst title,
                 int extInfo=0, bool is2D=true) :
        SizableWindow(parent, w, h, is2D)
    {
        Init(title, extInfo, is2D);
    }

    enum TWInfo {
        BtnClose = 1,
        BtnMax = 2,
        BtnMaxClose = 3,
        BtnMin = 4,
        BtnMinClose = 5,
        BtnMinMax = 6,
        BtnMinMaxClose = 7,
        BtnRounded = 8,
        TitleRounded = 16,
        NoContent = 32
    };

    void SetCloseWindowListener(CloseWindowListener* l, void* userData)
    {
        mCloseWindowListener = l;
        mCloseWindowUserData = userData;
    }

    void GetClientArea(int& x, int& y, int& w, int& h)
    {
        x = 4;
        y = 4;
        w = WndWidth() - 8;
        h = WndHeight() - mTitleHeight - 8;
    }

    virtual void SetBorderType(int type)
    {
        SizableWindow::SetBorderType(type);
        SetHighLightBorderType(type);
    }

    void SetButtonRoundness(int r0, int r1, int r2, int r3)
    {
        mCloseButton->SetRoundness(r0, r1, r2, r3);
        mMaximizeButton->SetRoundness(r0, r1, r2, r3);
        mMinimizeButton->SetRoundness(r0, r1, r2, r3);
    }

    void SetButtonBorderType(int type)
    {
        mCloseButton->SetUpBorderType(type);
        mMaximizeButton->SetUpBorderType(type);
        mMinimizeButton->SetUpBorderType(type);
    }

    void SetContentPane(Window *nwPane, bool delOldContent=true,
                        bool doLayoutAndConnect=true)
    {
        if (delOldContent && mContent){
            delete mContent;
            mContent = 0;
        }
        if ((mContent = nwPane) && doLayoutAndConnect){
            int clX, clY, clW, clH;

            GetClientArea(clX, clY, clW, clH);
            mContent->SetDimensions(clX, clY, clW, clH);
            mContent->ConnectTo(this, ALLSIDES);
            mContent->SetAllowReposition(false);
        }
    }

    virtual void MouseFunc(int msg, int but, int state, int x, int y)
    {
        SizableWindow::MouseFunc(msg, but, state, x, y);

        if (but == oglLeftButton && msg == oglMouseDblClick)
            if (y > mOglWnd->height - mTitleHeight - 8)
                mMaximizeButton->DoButtonSelectionEvent();
    }

    // Get reference to components
    Window* ContentPane()
    {
        return mContent;
    } 

    Button* CloseButton()
    {
        return mCloseButton;
    }

    Button* MaximizeButton()
    {
        return mMaximizeButton;
    }

    Button* MinimizeButton()
    {
        return mMinimizeButton;
    }

    StaticText* TitleText()
    {
        return mTitleText;
    }

    virtual void OnCloseButton()
    {
        if (mCloseWindowListener)
            if (!mCloseWindowListener->OnCloseWindow(this,mCloseWindowUserData))
                return;
        if (mMaxConnection)
            mMaximizeButton->DoButtonSelectionEvent();
        delete this;
    }

    virtual void OnMaximizeButton()
    {
        int pX, pY, pW, pH;
        this->GetParent()->GetDimensions(pX,pY,pW,pH);
        if (mMaxConnection != 0)
        {                
            delete mMaxConnection;
            mMaxConnection = 0;

            SetAllowMove(mOldAllowMove);
            SetDimensions(mOldX, mOldY, mOldW, mOldH);
            this->GetParent()->OnLayoutChange();
        }
        else 
        {
            mOldAllowMove = GetAllowMove();
            SetAllowMove(false);
            GetDimensions(mOldX, mOldY, mOldW, mOldH);
            SetDimensions(0, 0, pW, pH);
            mMaxConnection = ConnectTo(this->GetParent(), ALLSIDES | TPARENT);
        }
        mMaximizeButton->SetText(mMaxConnection ? "[]]" : "[]");
        HandleTargetVisibility(mOglWnd->parent, mOglWnd, true, !mMaxConnection);            
        this->GetParent()->RepositionViewports();
    }

    virtual void OnMinimizeButton()
    {
    }

    class TitleBarButtonListener : public ButtonListener
    {
    public:
        virtual void ButtonSelectionEvent(Button* btn, void* lData)
        {
            TitledWindow* tWnd = (TitledWindow*)lData;
            if (btn == tWnd->MaximizeButton())
                tWnd->OnMaximizeButton();
            if (btn == tWnd->CloseButton())
                tWnd->OnCloseButton();
        }
    };
    /*
    virtual void ButtonSelectionEvent(Button* btn, int lData)
    {
        if (btn == mMaximizeButton)
            OnMaximizeButton();

        // RvB: For test purposes, autoClosing.
        // Later CloseListener and/or (virtual bool OnClosing)
        if (btn == mCloseButton)
            OnCloseButton();
    }
    */


private:

    void
    Init(strconst title, int extInfo, bool is2D)
    {
        mCloseWindowListener = 0;
        mTitleHeight = 24;
        mMaxConnection = 0;
        mContent = mTitleText = mMaximizeButton = mMinimizeButton = 0;
        mOldX = mOldY = mOldW = mOldH = 0;
        mMaximized = false;

        SetAllowChildScaling(false);
        SetBorderType(BEV_LINE);
        SetRoundness(10, 10, 0, 0);
        SetMinMaxSizes(120, RETAIN, mTitleHeight + 8, RETAIN);

        if (!(extInfo & NoContent))
            SetContentPane(new Window(this, 0, 0, 10, 10, is2D));

        CreateTitleBar(title, extInfo);
    }

    void
    CreateTitleBar(strconst title, int extInfo)
    {
        int     tH = mTitleHeight;
        int     w = WndWidth(), h = WndHeight();
        int     btnR = (extInfo & BtnRounded) ? 10 : 0;
        int     btnX = w - tH - 4, btnY = h - tH - 2;
        int     btnSz = tH - 4;

        mTitleBarButtonListener = new TitleBarButtonListener();

        mTitleText = new StaticText(this, 4, h-tH-4, w-8, tH, title, false);
        if (extInfo & TitleRounded)
        {
            mTitleText->SetRoundness(8, 8, 0, 0);
            if (!btnR)
                btnX -= 3;
        }

        mTitleText->SetBorderFillShaded(2);
        mTitleText->SetAlignOffsets(6, 0);
        mTitleText->SetForeground(oglWHITE);
        mTitleText->SetBorderType(-1);
        mTitleText->SetBorderBackground(0x806060a0);
        //mTitleText->SetBorderBackground(0xff4040ff);
        mTitleText->SetNoMouseInput(true);
        mTitleText->ConnectTo(this, L2L | R2R | T2T | B2T | TPARENT);

        mCloseButton =
            TitleBarButton(btnX, btnY, btnSz, !(extInfo & BtnClose), btnR, "X");
        mCloseButton->SetStateFeedbackColor(0xffff8080);
        mCloseButton->SetUpBorderType(BEV_RAISED);
        mCloseButton->SetBorderBackground(0xffd04040);
        btnX -= btnSz + 2;

        mMaximizeButton =
            TitleBarButton(btnX, btnY, btnSz, !(extInfo & BtnMax), btnR, "[]");
        mMaximizeButton->SetAlignOffsets(0, 1);
        mMaximizeButton->SetVisible((extInfo & BtnMax)?true:false);
        btnX -= btnSz + 2;

        mMinimizeButton =
            TitleBarButton(btnX, btnY, btnSz, !(extInfo & BtnMin), btnR, "_");
        mMinimizeButton->SetAlignOffsets(0, 1);
        mMinimizeButton->SetVisible((extInfo & BtnMin)?true:false);
    }

    Button*
    TitleBarButton(int x, int y, int btnSz, bool disabled, int btnR, char *str)
    {
        Button*   btn = new Button(this, x, y, btnSz, btnSz, str);

        btn->ConnectTo(this, L2R | R2R | B2T | T2T | TPARENT);
        btn->SetRoundness(btnR, btnR, btnR, btnR );
        btn->SetUpBorderType(BEV_RAISED);
        //btn->SetButtonListener(this);
        btn->SetButtonListener(mTitleBarButtonListener, (void*) this);

        if (!disabled)
        {
            btn->SetForeground(oglWHITE);
            btn->SetShadowColor(oglDARKGREY);
        }
        else
            btn->SetState(0);
        return btn;
    }

    void
    HandleTargetVisibility(OGLWND *parent, OGLWND *targetWnd,
                           bool targetMode, bool otherMode)
    {
        OGLWND  *oglWnd;
        LIST    *obj;

        ForAllElements(obj, parent->wndList)
        {
            oglWnd = (OGLWND *) obj->info;
            SetTagsTo((TAGABLE *) oglWnd, visibleTag,
                      oglWnd==targetWnd ? targetMode : otherMode);
        }
    }

    TitleBarButtonListener* mTitleBarButtonListener;

    CloseWindowListener*    mCloseWindowListener;
    void*                   mCloseWindowUserData;

    Window*           mContent;
    StaticText*       mTitleText;
    Button*           mCloseButton;
    Button*           mMaximizeButton;
    Button*           mMinimizeButton;
    LayoutListener*   mMaxConnection;
    bool              mMaximized;
    bool              mOldAllowMove;
    int               mTitleHeight;
    int               mOldX, mOldY, mOldW, mOldH;

};

} // namespace OglGui

#endif

---