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

---

TwoPanesWindow.h

Go to the documentation of this file.

#ifndef OglGui_TwoPanesWindow_h
#define OglGui_TwoPanesWindow_h

/*
 *
 * changelog:
 * 14-5-06 Ork de Rooij: added mStartPos code in LayoutWindow
 */

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

namespace OglGui
{

class TwoPanesWindow : public Window
{
public:

    TwoPanesWindow(int x, int y, int w, int h, bool isHor=false) :
        Window(x, y, w, h)
    {
        Init(w, h, isHor);
    }

    TwoPanesWindow(Window *parent, int w, int h, bool isHor=false) :
        Window(parent, w, h)
    {
        Init(w, h, isHor);
    }

    TwoPanesWindow(Window *parent, int x, int y, int w, int h,bool isHor=false):
        Window( parent, x, y, w, h )
    {
        Init(w, h, isHor);
    }

    void LayoutPanes(bool mOwnStartPos = false, int mStartPos = 0)
    {
        int x,y,w,h;

        if( mLayedOut )
            return;

        mLayedOut = true;

        GetDimensions(x,y,w,h);

                if (! mOwnStartPos) {
                    for (int i=0; i<2; i++)
                    {
                     if (mPanes[i] && mIsHor)
                            mPanes[i]->SetDimensions(0, i*h/2+(i?4:0), w, h/2-4);
                        else if (mPanes[i] && !mIsHor)
                        mPanes[i]->SetDimensions(i*w/2+(i?4:0), 0, w/2-4, h);
                        }
                } else {
                        for (int i=0; i<2; i++)
                    {
                                int l = mStartPos;
                                int r = w - mStartPos;
                                if (mPanes[i] && mIsHor)
                                        mPanes[i]->SetDimensions(0, i?l+4:0, w, i?r-4:l-4);
                        else if (mPanes[i] && !mIsHor)
                                        mPanes[i]->SetDimensions(i?l+4:0, 0, i?r-4:l-4, h);
                        }

                }


        if (mIsHor)
        {
                        if (mOwnStartPos)
                    mSizeBar = new SizableWindow( this, 0, mStartPos-4, w, 8 );
                        else
                                mSizeBar = new SizableWindow( this, 0, h/2-4, w, 8 );
    
            mSizeBar->SetAllowMoveDirections(SizableWindow::EastWest, false);
            mSizeBar->ConnectTo(this, L2L | R2R | TPARENT);
        }
        else
        {
                        if (mOwnStartPos)
                    mSizeBar = new SizableWindow( this, mStartPos - 4, 0, 8, h );
                        else
                                mSizeBar = new SizableWindow( this, w/2-4, 0, 8, h );
            mSizeBar->SetAllowMoveDirections(SizableWindow::NorthSouth, false);
            mSizeBar->ConnectTo(this, T2T | B2B | TPARENT);
        }

        mSizeBar->SetAllowSizeDirections(SizableWindow::AllDir, false);
        mSizeBar->SetMoveCursor(mIsHor ? oglCursorN : oglCursorE);
//        mSizeBar->SetMoveCursor(mIsHor ? oglCursorNS : oglCursorWE);
        mSizeBar->SetBorderBackground( 0x80ff8080 );
        mSizeBar->SetMoveFeedback( true );
        mSizeBar->SetDoStateFeedback( true );

        if (mPanes[0])
            DoConnect(mPanes[0], mIsHor ? T2B : R2L,
                      TPARENT | (mIsHor ? B2B | L2L | R2R : B2B | T2T| L2L));

        if (mPanes[1])
            DoConnect(mPanes[1], mIsHor ? B2T : L2R,
                      TPARENT | (mIsHor ? T2T | L2L | R2R : B2B | T2T | R2R));

        SetReposChildren( false, false );
    }

        virtual void ReshapeFunc(int width, int height)
        {
                Window::ReshapeFunc(width, height);
                if (mLockToOther) {
                        // window is reshaping and the slider wants to be locked to the
            // other side: move it with the difference.
                        int oldpos,na,nb,nc;
                        if (mIsHor)
            {
                                mSizeBar->GetDimensions(na ,oldpos, nb, nc);
                                mSizeBar->SetDimensions(0,oldpos+height-mOldHeight, width, 8 );
                        } 
            else
            {
                                mSizeBar->GetDimensions(oldpos,na , nb, nc);
                                mSizeBar->SetDimensions(oldpos+width-mOldWidth, 0, 8, height );
                        }

                }
                mOldHeight = height;
                mOldWidth = width;
        }

        void SetMovable(bool isMovable) {
                if (isMovable) {
                        mSizeBar->SetAllowMoveDirections(SizableWindow::AllDir, true);
                        mSizeBar->
                SetAllowMoveDirections(mIsHor ? SizableWindow::EastWest :
                                       SizableWindow::NorthSouth, false);
                        mSizeBar->SetMoveCursor(mIsHor ? oglCursorN : oglCursorE);
                } else {
                        mSizeBar->SetAllowMoveDirections(SizableWindow::AllDir, false);
                        mSizeBar->SetMoveCursor(0);
                }
        }

        void SetLockToOtherSide(bool lockToOther) {
                mLockToOther = lockToOther;
        }


    void RegisterPane(Window *paneWnd, int i)
    {
        if (i > 2 || mPanes[i] != 0)
            return;

        mPanes[i] = paneWnd;
    }

    void SetMinPaneSize( int sz )
    {
        mMinSize = sz;
    }

    SizableWindow* SizeBar()
    {
        return mSizeBar;
    }

    virtual void DisplayFunc()
    {
        int     pX,pY,pW,pH;
        int     x,y,w,h;
        bool    adjust = false;

        GetDimensions(pX, pY, pW, pH);
        mSizeBar->GetDimensions(x, y, w, h);

        x +=4; y +=4;

        if (mIsHor)
        {
            if( y > pH - mMinSize )
                y = pH - mMinSize, adjust = true;
            if( y < mMinSize )
                y = mMinSize, adjust = true;
        }
        else
        {
            if( x > pW - mMinSize )
                x = pW - mMinSize, adjust = true;
            if( x < mMinSize )
                x = mMinSize, adjust = true;
        }
        x -=4; y -= 4;

        if( adjust )
        {
            mSizeBar->SetDimensions( x, y, w, h );
            OnLayoutChange();
        }
        Window::DisplayFunc();
    }

private:

    SizableWindow*  mSizeBar;
    Window*         mPanes[2];
    bool            mIsHor;
    bool            mLayedOut;
    int             mMinSize;

        int                             mOldWidth, mOldHeight;
        bool                    mLockToOther;

    void
    Init( int w, int h, bool isHor)
    {
        mIsHor = isHor;
        mLayedOut = false;
        mMinSize = 0;
        mPanes[0] = 0;
        mPanes[1] = 0;
        mOldWidth = w;
        mOldHeight = h;
        mLockToOther = false;
    }

    void
    DoConnect( Window* pane, int knobConnect, int frameConnect )
    {
        pane->ConnectTo( mSizeBar, knobConnect  );
        pane->ConnectTo( this, frameConnect );
    }
};

} //namespace OglGui
#endif

---