IGUIElement.hpp

// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in nirtcpp/nirtcpp.hpp
 
#ifndef NIRT_I_GUI_ELEMENT_HPP_INCLUDED
#define NIRT_I_GUI_ELEMENT_HPP_INCLUDED
 
#include <nirtcpp/core/engine/IAttributeExchangingObject.hpp>
#include <nirtcpp/core/engine/irrList.hpp>
#include <nirtcpp/core/engine/rect.hpp>
#include <nirtcpp/core/engine/irrString.hpp>
#include <nirtcpp/core/engine/IEventReceiver.hpp>
#include <nirtcpp/core/engine/EGUIElementTypes.hpp>
#include <nirtcpp/core/engine/EGUIAlignment.hpp>
#include <nirtcpp/core/engine/IAttributes.hpp>
#include <nirtcpp/core/engine/IGUIEnvironment.hpp>
 
namespace nirt
{
namespace gui
{
class IGUIElement : public virtual io::IAttributeExchangingObject, public IEventReceiver
{
public:
 
    IGUIElement(EGUI_ELEMENT_TYPE type, IGUIEnvironment* environment, IGUIElement* parent,
        s32 id, const core::rect<s32>& rectangle)
        : Parent(0), RelativeRect(rectangle), AbsoluteRect(rectangle),
        AbsoluteClippingRect(rectangle), DesiredRect(rectangle),
        MaxSize(0,0), MinSize(1,1), IsVisible(true), IsEnabled(true),
        IsSubElement(false), NoClip(false), ID(id), IsTabStop(false), TabOrder(-1), IsTabGroup(false),
        AlignLeft(EGUIA_UPPERLEFT), AlignRight(EGUIA_UPPERLEFT), AlignTop(EGUIA_UPPERLEFT), AlignBottom(EGUIA_UPPERLEFT),
        Environment(environment), Type(type)
    {
        #ifdef _DEBUG
        setDebugName("IGUIElement");
        #endif
 
        // if we were given a parent to attach to
        if (parent)
        {
            parent->addChildToEnd(this);
            recalculateAbsolutePosition(true);
        }
    }
 
 
    virtual ~IGUIElement()
    {
        // delete all children
        core::list<IGUIElement*>::Iterator it = Children.begin();
        for (; it != Children.end(); ++it)
        {
            (*it)->Parent = 0;
            (*it)->drop();
        }
    }
 
 
    IGUIElement* getParent() const
    {
        return Parent;
    }
 
    core::rect<s32> getRelativePosition() const
    {
        return RelativeRect;
    }
 
 
 
    void setRelativePosition(const core::rect<s32>& r)
    {
        if (Parent)
        {
            const core::rect<s32>& r2 = Parent->getAbsolutePosition();
 
            const core::dimension2df d((f32)(r2.getSize().Width), (f32)(r2.getSize().Height));
 
            if (AlignLeft   == EGUIA_SCALE)
                ScaleRect.UpperLeftCorner.X = (f32)r.UpperLeftCorner.X / d.Width;
            if (AlignRight  == EGUIA_SCALE)
                ScaleRect.LowerRightCorner.X = (f32)r.LowerRightCorner.X / d.Width;
            if (AlignTop    == EGUIA_SCALE)
                ScaleRect.UpperLeftCorner.Y = (f32)r.UpperLeftCorner.Y / d.Height;
            if (AlignBottom == EGUIA_SCALE)
                ScaleRect.LowerRightCorner.Y = (f32)r.LowerRightCorner.Y / d.Height;
        }
 
        DesiredRect = r;
        updateAbsolutePosition();
    }
 
 
    void setRelativePosition(const core::position2di & position)
    {
        const core::dimension2di mySize = RelativeRect.getSize();
        const core::rect<s32> rectangle(position.X, position.Y,
                        position.X + mySize.Width, position.Y + mySize.Height);
        setRelativePosition(rectangle);
    }
 
 
 
