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

---

Tabs.h

Go to the documentation of this file.

//345678901234567890123456789012345678901234567890123456789012345678901234567890
#ifndef OglGui_Tabs_h
#define OglGui_Tabs_h

/*
 * Author Dennis Koelma
 * TabAnimation Added: Richard van Balen
 */

#ifndef OglGui_vector_included
#include <vector>
#define OglGui_vector_included
#endif

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

#ifndef TabsListener_h
#include "OglGui/TabsListener.h"
#endif

#include "OglGui/Transition.h"

namespace OglGui
{

class Tabs : public Window, public ButtonListener, public WindowListener
{
public:

    Tabs(int x, int y, int wndW, int wndH, int labelW = 120, int labelH = 22):
         Window(x, y, wndW, wndH)
    {
        Init(labelW, labelH);
    }

    Tabs(Window* parent, int wndW, int wndH, int labelW = 120, int labelH = 22):
         Window(parent, wndW, wndH)
    {
        Init(labelW, labelH);
    }

    Tabs(Window* parent, int x, int y, int wndW, int wndH, int labelW = 120,
         int labelH = 22) :
        Window(parent, x, y, wndW, wndH)
    {
        Init(labelW, labelH);
    }

    void SetTabsListener(TabsListener* listener, void* listenerData = 0)
    {
        mTabsListener = listener;
        mTabsListenerData = listenerData;
    }

    Window* TabBar()                        { return mTitleWnd; }
    void TabsDissolve(bool mode)            { mDissolve = mode; }
    void TabsAnimated(int mode)             { mTabsAnimated = abs(mode); }
    void TabsAnimDivider(int d)             { mTabAnimDiv = abs(d%40); }

    void TabsTransition(int m1, int m2)
    {
        mTabTransit1 = m1;
        mTabTransit2 = m2;
    }

    void TabsTransitionGridXY(int x, int y)
    {
        mGridX=x;
        mGridY=y;
    }

    void ScaleTabBar(bool fixedHeight)
    {
        RepositionViewports();
        if (fixedHeight)
            mTitleWnd->ConnectTo(this,L2L|R2R|T2T|B2T);
        else
            mTitleWnd->ScaleTo(this);
        mTitleWnd->SetAllowScaling(false);
        mTitleWnd->RepositionViewports();
        mTitleWnd->ScaleChildren();
        mTitleWnd->SetAllowChildScaling(false);
    }

    Window*
    CreateTab(std::string title, int labelW = -1, int tabControlData = -1)
    {
        if (labelW == -1)
            labelW = mLabelWidth;
        int curBut = mCanvasList.size();
        Button* but = new Button(mTitleWnd, labelW, mLabelHeight+4, title);
        but->SetRoundness(200, 200, 2, 2);
        but->SetButtonListener(this, (void*)curBut);
        int canvasHeight = mOglWnd->height - mLabelHeight - 4;
        Window* canvas = new Window(this, 0, 0, mOglWnd->width, canvasHeight);
        canvas->ConnectTo(this, ALLSIDES | TPARENT);
        canvas->SetExternWindowReference(but);
        mCanvasList.push_back(canvas);
        mTabControlData.push_back(tabControlData);
        return canvas;
    }


    void SetActiveTab(int idx, bool idxIsTabNr = true)
    {
        if (!idxIsTabNr)
        {
            for (unsigned int i=0 ; i<mTabControlData.size() ; i++)
                if (mTabControlData[i] == idx)
                    idx = i;
        }
        if (idx < (int) mCanvasList.size())
        {
            for (int i=0 ; i < (int) mCanvasList.size() ; i++)
            {
                Button* btn =
                        (Button *) mCanvasList[i]->GetExternWindowReference();
                btn->SetBorderFillOpacity((i == idx) ? 0.8f : 0.3f);
                if (i == idx)
                {
                    mActiveTabId = idx;
                    HandleTabChangeAnimation();
                    mCanvasList[i]->SetVisible(true);
                    oglFocusWnd = mCanvasList[i]->GetOGLWND();
                    oglSys.SetUpdateScene(oglFocusWnd, 1);
                }
                else
                    mCanvasList[i]->SetVisible(false);
            }
            RepositionViewports();
            if (mTabsListener)
            {
                if (mTabControlData[idx] >= 0)
                    mTabsListener->TabSelectionEvent(this, idx,
                                                     mTabsListenerData,
                                                     mTabControlData[idx]);
                else
                    mTabsListener->TabSelectionEvent(this, idx,
                                                     mTabsListenerData);
            }
        }
    }

    int
    GetActiveTab()
    {
        return mActiveTabId;
    }

    int
    GetActiveTabControlData()
    {
        return mTabControlData[GetActiveTab()];
    }

    void
    ActivateNextTab()
    {
        int sz = mCanvasList.size();

        if (sz > 0)
            SetActiveTab((mActiveTabId+1) % sz);
    }

    // specialization of base classes

    virtual void
    ButtonSelectionEvent(Button *src, void* userData)
    {
        SetActiveTab((int)(long long) userData);
    }

    virtual void DisplayFunc()
    {
        HandleTabAnimation();
        Window::DisplayFunc();
    }

