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

---

SizableWindow.h

Go to the documentation of this file.

#ifndef OglGui_SizableWindow_h
#define OglGui_SizableWindow_h

#ifndef OglGui_Window_h
#include "OglGui/Window.h"
#endif

//#include "Link/OGL/LinkListMacros.h"

namespace OglGui
{

class SizableWindow : public Window
{
public:

    SizableWindow(Window *parent, int w, int h, bool is2D=true) :
        Window(parent, w, h, is2D)
    {
        Init();
    }

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

    enum ActionBits {
        North       = 1,
        East        = 2,
        NorthEast   = 3,
        South       = 4,
        NorthSouth  = 5,
        SouthEast   = 6,
        West        = 8,
        NorthWest   = 9,
        EastWest    = 10,
        SouthWest   = 12,
        Move        = 16,
        AllDir      = 15
    };

    // RvB: Should probably be moved to Window or even COglWnd or oglSys
    bool IsTopWindowInParent()
    {
        LIST    *obj = mOglWnd->parent->wndList;

        if (!obj)
            return false;

        while(obj->next)
            obj = obj->next;

        return obj->info == mOglWnd;
    }

    // RvB: Should probably be moved to Window or even COglWnd or oglSys
    virtual void BringToFront()
    {
        oglSys.BringToFront(mOglWnd);
/*
        OGLWND  *pOglWnd = mOglWnd->parent;
        LIST    *obj = S_FindItem(mOglWnd, pOglWnd->wndList);

        if (!obj)
            return;

            pOglWnd->wndList = oglSys.RemoveFromList(obj, pOglWnd->wndList);
            pOglWnd->wndList = S_Append(mOglWnd, pOglWnd->wndList);
*/
    }

    virtual void DisplayFunc()
    {
        Window::DisplayFunc();
        Window::SetBorderType(mHighLight?mHighLightBorderType:mNormalBorderType);

        if (mAllowHighLight && mHighLight)
        {
            float   r0, r1, r2, r3;
            int     w = mOglWnd->width, h = mOglWnd->height;
            int     brd = mHighLightInset;
            OGC     myOGC;

            OGCSave(&myOGC);
            SetSolidLineColor(mStateFeedbackColor);
            if (GetRoundness(r0, r1, r2, r3))
                DrawRoundRectExt(brd, brd, w - 2*brd, h - 2*brd, r0,r1,r2,r3);
            else
                DrawRectangle(brd, brd, w - 2*brd, h - 2*brd);
            OGCRestore(&myOGC);
        }
    }

    virtual void MouseFunc(int msg, int but, int state, int x, int y)
    {
        int theAction = 0;
        if (!mActOnModifier || !(state&mActOnModifier))
            Window::MouseFunc(msg, but, state, x, y);
        if (mActOnModifier && (mOglWnd->dragging || !(state&mActOnModifier)))
        {
            mHighLight = false;
            SetActionCursor(mAction = 0);
            return;
        }
        if (msg==oglMouseDown && !(state&oglControl) &&
            (mToFrontOnMouseDown && !IsTopWindowInParent()))
            BringToFront();

        if (mAction && msg == oglMouseUp)
            mAction = 0;

        if (msg == oglMouseLeave)
        {
            mHighLight = false;
            oglSys.SetCursor(oglCursorArrow);
        }

        if (msg == oglMouseDown && but == oglLeftButton)
        {
            mDx = x;
            mDy = y;
            if (theAction = GetAction(x, y))
                mAction |= theAction;
        }

        if (mAction)
            mHighLight = true;

        if (msg == oglMouseMove)
            mHighLight = (mAction != 0) || (theAction = GetAction(x, y));

        if (mAction && msg == oglMouseMove )
            PerformAction(x, y);

        SetActionCursor(theAction | mAction);
    }


// Setters / getters
    void ActOnModifier(int state)               { mActOnModifier = state; }
    int  ActOnModifier()                        { return mActOnModifier; }
    void SetToFrontOnMouseDown(bool m=true)     { mToFrontOnMouseDown = m; }
    void SetHighLightBorderType(int type)       { mHighLightBorderType = type; }
    void SetAllowHighlight(bool mode)           { mAllowHighLight = mode; }
    void SetHighLightInset(int inset)           { mHighLightInset = inset; }
    void SetAllowMove(bool mode)                { mAllowMove = mode; }
    bool GetAllowMove()                         { return mAllowMove; }
    void SetMoveFeedback(bool mode)             { mMoveFeedback = mode; }
    void SetMoveCursor(int nr)                  { mMoveCursorNr = nr; }