    void setRelativePositionProportional(const core::rect<f32>& r)
    {
        if (!Parent)
            return;
 
        const core::dimension2di& d = Parent->getAbsolutePosition().getSize();
 
        DesiredRect = core::rect<s32>(
                    core::floor32((f32)d.Width * r.UpperLeftCorner.X),
                    core::floor32((f32)d.Height * r.UpperLeftCorner.Y),
                    core::floor32((f32)d.Width * r.LowerRightCorner.X),
                    core::floor32((f32)d.Height * r.LowerRightCorner.Y));
 
        ScaleRect = r;
 
        updateAbsolutePosition();
    }
 
 
    core::rect<s32> getAbsolutePosition() const
    {
        return AbsoluteRect;
    }
 
 
    core::rect<s32> getAbsoluteClippingRect() const
    {
        return AbsoluteClippingRect;
    }
 
 
 
    void setNotClipped(bool noClip)
    {
        NoClip = noClip;
        updateAbsolutePosition();
    }
 
 
 
    bool isNotClipped() const
    {
        return NoClip;
    }
 
 
 
    void setMaxSize(core::dimension2du size)
    {
        MaxSize = size;
        updateAbsolutePosition();
    }
 
 
    void setMinSize(core::dimension2du size)
    {
        MinSize = size;
        if (MinSize.Width < 1)
            MinSize.Width = 1;
        if (MinSize.Height < 1)
            MinSize.Height = 1;
        updateAbsolutePosition();
    }
 
 
    void setAlignment(EGUI_ALIGNMENT left, EGUI_ALIGNMENT right, EGUI_ALIGNMENT top, EGUI_ALIGNMENT bottom)
    {
        AlignLeft = left;
        AlignRight = right;
        AlignTop = top;
        AlignBottom = bottom;
 
        if (Parent)
        {
            const core::rect<s32> r(Parent->getAbsolutePosition());
            const core::dimension2df d((f32)r.getSize().Width, (f32)r.getSize().Height);
 
            if (AlignLeft   == EGUIA_SCALE)
                ScaleRect.UpperLeftCorner.X = (f32)DesiredRect.UpperLeftCorner.X / d.Width;
            if (AlignRight  == EGUIA_SCALE)
                ScaleRect.LowerRightCorner.X = (f32)DesiredRect.LowerRightCorner.X / d.Width;
            if (AlignTop    == EGUIA_SCALE)
                ScaleRect.UpperLeftCorner.Y = (f32)DesiredRect.UpperLeftCorner.Y / d.Height;
            if (AlignBottom == EGUIA_SCALE)
                ScaleRect.LowerRightCorner.Y = (f32)DesiredRect.LowerRightCorner.Y / d.Height;
        }
    }
 
    EGUI_ALIGNMENT getAlignLeft() const 
    {
        return AlignLeft;
    }
 
    EGUI_ALIGNMENT getAlignRight() const 
    {
        return AlignRight;
    }
 
    EGUI_ALIGNMENT getAlignTop() const 
    {
        return AlignTop;
    }
 
    EGUI_ALIGNMENT getAlignBottom() const 
    {
        return AlignBottom;
    }
 
    virtual void updateAbsolutePosition()
    {
        recalculateAbsolutePosition(false);
 
        // update all children
        core::list<IGUIElement*>::Iterator it = Children.begin();
        for (; it != Children.end(); ++it)
        {
            (*it)->updateAbsolutePosition();
        }
    }
 
 
 
    virtual IGUIElement* getElementFromPoint(const core::position2d<s32>& point)
    {
        IGUIElement* target = 0;
 
        // we have to search from back to front, because later children
        // might be drawn over the top of earlier ones.
 
        core::list<IGUIElement*>::ConstIterator it = Children.getLast();
 
        if (isVisible())
        {
            while(it != Children.end())
            {
                target = (*it)->getElementFromPoint(point);
                if (target)
                    return target;
 
                --it;
            }
        }
 
        if (isVisible() && isPointInside(point))
            target = this;
 
        return target;
    }
 
 
 
    virtual bool isPointInside(const core::position2d<s32>& point) const
    {
        return AbsoluteClippingRect.isPointInside(point);
    }
 
 
    virtual void addChild(IGUIElement* child)
    {
        if ( child && child != this )
        {
            addChildToEnd(child);
            child->updateAbsolutePosition();
        }
    }
 