    virtual void
    WindowKeyboardEvent(Window *src, int c, int state, void *userData)
    {
        if (c >= '0' && c <= '9')
            TabsAnimated(c-'0');
        if (c == 'd')
            TabsDissolve(!mDissolve);
        if (c == oglCTRL('t'))
            TabsTransition(0,0);
        if (c == 't')
            TabsTransition((mTabTransit1+1)%32,mTabTransit2);
        if (c == 'T')
            TabsTransition(mTabTransit1,(mTabTransit2+1)%32);
        if (c == 's')
            mShowAnimInfo = !mShowAnimInfo;
        if (c == oglCTRL('x'))
            TabsTransitionGridXY(1+mGridX%7,mGridY);
        if (c == oglCTRL('y'))
            TabsTransitionGridXY(mGridX,1+mGridY%7);
    }

    virtual void
    WindowDisplayEvent(Window *src, void *userData)
    {
        if (mShowAnimInfo)
        {
            oglSys.PosColPrintf(src->GetOGLWND(),src->W()-160,4,oglRED,
                                "A:%d D:%d t:%d T:%d X:%d Y:%d",
                                mTabsAnimated, mDissolve ? 1 : 0,
                                mTabTransit1, mTabTransit2, mGridX, mGridY);
        }
    }

protected:

    void StartTabTransition()
    {
        if (!(mDissolve || mTabTransit1 || mTabTransit2))
            return;
        if (!mTransitionWnd)
            mTransitionWnd =  new Transition(this);
        mTransitionWnd->GridXY(mGridX, mGridY);
        //mTransitionWnd->FillColors(oglGUI_BG,oglTrWHITE,oglTrWHITE, oglGUI_BG);
        mTransitionWnd->FillColors(0x80d0c0b0,oglTrWHITE,oglTrWHITE, 0x80d0c0b0);
        mTransitionWnd->TransitionStart(mDissolve, mTabTransit1, mTabTransit2);
    }

    void StartTabAnimation()
    {
        if (!mTabsAnimated)
            return;
        Window* wnd = mCanvasList[mActiveTabId];
        int x,y,w,h;
        wnd->GetDimensions(x,y,w,h);
        if (mTabsAnimated & 5)
            x = (mTabsAnimated & 1) ? -w : w;
        if (mTabsAnimated & 10)
            y = (mTabsAnimated & 2) ? h : -h;
        wnd->SetDimensions(x,y,w,h);
        SetAlwaysDraw(mTabAnimating = true);

    }

    void HandleTabChangeAnimation()
    {
        StartTabAnimation();
        StartTabTransition();
    }

    void HandleTabAnimation()
    {
        if (!mTabAnimating)
            return;
        Window* wnd = mCanvasList[mActiveTabId];
        int x,y,w,h;
        wnd->GetDimensions(x,y,w,h);
        int dX = (mTabsAnimated & 1) ?  1 : -1;
        int dY = (mTabsAnimated & 2) ? -1 : 1;
        if (x < -1 || x > 1 || y < -1 || y > 1)
        {
            int addX = (x==-1||x==1) ? 0 :
                       ((mTabsAnimated & 5) ?  -x / mTabAnimDiv + dX : 0);
            int addY = (y==-1||y==1) ? 0 :
                       ((mTabsAnimated & 10) ? -y / mTabAnimDiv + dY : 0);
            addX = (addX > 40) ? 40 : addX;
            addX = (addX < -40) ? -40 : addX;
            addY = (addY > 40) ? 40 : addY;
            addY = (addY < -40) ? -40 : addY;
            wnd->SetDimensions(x+addX,y+addY,w,h);
        }
        else
        {
            SetAlwaysDraw(mTabAnimating = false);
            wnd->SetDimensions(0,0,w,h);
            wnd->UpdateScene();
        }
    }

private:

    void
    Init(int labelW, int labelH)
    {
        mTabsListener = 0;
        mTabsListenerData = 0;
        mLabelWidth = labelW;
        mLabelHeight = labelH;
        mTitleWnd = new Window(this, mOglWnd->width, mLabelHeight + 1);
RepositionViewports();
mTitleWnd->ConnectTo(this, OglGui::TOTOP | OglGui::TOLEFTRIGHT);
        mTitleWnd->SetWindowListener(this);
        mActiveTabId = 0;
        mTabsAnimated = 0;
        mTabAnimDiv = 4;
        mTabAnimating = false;
        mDissolve = false;
        mTransitionWnd = 0;
        mTabTransit1 = mTabTransit2 = 0;
        mShowAnimInfo = false;
        mGridX = 3;
        mGridY = 3;
    }

    int                  mLabelWidth;
    int                  mLabelHeight;
    TabsListener*        mTabsListener;
    void*                mTabsListenerData;
    std::vector<int>     mTabControlData;

    Window*              mTitleWnd;
    std::vector<Window*> mCanvasList;

    int                  mActiveTabId;

    bool                 mShowAnimInfo;

    int                  mTabsAnimated;
    int                  mTabAnimDiv;
    bool                 mTabAnimating;

    bool                 mDissolve;

    Transition*          mTransitionWnd;
    int                  mTabTransit1;
    int                  mTabTransit2;
    int                  mGridX;
    int                  mGridY;
};

} // namespace OglGui

#endif

---