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

---

DropDownWindow.h

Go to the documentation of this file.

#ifndef OglGui_DropDownWindow_h
#define OglGui_DropDownWindow_h

// RvB: Note: I could have used the WndAdded function of Window
// but then an outsider could not provide for an animated background.
// Therefore chosen for AddWnd when an item wants to be known to the
// DropDownWindow.
// Also note: Deliberately chosen for very loose layout rules allowing
// the items inside maximum flexibility.
//
// Maybe I should create the header in a virtual function.
// That way others could provide for alternative headers.
// I could even have a final argument in the constructor with a
// header creator function pointer that defaults to 0

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

namespace OglGui
{

class DropDownWindow : public Window, WindowListener
{
public:

    DropDownWindow(Window* parent, int width, int height,
                   strconst txt, int options=PlusMinus+Lines) :
        Window(parent, width, height)
    {
        Init(width, height, txt, options);
    }

    DropDownWindow(Window* parent, int x, int y, int width, int height,
                   strconst txt, int options=PlusMinus+Lines) :
        Window(parent, x, y, width, height)
    {
        Init(width, height, txt, options);
    }

    enum DDOPTIONS {
        PlusMinus = 1,
        Lines = 2,
    };

    void AddWindow(Window* child, int inset=20, int insertAt=-1)
    {
        int     x,y,w,h;

        if (insertAt==-1 || insertAt > (int) mChildWindows.size()-1)
            mChildWindows.push_back(child);
        else
            mChildWindows.insert(mChildWindows.begin()+insertAt+1,child);
        child->SetAllowReposition(false);
        child->GetDimensions(x,y,w,h);
        child->SetDimensions(x+inset,y,w,h);
        HandleLayoutChange();
    }

    void HandleLayoutChange()
    {
        if(!mInitialized)
            return;
        Window* wnd = this;
        while(wnd != 0 && (wnd->GetRunTimeType() & 8))
        {
            wnd->DisplayFunc();
            wnd = wnd->GetParent();
        }
    }


    // Must be called when a child window has been deleted
    // from the DropDownWindow.
    void RemoveWindow(Window* child, bool destroy=false)
    {
        for (int i=0; i < (int) mChildWindows.size(); i++)
            if (child == mChildWindows[i])
            {
                mChildWindows.erase(mChildWindows.begin() + i);
                if (destroy)
                    delete child;
                HandleLayoutChange();
                return;
            }
    }

    void DropDown(bool mode=true)
    {
        mIsDropped = mode;
        if (mPlusMinText)
            mPlusMinText->SetText(mIsDropped ? "-" : "+");
        HandleLayoutChange();
    }

    void SetClosedHeight(int h)     { mClosedHeight = h; }
    bool IsDropped() const          { return mIsDropped; }
    void ShowLines(bool show=true)  { mShowLines = show; }
    void LinePattern(short pat)     { mLinePattern = pat; }
    void Spacing(int nPix)          { mSpacing = nPix; }

    Window*     HeaderWindow()      { return mHeaderWindow; }
    StaticText* HeaderText()        { return mHeaderText; }
    StaticText* PlusMinText()       { return mPlusMinText; }

// Listeners

    virtual void
    WindowMouseEvent(Window *src, int msg, int but, int state, int x, int y,
                     void* listenerData)
    {
        if (but==oglLeftButton)
        {
            if ((src == mPlusMinText && msg == oglMouseDown))
                DropDown(!mIsDropped);
            else if(src != mPlusMinText && msg == oglMouseDblClick)
                DropDown(!mIsDropped);
        }
    }

// Overloaded standard OGL functions
 
    virtual void
    DisplayFunc()
    {
        OGC     myOGC;
        int     curY = WndHeight();
        int     nY = curY-mHeaderHeight-2, nW = 0, nH = 0;
        int     lineX, topLineY = nY;
        bool    itemLines = (mShowLines && mIsDropped);

        mInitialized = true;

        mHeaderWindow->SetDimensions(RETAIN, nY, RETAIN, mHeaderHeight);

        if (mShowLines)
        {
            OGCSave(&myOGC);
            SetStipple(mLinePattern);
            SetSolidLineColor(mForeGroundColor);
            lineX = mHeaderWindow->WndX();
            DrawLine(lineX, nY+7, 0, nY+7);
            lineX += 6;
        }

        for (int i=0 ; i < (int) mChildWindows.size() ; i++)
        {
            int     cX, cY, cW, cH;
            Window*  child = mChildWindows[i];

            if (!HasTags((TAGABLE*)child->GetOGLWND(), visibleTag))
                continue;

            child->GetDimensions(cX,cY,cW,cH);
            
            nH   += cH + ((i==0) ? 4 : mSpacing);
            curY -= cH + ((i==0) ? 4 : mSpacing);

            child->SetDimensions(RETAIN, curY, RETAIN, RETAIN);

            if ((i>0) && itemLines)
            {
                if (lineX < cX )
                    DrawLine(lineX, curY+cH-11, cX-2, curY+cH-11);
                if (lineX > cX+cW)
                    DrawLine(lineX, curY+cH-11, cX+cW+2, curY+cH-11);
                nY = curY+cH-9;
            }

            if ((i<1) || (mIsDropped && (nW < cX+cW)))
                nW = cX+cW;
        }
        if (itemLines)
            DrawLine(lineX, nY, lineX, topLineY);

        nY = WndY() + WndHeight() - (mIsDropped ? nH : mClosedHeight);
        nH = mIsDropped ? nH : mClosedHeight;

        SetDimensions(WndX(), nY, nW+2, nH);

        if (mShowLines) OGCRestore(&myOGC);

        Window::DisplayFunc();
    }


private :

    Window*               mHeaderWindow;
    StaticText*           mPlusMinText;
    StaticText*           mHeaderText;
    std::vector<Window*>  mChildWindows;
    bool                  mShowLines;
    short                 mLinePattern;
    bool                  mIsDropped;
    int                   mHeaderHeight;
    int                   mClosedHeight;
    int                   mSpacing;
    bool                  mInitialized;

    void
    Init(int w, int h, strconst txt, int options)
    {
        int     hdrX = 2;
        int     hdrTxtX = 4;
        bool    plMin = (options & 1) ? true : false;

        mRunTimeType |= 8;
        mHeaderHeight = 16;
        mPlusMinText = 0;
        mIsDropped = false;
        mShowLines = (options & 2) ? true : false;
        mLinePattern = (short) oglDot;
        mRunTimeType |= 8;
        mSpacing = 2;
        mClosedHeight = h; // Allowing for partially opened in closed state
        mInitialized = false;

        mHeaderWindow = new Window(this, hdrX, 0, w-hdrX, mHeaderHeight);
        mHeaderWindow->SetWindowListener(this);

        if (plMin)
        {
            mPlusMinText = new StaticText(mHeaderWindow, 0, 3, 13, 13, "+");
            mPlusMinText->SetBorderType(BEV_LINE);
            mPlusMinText->SetDoStateFeedback(true);
            mPlusMinText->SetWindowListener(this);
            hdrTxtX = 14;
        }

        mHeaderText = new StaticText(mHeaderWindow, hdrTxtX, 0, w-hdrTxtX-2,
                                     16, txt);
        mHeaderText->SetAlign(oglLeftAlign, oglBottomAlign);
        mHeaderText->SetNoMouseInput(true);
        mHeaderText->SetWindowListener(this);

        AddWindow(mHeaderWindow, 0);
        DropDown(false);
    }
};

} // namespace OglGui

#endif // DropDownWindow_h

---