    virtual void removeChild(IGUIElement* child)
    {
        core::list<IGUIElement*>::Iterator it = Children.begin();
        for (; it != Children.end(); ++it)
            if ((*it) == child)
            {
                (*it)->Parent = 0;
                (*it)->drop();
                Children.erase(it);
                return;
            }
    }
 
 
    virtual void remove()
    {
        if (Parent)
            Parent->removeChild(this);
    }
 
 
    virtual void draw()
    {
        if ( isVisible() )
        {
            core::list<IGUIElement*>::Iterator it = Children.begin();
            for (; it != Children.end(); ++it)
                (*it)->draw();
        }
    }
 
 
    virtual void OnPostRender(u32 timeMs)
    {
        if ( isVisible() )
        {
            core::list<IGUIElement*>::Iterator it = Children.begin();
            for (; it != Children.end(); ++it)
                (*it)->OnPostRender( timeMs );
        }
    }
 
 
    virtual void move(core::position2d<s32> absoluteMovement)
    {
        setRelativePosition(DesiredRect + absoluteMovement);
    }
 
 
    virtual bool isVisible() const
    {
        return IsVisible;
    }
 
 
    virtual bool isTrulyVisible() const
    {
        if(!IsVisible)
            return false;
 
        if(!Parent)
            return true;
 
        return Parent->isTrulyVisible();
    }
 
    virtual void setVisible(bool visible)
    {
        IsVisible = visible;
    }
 
 
    virtual bool isSubElement() const
    {
        return IsSubElement;
    }
 
 
 
    virtual void setSubElement(bool subElement)
    {
        IsSubElement = subElement;
    }
 
 
 
    void setTabStop(bool enable)
    {
        IsTabStop = enable;
    }
 
 
    bool isTabStop() const
    {
        return IsTabStop;
    }
 
 
 
    void setTabOrder(s32 index)
    {
        // negative = autonumber
        if (index < 0)
        {
            TabOrder = 0;
            IGUIElement *el = getTabGroup();
            while (IsTabGroup && el && el->Parent)
                el = el->Parent;
 
            IGUIElement *first=0, *closest=0;
            if (el)
            {
                // find the highest element number
                el->getNextElement(-1, true, IsTabGroup, first, closest, true, true);
                if (first)
                {
                    TabOrder = first->getTabOrder() + 1;
                }
            }
 
        }
        else
            TabOrder = index;
    }
 
 
    s32 getTabOrder() const
    {
        return TabOrder;
    }
 
 
 
    void setTabGroup(bool isGroup)
    {
        IsTabGroup = isGroup;
    }
 
 
    bool isTabGroup() const
    {
        return IsTabGroup;
    }
 
 
    IGUIElement* getTabGroup()
    {
        IGUIElement *ret=this;
 
        while (ret && !ret->isTabGroup())
            ret = ret->getParent();
 
        return ret;
    }
 
 
 
    virtual bool isEnabled() const
    {
        if ( isSubElement() && IsEnabled && getParent() )
            return getParent()->isEnabled();
 
        return IsEnabled;
    }
 
 
    virtual void setEnabled(bool enabled)
    {
        IsEnabled = enabled;
    }
 
 
    virtual void setText(const wchar_t* text)
    {
        Text = text;
    }
 
 
    virtual const wchar_t* getText() const
    {
        return Text.data();
    }
 
 
    virtual void setToolTipText(const wchar_t* text)
    {
        ToolTipText = text;
    }
 
 
    virtual const core::stringw& getToolTipText() const
    {
        return ToolTipText;
    }
 
 
    virtual s32 getID() const
    {
        return ID;
    }
 
 
    virtual void setID(s32 id)
    {
        ID = id;
    }
 
 
    virtual bool OnEvent(const SEvent& event) override
    {
        return Parent ? Parent->OnEvent(event) : false;
    }
 
 
 
    virtual bool bringToFront(IGUIElement* element)
    {
        core::list<IGUIElement*>::Iterator it = Children.begin();
        for (; it != Children.end(); ++it)
        {
            if (element == (*it))
            {
                Children.erase(it);
                Children.push_back(element);
                return true;
            }
        }
 
        return false;
    }
 
 
 
    virtual bool sendToBack(IGUIElement* child)
    {
        core::list<IGUIElement*>::Iterator it = Children.begin();
        if (child == (*it)) // already there
            return true;
        for (; it != Children.end(); ++it)
        {
            if (child == (*it))
            {
                Children.erase(it);
                Children.push_front(child);
                return true;
            }
        }
 
        return false;
    }
 