    virtual void SetBorderType(int type)
    {
        Window::SetBorderType(type);
        mNormalBorderType = type;
    }

    void SetMinMaxXY(int minX, int maxX, int minY, int maxY)
    {
        if (minX != RETAIN)
            mMinX = minX;
        if (minY != RETAIN)
            mMinY = minY;
        if (maxX != RETAIN)
            mMaxX = maxX;
        if (maxY != RETAIN)
            mMaxY = maxY;
    }

    void SetMinMaxSizes(int minW, int maxW, int minH, int maxH)
    {
        if (minW != RETAIN)
            mMinW = minW;
        if (minH != RETAIN)
            mMinH = minH;
        if (maxW != RETAIN)
            mMaxW = maxW;
        if (maxH != RETAIN)
            mMaxH = maxH;
    }

    void SetAllowMoveDirections(int bits, bool mode=true)
    {
        if (bits & NorthSouth)
            (mAllowMoveVert = mode);
        if (bits & EastWest)
            mAllowMoveHor = mode;
        if (bits & Move)
            mAllowMove = mode;
    }

    void SetAllowSizeDirections(int bits, bool mode=true)
    {
        if (bits & North)
            mAllowSizeNorth = mode;
        if (bits & East)
            mAllowSizeEast = mode;
        if (bits & South)
            mAllowSizeSouth = mode;
        if (bits & West)
            mAllowSizeWest = mode;
        if (bits & Move)
            mAllowMove = mode;
    }


protected:
    void SetActionCursor(int action)
    {
        int cursor = oglCursorArrow;
        if ((action & South) && (action & West))
            cursor = oglCursorSW;
        else if ((action & North) && (action & East))
            cursor = oglCursorNE;
        else if ((action & North) && (action & West))
            cursor = oglCursorNW;
        else if ((action & South) && (action & West))
            cursor = oglCursorSW;
        else if ((action & South) && (action & East))
            cursor = oglCursorSE;
        else if ((action & West) )
            cursor = oglCursorW;
        else if ((action & East))
            cursor = oglCursorE;
        else if ((action & South))
            cursor = oglCursorS;
        else if ((action & North))
            cursor = oglCursorN;

        // Could check for allowVert and allowHor with specific cursors
        else if (mMoveFeedback && (action & Move))
            cursor = mMoveCursorNr;

        oglSys.SetCursor(cursor);
    }

    int GetAction(int x, int y)
    {
        int action = 0;
        int w = WndWidth(), h = WndHeight();

        if (x >= 0 && x <= mSensePix && mAllowSizeWest)   action |= West;
        if (x >= w-mSensePix && x <= w && mAllowSizeEast) action |= East;
        if (y >= 0 && y <= mSensePix && mAllowSizeSouth)  action |= South;
        if (y >= h-mSensePix && y <= h && mAllowSizeNorth)action |= North;

        // Prevent impossible actions resulting from very small windows
        if ((action & (West|East)) == (West|East))
            action &= ~West;
        if ((action & (North|South)) == (North|South))
            action &= ~North;
        if (!action && x > 0 && y > 0 && x < w && y < h && mAllowMove)
            action = Move;
        return action;
    }