    virtual const core::list<IGUIElement*>& getChildren() const
    {
        return Children;
    }
 
 
 
    virtual IGUIElement* getElementFromId(s32 id, bool searchchildren=false) const
    {
        IGUIElement* e = 0;
 
        core::list<IGUIElement*>::ConstIterator it = Children.begin();
        for (; it != Children.end(); ++it)
        {
            if ((*it)->getID() == id)
                return (*it);
 
            if (searchchildren)
                e = (*it)->getElementFromId(id, true);
 
            if (e)
                return e;
        }
 
        return e;
    }
 
 
    bool isMyChild(IGUIElement* child) const
    {
        if (!child)
            return false;
        do
        {
            if (child->Parent)
                child = child->Parent;
 
        } while (child->Parent && child != this);
 
 
        return child == this;
    }
 
 
 
    bool getNextElement(s32 startOrder, bool reverse, bool group,
        IGUIElement*& first, IGUIElement*& closest, bool includeInvisible=false,
        bool includeDisabled=false) const
    {
        // we'll stop searching if we find this number
        s32 wanted = startOrder + ( reverse ? -1 : 1 );
        if (wanted==-2)
            wanted = 1073741824; // maximum s32
 
        core::list<IGUIElement*>::ConstIterator it = Children.begin();
 
        s32 closestOrder, currentOrder;
 
        while(it != Children.end())
        {
            // ignore invisible elements and their children
            if ( ( (*it)->isVisible() || includeInvisible ) &&
                (group == true || (*it)->isTabGroup() == false) )
            {
                // ignore disabled, but children are checked (disabled is currently per element ignoring parent states)
                if ( (*it)->isEnabled() || includeDisabled )
                {
                    // only check tab stops and those with the same group status
                    if ((*it)->isTabStop() && ((*it)->isTabGroup() == group))
                    {
                        currentOrder = (*it)->getTabOrder();
 
                        // is this what we're looking for?
                        if (currentOrder == wanted)
                        {
                            closest = *it;
                            return true;
                        }
 
                        // is it closer than the current closest?
                        if (closest)
                        {
                            closestOrder = closest->getTabOrder();
                            if ( ( reverse && currentOrder > closestOrder && currentOrder < startOrder)
                                ||(!reverse && currentOrder < closestOrder && currentOrder > startOrder))
                            {
                                closest = *it;
                            }
                        }
                        else
                        if ( (reverse && currentOrder < startOrder) || (!reverse && currentOrder > startOrder) )
                        {
                            closest = *it;
                        }
 
                        // is it before the current first?
                        if (first)
                        {
                            closestOrder = first->getTabOrder();
 
                            if ( (reverse && closestOrder < currentOrder) || (!reverse && closestOrder > currentOrder) )
                            {
                                first = *it;
                            }
                        }
                        else
                        {
                            first = *it;
                        }
                    }
                }
                // search within children
                if ((*it)->getNextElement(startOrder, reverse, group, first, closest, includeInvisible, includeDisabled))
                {
                    return true;
                }
            }
            ++it;
        }
        return false;
    }
 
 
 
    EGUI_ELEMENT_TYPE getType() const
    {
        return Type;
    }
 
 
    virtual bool hasType(EGUI_ELEMENT_TYPE type) const
    {
        return type == Type;
    }
 
 
 
    virtual const c8* getTypeName() const
    {
        return GUIElementTypeNames[Type];
    }
 
 
    virtual const c8* getName() const
    {
        return Name.data();
    }
 
 
 
    virtual void setName(const c8* name)
    {
        Name = name;
    }
 
 
 
    virtual void setName(const core::stringc& name)
    {
        Name = name;
    }
 
 
 
    virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options=0) const override
    {
        out->addString("Name", Name.data());
        out->addInt("Id", ID );
        out->addString("Caption", getText());
        out->addString("ToolTip", getToolTipText().data());
        out->addRect("Rect", DesiredRect);
        out->addPosition2d("MinSize", core::position2di(MinSize.Width, MinSize.Height));
        out->addPosition2d("MaxSize", core::position2di(MaxSize.Width, MaxSize.Height));
        out->addEnum("LeftAlign", AlignLeft, GUIAlignmentNames);
        out->addEnum("RightAlign", AlignRight, GUIAlignmentNames);
        out->addEnum("TopAlign", AlignTop, GUIAlignmentNames);
        out->addEnum("BottomAlign", AlignBottom, GUIAlignmentNames);
        out->addBool("Visible", IsVisible);
        out->addBool("Enabled", IsEnabled);
        out->addBool("TabStop", IsTabStop);
        out->addBool("TabGroup", IsTabGroup);
        out->addInt("TabOrder", TabOrder);
        out->addBool("NoClip", NoClip);
    }
 
 
 
    virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options=0) override
    {
        setName(in->getAttributeAsString("Name", Name));
        setID(in->getAttributeAsInt("Id", ID));
        setText(in->getAttributeAsStringW("Caption", Text).data());
        setToolTipText(in->getAttributeAsStringW("ToolTip").data());
        setVisible(in->getAttributeAsBool("Visible", IsVisible));
        setEnabled(in->getAttributeAsBool("Enabled", IsEnabled));
        IsTabStop = in->getAttributeAsBool("TabStop", IsTabStop);
        IsTabGroup = in->getAttributeAsBool("TabGroup", IsTabGroup);
        TabOrder = in->getAttributeAsInt("TabOrder", TabOrder);
 
        core::position2di p = in->getAttributeAsPosition2d("MaxSize", core::position2di(MaxSize.Width, MaxSize.Height));
        setMaxSize(core::dimension2du(p.X,p.Y));
 
        p = in->getAttributeAsPosition2d("MinSize", core::position2di(MinSize.Width, MinSize.Height));
        setMinSize(core::dimension2du(p.X,p.Y));
 
        setAlignment((EGUI_ALIGNMENT) in->getAttributeAsEnumeration("LeftAlign", GUIAlignmentNames, AlignLeft),
            (EGUI_ALIGNMENT)in->getAttributeAsEnumeration("RightAlign", GUIAlignmentNames, AlignRight),
            (EGUI_ALIGNMENT)in->getAttributeAsEnumeration("TopAlign", GUIAlignmentNames, AlignTop),
            (EGUI_ALIGNMENT)in->getAttributeAsEnumeration("BottomAlign", GUIAlignmentNames, AlignBottom));
 
        setRelativePosition(in->getAttributeAsRect("Rect", DesiredRect));
 
        setNotClipped(in->getAttributeAsBool("NoClip", NoClip));
    }
 
protected:
    // not virtual because needed in constructor
    void addChildToEnd(IGUIElement* child)
    {
        if (child)
        {
            child->grab(); // prevent destruction when removed
            child->remove(); // remove from old parent
            child->LastParentRect = getAbsolutePosition();
            child->Parent = this;
            Children.push_back(child);
        }
    }
 