    bool ClampMinMax(int& nX, int& nY, int& nW, int& nH)
    {
        int clamped = -1;
        if (nX < mMinX) clamped = nX = mMinX;
        if (nY < mMinY) clamped = nY = mMinY;
        if (nX > mMaxX) clamped = nX = mMaxX;
        if (nY > mMaxY) clamped = nY = mMaxY;
        if (nW < mMinW) clamped = nW = mMinW;
        if (nH < mMinH) clamped = nH = mMinH;
        if (nW > mMaxW) clamped = nW = mMaxW;
        if (nH > mMaxH) clamped = nH = mMaxH;
        return clamped != -1;
    }

    // RvB: Consider limiting not only XY but complete bounds
    void CheckMinMax(int action, int& nX, int& nY, int& nW, int& nH)
    {
        int oX, oY, oW, oH;

        GetDimensions(oX, oY, oW, oH);

        if (nX < mMinX) nX = mMinX;
        if (nY < mMinY) nY = mMinY;
        if (nX > mMaxX) nX = mMaxX;
        if (nY > mMaxY) nY = mMaxY;

        if (nW < mMinW)
            if (action & West)
                nX = oX, nW = oW;
            else
                nW = mMinW;
        if (nH < mMinH)
            if (action & South)
                nY = oY, nH = oH;
            else
                nH = mMinH;
        if (nW > mMaxW)
            if (action & West)
                nX = oX, nW = oW;
            else
                nW = mMaxW;
        if (nH > mMaxH)
            if (action & South)
                nY = oY, nH = oH;
            else
                nH = mMaxH;
    }

    void PerformAction(int x, int y)
    {
        int nX, nY, nW, nH;
        GetDimensions(nX,nY,nW,nH);

        if (mAction == Move)
        {
            if (mAllowMoveHor)
                nX = x + nX - mDx;
            if (mAllowMoveVert)
                nY = y + nY - mDy;
        }
        if (mAction & West)
        {
            nX = nX + x;
            nW = nW - x;
        }
        if (mAction & East)
            nW = x;
        if (mAction & South)
        {
            nY = nY + y;
            nH = nH - y;
        }
        if (mAction & North)
            nH = y;

        CheckMinMax(mAction, nX, nY, nW, nH);
        SetDimensions(nX, nY, nW, nH);
    }

protected:

    int     mAction;
    int     mHighLightBorderType;
    int     mNormalBorderType;
    int     mMoveCursorNr;
    bool    mMoveFeedback;
    bool    mToFrontOnMouseDown;
    bool    mAllowHighLight;
    bool    mAllowMove;
    bool    mAllowSizeNorth;
    bool    mAllowSizeEast;
    bool    mAllowSizeSouth;
    bool    mAllowSizeWest;
    bool    mAllowMoveHor;
    bool    mAllowMoveVert;
    bool    mHighLight;
    int     mActOnModifier;
    int     mHighLightInset;
    int     mSensePix;
    int     mDx, mDy;
    int     mMinX, mMinY;
    int     mMaxX, mMaxY;
    int     mMinW, mMaxW;
    int     mMinH, mMaxH;

private:
    void Init()
    {
        oglSys.SetAllMouseMotion(mOglWnd, 1);
        mNormalBorderType       = BEV_ETCHED;
        mHighLightBorderType    = BEV_RIDGE;
        mMoveCursorNr           = oglCursorSizeAll;
        mHighLight              = false;
        mToFrontOnMouseDown     = true;
        mMoveFeedback           = false;
        mAllowHighLight         = true;
        mAllowMove              = true;
        mAllowMoveHor           = true;
        mAllowMoveVert          = true;
        mAllowSizeNorth         = true;
        mAllowSizeEast          = true;
        mAllowSizeSouth         = true;
        mAllowSizeWest          = true;
        mHighLightInset         = 3;
        mSensePix               = 6;
        mActOnModifier          = 0;
        mAction                 = 0;
        mDx                     = 0;
        mDy                     = 0;
        mMinX = mMinY           = -2000000;
        mMaxX = mMaxY           = 2000000;
        mMinW = mMinH           = 8;
        mMaxW = mMaxH           = 2000000;
    }
};

} // namespace OglGui
#endif

---