    // not virtual because needed in constructor
    void recalculateAbsolutePosition(bool recursive)
    {
        core::rect<s32> parentAbsolute(0,0,0,0);
        core::rect<s32> parentAbsoluteClip;
        f32 fw=0.f, fh=0.f;
 
        if (Parent)
        {
            parentAbsolute = Parent->AbsoluteRect;
 
            if (NoClip)
            {
                IGUIElement* p=this;
                while (p->Parent)
                    p = p->Parent;
                parentAbsoluteClip = p->AbsoluteClippingRect;
            }
            else
                parentAbsoluteClip = Parent->AbsoluteClippingRect;
        }
 
        const s32 diffx = parentAbsolute.getWidth() - LastParentRect.getWidth();
        const s32 diffy = parentAbsolute.getHeight() - LastParentRect.getHeight();
 
        if (AlignLeft == EGUIA_SCALE || AlignRight == EGUIA_SCALE)
            fw = (f32)parentAbsolute.getWidth();
 
        if (AlignTop == EGUIA_SCALE || AlignBottom == EGUIA_SCALE)
            fh = (f32)parentAbsolute.getHeight();
 
        switch (AlignLeft)
        {
            case EGUIA_UPPERLEFT:
                break;
            case EGUIA_LOWERRIGHT:
                DesiredRect.UpperLeftCorner.X += diffx;
                break;
            case EGUIA_CENTER:
                DesiredRect.UpperLeftCorner.X += diffx/2;
                break;
            case EGUIA_SCALE:
                DesiredRect.UpperLeftCorner.X = core::round32(ScaleRect.UpperLeftCorner.X * fw);
                break;
        }
 
        switch (AlignRight)
        {
            case EGUIA_UPPERLEFT:
                break;
            case EGUIA_LOWERRIGHT:
                DesiredRect.LowerRightCorner.X += diffx;
                break;
            case EGUIA_CENTER:
                DesiredRect.LowerRightCorner.X += diffx/2;
                break;
            case EGUIA_SCALE:
                DesiredRect.LowerRightCorner.X = core::round32(ScaleRect.LowerRightCorner.X * fw);
                break;
        }
 
        switch (AlignTop)
        {
            case EGUIA_UPPERLEFT:
                break;
            case EGUIA_LOWERRIGHT:
                DesiredRect.UpperLeftCorner.Y += diffy;
                break;
            case EGUIA_CENTER:
                DesiredRect.UpperLeftCorner.Y += diffy/2;
                break;
            case EGUIA_SCALE:
                DesiredRect.UpperLeftCorner.Y = core::round32(ScaleRect.UpperLeftCorner.Y * fh);
                break;
        }
 
        switch (AlignBottom)
        {
            case EGUIA_UPPERLEFT:
                break;
            case EGUIA_LOWERRIGHT:
                DesiredRect.LowerRightCorner.Y += diffy;
                break;
            case EGUIA_CENTER:
                DesiredRect.LowerRightCorner.Y += diffy/2;
                break;
            case EGUIA_SCALE:
                DesiredRect.LowerRightCorner.Y = core::round32(ScaleRect.LowerRightCorner.Y * fh);
                break;
        }
 
        RelativeRect = DesiredRect;
 
        const s32 w = RelativeRect.getWidth();
        const s32 h = RelativeRect.getHeight();
 
        // make sure the desired rectangle is allowed
        if (w < (s32)MinSize.Width)
            RelativeRect.LowerRightCorner.X = RelativeRect.UpperLeftCorner.X + MinSize.Width;
        if (h < (s32)MinSize.Height)
            RelativeRect.LowerRightCorner.Y = RelativeRect.UpperLeftCorner.Y + MinSize.Height;
        if (MaxSize.Width && w > (s32)MaxSize.Width)
            RelativeRect.LowerRightCorner.X = RelativeRect.UpperLeftCorner.X + MaxSize.Width;
        if (MaxSize.Height && h > (s32)MaxSize.Height)
            RelativeRect.LowerRightCorner.Y = RelativeRect.UpperLeftCorner.Y + MaxSize.Height;
 
        RelativeRect.repair();
 
        AbsoluteRect = RelativeRect + parentAbsolute.UpperLeftCorner;
 
        if (!Parent)
            parentAbsoluteClip = AbsoluteRect;
 
        AbsoluteClippingRect = AbsoluteRect;
        AbsoluteClippingRect.clipAgainst(parentAbsoluteClip);
 
        LastParentRect = parentAbsolute;
 
        if ( recursive )
        {
            // update all children
            core::list<IGUIElement*>::Iterator it = Children.begin();
            for (; it != Children.end(); ++it)
            {
                (*it)->recalculateAbsolutePosition(recursive);
            }
        }
    }
 
protected:
 
    core::list<IGUIElement*> Children;
 
    IGUIElement* Parent;
 
    core::rect<s32> RelativeRect;
 
    core::rect<s32> AbsoluteRect;
 
    core::rect<s32> AbsoluteClippingRect;
 
    core::rect<s32> DesiredRect;
 
    core::rect<s32> LastParentRect;
 
    core::rect<f32> ScaleRect;
 
    core::dimension2du MaxSize, MinSize;
 
    bool IsVisible;
 
    bool IsEnabled;
 
    bool IsSubElement;
 
    bool NoClip;
 
    core::stringw Text;
 
    core::stringw ToolTipText;
 
    core::stringc Name;
 
    s32 ID;
 
    bool IsTabStop;
 
    s32 TabOrder;
 
    bool IsTabGroup;
 
    EGUI_ALIGNMENT AlignLeft, AlignRight, AlignTop, AlignBottom;
 
    IGUIEnvironment* Environment;
 
    EGUI_ELEMENT_TYPE Type;
};
 
 
} // end namespace gui
} // end namespace nirt
 
#endif