Irrlicht 3D Engine: IGUIElement.h Source File

| Irrlicht 3D Engine |

IGUIElement.h
Go to the documentation of this file.

    00001 // Copyright (C) 2002-2012 Nikolaus Gebhardt
    00002 // This file is part of the "Irrlicht Engine".
    00003 // For conditions of distribution and use, see copyright notice in irrlicht.h
    00004
    00005 #ifndef __I_GUI_ELEMENT_H_INCLUDED__
    00006 #define __I_GUI_ELEMENT_H_INCLUDED__
    00007
    00008 #include "IAttributeExchangingObject.h"
    00009 #include "irrList.h"
    00010 #include "rect.h"
    00011 #include "irrString.h"
    00012 #include "IEventReceiver.h"
    00013 #include "EGUIElementTypes.h"
    00014 #include "EGUIAlignment.h"
    00015 #include "IAttributes.h"
    00016
    00017 namespace irr
    00018 {
    00019 namespace gui
    00020 {
    00021
    00022 class IGUIEnvironment;
    00023
    00025 class IGUIElement : public virtual io::IAttributeExchangingObject, public IEventReceiver
    00026 {
    00027 public:
    00028
    00030     IGUIElement(EGUI_ELEMENT_TYPE type, IGUIEnvironment* environment, IGUIElement* parent,
    00031         s32 id, const core::rect<s32>& rectangle)
    00032         : Parent(0), RelativeRect(rectangle), AbsoluteRect(rectangle),
    00033         AbsoluteClippingRect(rectangle), DesiredRect(rectangle),
    00034         MaxSize(0,0), MinSize(1,1), IsVisible(true), IsEnabled(true),
    00035         IsSubElement(false), NoClip(false), ID(id), IsTabStop(false), TabOrder(-1), IsTabGroup(false),
    00036         AlignLeft(EGUIA_UPPERLEFT), AlignRight(EGUIA_UPPERLEFT), AlignTop(EGUIA_UPPERLEFT), AlignBottom(EGUIA_UPPERLEFT),
    00037         Environment(environment), Type(type)
    00038     {
    00039         #ifdef _DEBUG
    00040         setDebugName("IGUIElement");
    00041         #endif
    00042
    00043         // if we were given a parent to attach to
    00044         if (parent)
    00045         {
    00046             parent->addChildToEnd(this);
    00047             recalculateAbsolutePosition(true);
    00048         }
    00049     }
    00050
    00051
    00053     virtual ~IGUIElement()
    00054     {
    00055         // delete all children
    00056         core::list<IGUIElement*>::Iterator it = Children.begin();
    00057         for (; it != Children.end(); ++it)
    00058         {
    00059             (*it)->Parent = 0;
    00060             (*it)->drop();
    00061         }
    00062     }
    00063
    00064
    00066     IGUIElement* getParent() const
    00067     {
    00068         return Parent;
    00069     }
    00070
    00071
    00073     core::rect<s32> getRelativePosition() const
    00074     {
    00075         return RelativeRect;
    00076     }
    00077
    00078
    00080
    00081     void setRelativePosition(const core::rect<s32>& r)
    00082     {
    00083         if (Parent)
    00084         {
    00085             const core::rect<s32>& r2 = Parent->getAbsolutePosition();
    00086
    00087             core::dimension2df d((f32)(r2.getSize().Width), (f32)(r2.getSize().Height));
    00088
    00089             if (AlignLeft   == EGUIA_SCALE)
    00090                 ScaleRect.UpperLeftCorner.X = (f32)r.UpperLeftCorner.X / d.Width;
    00091             if (AlignRight  == EGUIA_SCALE)
    00092                 ScaleRect.LowerRightCorner.X = (f32)r.LowerRightCorner.X / d.Width;
    00093             if (AlignTop    == EGUIA_SCALE)
    00094                 ScaleRect.UpperLeftCorner.Y = (f32)r.UpperLeftCorner.Y / d.Height;
    00095             if (AlignBottom == EGUIA_SCALE)
    00096                 ScaleRect.LowerRightCorner.Y = (f32)r.LowerRightCorner.Y / d.Height;
    00097         }
    00098
    00099         DesiredRect = r;
    00100         updateAbsolutePosition();
    00101     }
    00102
    00104
    00105     void setRelativePosition(const core::position2di & position)
    00106     {
    00107         const core::dimension2di mySize = RelativeRect.getSize();
    00108         const core::rect<s32> rectangle(position.X, position.Y,
    00109                         position.X + mySize.Width, position.Y + mySize.Height);
    00110         setRelativePosition(rectangle);
    00111     }
    00112
    00113
    00115
    00119     void setRelativePositionProportional(const core::rect<f32>& r)
    00120     {
    00121         if (!Parent)
    00122             return;
    00123
    00124         const core::dimension2di& d = Parent->getAbsolutePosition().getSize();
    00125
    00126         DesiredRect = core::rect<s32>(
    00127                     core::floor32((f32)d.Width * r.UpperLeftCorner.X),
    00128                     core::floor32((f32)d.Height * r.UpperLeftCorner.Y),
    00129                     core::floor32((f32)d.Width * r.LowerRightCorner.X),
    00130                     core::floor32((f32)d.Height * r.LowerRightCorner.Y));
    00131
    00132         ScaleRect = r;
    00133
    00134         updateAbsolutePosition();
    00135     }
    00136
    00137
    00139     core::rect<s32> getAbsolutePosition() const
    00140     {
    00141         return AbsoluteRect;
    00142     }
    00143
    00144
    00146     core::rect<s32> getAbsoluteClippingRect() const
    00147     {
    00148         return AbsoluteClippingRect;
    00149     }
    00150
    00151
    00153
    00154     void setNotClipped(bool noClip)
    00155     {
    00156         NoClip = noClip;
    00157         updateAbsolutePosition();
    00158     }
    00159
    00160
    00162
    00163     bool isNotClipped() const
    00164     {
    00165         return NoClip;
    00166     }
    00167
    00168
    00170
    00171     void setMaxSize(core::dimension2du size)
    00172     {
    00173         MaxSize = size;
    00174         updateAbsolutePosition();
    00175     }
    00176
    00177
    00179     void setMinSize(core::dimension2du size)
    00180     {
    00181         MinSize = size;
    00182         if (MinSize.Width < 1)
    00183             MinSize.Width = 1;
    00184         if (MinSize.Height < 1)
    00185             MinSize.Height = 1;
    00186         updateAbsolutePosition();
    00187     }
    00188
    00189
    00191     void setAlignment(EGUI_ALIGNMENT left, EGUI_ALIGNMENT right, EGUI_ALIGNMENT top, EGUI_ALIGNMENT bottom)
    00192     {
    00193         AlignLeft = left;
    00194         AlignRight = right;
    00195         AlignTop = top;
    00196         AlignBottom = bottom;
    00197
    00198         if (Parent)
    00199         {
    00200             core::rect<s32> r(Parent->getAbsolutePosition());
    00201
    00202             core::dimension2df d((f32)r.getSize().Width, (f32)r.getSize().Height);
    00203
    00204             if (AlignLeft   == EGUIA_SCALE)
    00205                 ScaleRect.UpperLeftCorner.X = (f32)DesiredRect.UpperLeftCorner.X / d.Width;
    00206             if (AlignRight  == EGUIA_SCALE)
    00207                 ScaleRect.LowerRightCorner.X = (f32)DesiredRect.LowerRightCorner.X / d.Width;
    00208             if (AlignTop    == EGUIA_SCALE)
    00209                 ScaleRect.UpperLeftCorner.Y = (f32)DesiredRect.UpperLeftCorner.Y / d.Height;
    00210             if (AlignBottom == EGUIA_SCALE)
    00211                 ScaleRect.LowerRightCorner.Y = (f32)DesiredRect.LowerRightCorner.Y / d.Height;
    00212         }
    00213     }
    00214
    00215
    00217     virtual void updateAbsolutePosition()
    00218     {
    00219         recalculateAbsolutePosition(false);
    00220
    00221         // update all children
    00222         core::list<IGUIElement*>::Iterator it = Children.begin();
    00223         for (; it != Children.end(); ++it)
    00224         {
    00225             (*it)->updateAbsolutePosition();
    00226         }
    00227     }
    00228
    00229
    00231
    00242     IGUIElement* getElementFromPoint(const core::position2d<s32>& point)
    00243     {
    00244         IGUIElement* target = 0;
    00245
    00246         // we have to search from back to front, because later children
    00247         // might be drawn over the top of earlier ones.
    00248
    00249         core::list<IGUIElement*>::Iterator it = Children.getLast();
    00250
    00251         if (isVisible())
    00252         {
    00253             while(it != Children.end())
    00254             {
    00255                 target = (*it)->getElementFromPoint(point);
    00256                 if (target)
    00257                     return target;
    00258
    00259                 --it;
    00260             }
    00261         }
    00262
    00263         if (isVisible() && isPointInside(point))
    00264             target = this;
    00265
    00266         return target;
    00267     }
    00268
    00269
    00271
    00272     virtual bool isPointInside(const core::position2d<s32>& point) const
    00273     {
    00274         return AbsoluteClippingRect.isPointInside(point);
    00275     }
    00276
    00277
    00279     virtual void addChild(IGUIElement* child)
    00280     {
    00281         addChildToEnd(child);
    00282         if (child)
    00283         {
    00284             child->updateAbsolutePosition();
    00285         }
    00286     }
    00287
    00289     virtual void removeChild(IGUIElement* child)
    00290     {
    00291         core::list<IGUIElement*>::Iterator it = Children.begin();
    00292         for (; it != Children.end(); ++it)
    00293             if ((*it) == child)
    00294             {
    00295                 (*it)->Parent = 0;
    00296                 (*it)->drop();
    00297                 Children.erase(it);
    00298                 return;
    00299             }
    00300     }
    00301
    00302
    00304     virtual void remove()
    00305     {
    00306         if (Parent)
    00307             Parent->removeChild(this);
    00308     }
    00309
    00310
    00312     virtual void draw()
    00313     {
    00314         if ( isVisible() )
    00315         {
    00316             core::list<IGUIElement*>::Iterator it = Children.begin();
    00317             for (; it != Children.end(); ++it)
    00318                 (*it)->draw();
    00319         }
    00320     }
    00321
    00322
    00324     virtual void OnPostRender(u32 timeMs)
    00325     {
    00326         if ( isVisible() )
    00327         {
    00328             core::list<IGUIElement*>::Iterator it = Children.begin();
    00329             for (; it != Children.end(); ++it)
    00330                 (*it)->OnPostRender( timeMs );
    00331         }
    00332     }
    00333
    00334
    00336     virtual void move(core::position2d<s32> absoluteMovement)
    00337     {
    00338         setRelativePosition(DesiredRect + absoluteMovement);
    00339     }
    00340
    00341
    00343     virtual bool isVisible() const
    00344     {
    00345         _IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
    00346         return IsVisible;
    00347     }
    00348
    00349
    00351     virtual void setVisible(bool visible)
    00352     {
    00353         IsVisible = visible;
    00354     }
    00355
    00356
    00358     virtual bool isSubElement() const
    00359     {
    00360         _IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
    00361         return IsSubElement;
    00362     }
    00363
    00364
    00366
    00368     virtual void setSubElement(bool subElement)
    00369     {
    00370         IsSubElement = subElement;
    00371     }
    00372
    00373
    00375
    00377     void setTabStop(bool enable)
    00378     {
    00379         IsTabStop = enable;
    00380     }
    00381
    00382
    00384     bool isTabStop() const
    00385     {
    00386         _IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
    00387         return IsTabStop;
    00388     }
    00389
    00390
    00392
    00394     void setTabOrder(s32 index)
    00395     {
    00396         // negative = autonumber
    00397         if (index < 0)
    00398         {
    00399             TabOrder = 0;
    00400             IGUIElement *el = getTabGroup();
    00401             while (IsTabGroup && el && el->Parent)
    00402                 el = el->Parent;
    00403
    00404             IGUIElement *first=0, *closest=0;
    00405             if (el)
    00406             {
    00407                 // find the highest element number
    00408                 el->getNextElement(-1, true, IsTabGroup, first, closest, true);
    00409                 if (first)
    00410                 {
    00411                     TabOrder = first->getTabOrder() + 1;
    00412                 }
    00413             }
    00414
    00415         }
    00416         else
    00417             TabOrder = index;
    00418     }
    00419
    00420
    00422     s32 getTabOrder() const
    00423     {
    00424         return TabOrder;
    00425     }
    00426
    00427
    00429
    00431     void setTabGroup(bool isGroup)
    00432     {
    00433         IsTabGroup = isGroup;
    00434     }
    00435
    00436
    00438     bool isTabGroup() const
    00439     {
    00440         _IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
    00441         return IsTabGroup;
    00442     }
    00443
    00444
    00446     IGUIElement* getTabGroup()
    00447     {
    00448         IGUIElement *ret=this;
    00449
    00450         while (ret && !ret->isTabGroup())
    00451             ret = ret->getParent();
    00452
    00453         return ret;
    00454     }
    00455
    00456
    00458
    00462     virtual bool isEnabled() const
    00463     {
    00464         if ( isSubElement() && IsEnabled && getParent() )
    00465             return getParent()->isEnabled();
    00466
    00467         _IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
    00468         return IsEnabled;
    00469     }
    00470
    00471
    00473     virtual void setEnabled(bool enabled)
    00474     {
    00475         IsEnabled = enabled;
    00476     }
    00477
    00478
    00480     virtual void setText(const wchar_t* text)
    00481     {
    00482         Text = text;
    00483     }
    00484
    00485
    00487     virtual const wchar_t* getText() const
    00488     {
    00489         return Text.c_str();
    00490     }
    00491
    00492
    00494     virtual void setToolTipText(const wchar_t* text)
    00495     {
    00496         ToolTipText = text;
    00497     }
    00498
    00499
    00501     virtual const core::stringw& getToolTipText() const
    00502     {
    00503         return ToolTipText;
    00504     }
    00505
    00506
    00508     virtual s32 getID() const
    00509     {
    00510         return ID;
    00511     }
    00512
    00513
    00515     virtual void setID(s32 id)
    00516     {
    00517         ID = id;
    00518     }
    00519
    00520
    00522     virtual bool OnEvent(const SEvent& event)
    00523     {
    00524         return Parent ? Parent->OnEvent(event) : false;
    00525     }
    00526
    00527
    00529
    00530     virtual bool bringToFront(IGUIElement* element)
    00531     {
    00532         core::list<IGUIElement*>::Iterator it = Children.begin();
    00533         for (; it != Children.end(); ++it)
    00534         {
    00535             if (element == (*it))
    00536             {
    00537                 Children.erase(it);
    00538                 Children.push_back(element);
    00539                 return true;
    00540             }
    00541         }
    00542
    00543         _IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
    00544         return false;
    00545     }
    00546
    00547
    00549
    00550     virtual bool sendToBack(IGUIElement* child)
    00551     {
    00552         core::list<IGUIElement*>::Iterator it = Children.begin();
    00553         if (child == (*it)) // already there
    00554             return true;
    00555         for (; it != Children.end(); ++it)
    00556         {
    00557             if (child == (*it))
    00558             {
    00559                 Children.erase(it);
    00560                 Children.push_front(child);
    00561                 return true;
    00562             }
    00563         }
    00564
    00565         _IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
    00566         return false;
    00567     }
    00568
    00570     virtual const core::list<IGUIElement*>& getChildren() const
    00571     {
    00572         return Children;
    00573     }
    00574
    00575
    00577
    00583     virtual IGUIElement* getElementFromId(s32 id, bool searchchildren=false) const
    00584     {
    00585         IGUIElement* e = 0;
    00586
    00587         core::list<IGUIElement*>::ConstIterator it = Children.begin();
    00588         for (; it != Children.end(); ++it)
    00589         {
    00590             if ((*it)->getID() == id)
    00591                 return (*it);
    00592
    00593             if (searchchildren)
    00594                 e = (*it)->getElementFromId(id, true);
    00595
    00596             if (e)
    00597                 return e;
    00598         }
    00599
    00600         return e;
    00601     }
    00602
    00603
    00606     bool isMyChild(IGUIElement* child) const
    00607     {
    00608         if (!child)
    00609             return false;
    00610         do
    00611         {
    00612             if (child->Parent)
    00613                 child = child->Parent;
    00614
    00615         } while (child->Parent && child != this);
    00616
    00617         _IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
    00618         return child == this;
    00619     }
    00620
    00621
    00623
    00630     bool getNextElement(s32 startOrder, bool reverse, bool group,
    00631         IGUIElement*& first, IGUIElement*& closest, bool includeInvisible=false) const
    00632     {
    00633         // we'll stop searching if we find this number
    00634         s32 wanted = startOrder + ( reverse ? -1 : 1 );
    00635         if (wanted==-2)
    00636             wanted = 1073741824; // maximum s32
    00637
    00638         core::list<IGUIElement*>::ConstIterator it = Children.begin();
    00639
    00640         s32 closestOrder, currentOrder;
    00641
    00642         while(it != Children.end())
    00643         {
    00644             // ignore invisible elements and their children
    00645             if ( ( (*it)->isVisible() || includeInvisible ) &&
    00646                 (group == true || (*it)->isTabGroup() == false) )
    00647             {
    00648                 // only check tab stops and those with the same group status
    00649                 if ((*it)->isTabStop() && ((*it)->isTabGroup() == group))
    00650                 {
    00651                     currentOrder = (*it)->getTabOrder();
    00652
    00653                     // is this what we're looking for?
    00654                     if (currentOrder == wanted)
    00655                     {
    00656                         closest = *it;
    00657                         return true;
    00658                     }
    00659
    00660                     // is it closer than the current closest?
    00661                     if (closest)
    00662                     {
    00663                         closestOrder = closest->getTabOrder();
    00664                         if ( ( reverse && currentOrder > closestOrder && currentOrder < startOrder)
    00665                             ||(!reverse && currentOrder < closestOrder && currentOrder > startOrder))
    00666                         {
    00667                             closest = *it;
    00668                         }
    00669                     }
    00670                     else
    00671                     if ( (reverse && currentOrder < startOrder) || (!reverse && currentOrder > startOrder) )
    00672                     {
    00673                         closest = *it;
    00674                     }
    00675
    00676                     // is it before the current first?
    00677                     if (first)
    00678                     {
    00679                         closestOrder = first->getTabOrder();
    00680
    00681                         if ( (reverse && closestOrder < currentOrder) || (!reverse && closestOrder > currentOrder) )
    00682                         {
    00683                             first = *it;
    00684                         }
    00685                     }
    00686                     else
    00687                     {
    00688                         first = *it;
    00689                     }
    00690                 }
    00691                 // search within children
    00692                 if ((*it)->getNextElement(startOrder, reverse, group, first, closest))
    00693                 {
    00694                     _IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
    00695                     return true;
    00696                 }
    00697             }
    00698             ++it;
    00699         }
    00700         _IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
    00701         return false;
    00702     }
    00703
    00704
    00706
    00710     EGUI_ELEMENT_TYPE getType() const
    00711     {
    00712         return Type;
    00713     }
    00714
    00716
    00724     virtual bool hasType(EGUI_ELEMENT_TYPE type) const
    00725     {
    00726         return type == Type;
    00727     }
    00728
    00729
    00731
    00733     virtual const c8* getTypeName() const
    00734     {
    00735         return GUIElementTypeNames[Type];
    00736     }
    00737
    00739
    00740     virtual const c8* getName() const
    00741     {
    00742         return Name.c_str();
    00743     }
    00744
    00745
    00747
    00748     virtual void setName(const c8* name)
    00749     {
    00750         Name = name;
    00751     }
    00752
    00753
    00755
    00756     virtual void setName(const core::stringc& name)
    00757     {
    00758         Name = name;
    00759     }
    00760
    00761
    00763
    00765     virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options=0) const
    00766     {
    00767         out->addString("Name", Name.c_str());
    00768         out->addInt("Id", ID );
    00769         out->addString("Caption", getText());
    00770         out->addRect("Rect", DesiredRect);
    00771         out->addPosition2d("MinSize", core::position2di(MinSize.Width, MinSize.Height));
    00772         out->addPosition2d("MaxSize", core::position2di(MaxSize.Width, MaxSize.Height));
    00773         out->addEnum("LeftAlign", AlignLeft, GUIAlignmentNames);
    00774         out->addEnum("RightAlign", AlignRight, GUIAlignmentNames);
    00775         out->addEnum("TopAlign", AlignTop, GUIAlignmentNames);
    00776         out->addEnum("BottomAlign", AlignBottom, GUIAlignmentNames);
    00777         out->addBool("Visible", IsVisible);
    00778         out->addBool("Enabled", IsEnabled);
    00779         out->addBool("TabStop", IsTabStop);
    00780         out->addBool("TabGroup", IsTabGroup);
    00781         out->addInt("TabOrder", TabOrder);
    00782         out->addBool("NoClip", NoClip);
    00783     }
    00784
    00785
    00787
    00789     virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options=0)
    00790     {
    00791         setName(in->getAttributeAsString("Name"));
    00792         setID(in->getAttributeAsInt("Id"));
    00793         setText(in->getAttributeAsStringW("Caption").c_str());
    00794         setVisible(in->getAttributeAsBool("Visible"));
    00795         setEnabled(in->getAttributeAsBool("Enabled"));
    00796         IsTabStop = in->getAttributeAsBool("TabStop");
    00797         IsTabGroup = in->getAttributeAsBool("TabGroup");
    00798         TabOrder = in->getAttributeAsInt("TabOrder");
    00799
    00800         core::position2di p = in->getAttributeAsPosition2d("MaxSize");
    00801         setMaxSize(core::dimension2du(p.X,p.Y));
    00802
    00803         p = in->getAttributeAsPosition2d("MinSize");
    00804         setMinSize(core::dimension2du(p.X,p.Y));
    00805
    00806         setAlignment((EGUI_ALIGNMENT) in->getAttributeAsEnumeration("LeftAlign", GUIAlignmentNames),
    00807             (EGUI_ALIGNMENT)in->getAttributeAsEnumeration("RightAlign", GUIAlignmentNames),
    00808             (EGUI_ALIGNMENT)in->getAttributeAsEnumeration("TopAlign", GUIAlignmentNames),
    00809             (EGUI_ALIGNMENT)in->getAttributeAsEnumeration("BottomAlign", GUIAlignmentNames));
    00810
    00811         setRelativePosition(in->getAttributeAsRect("Rect"));
    00812
    00813         setNotClipped(in->getAttributeAsBool("NoClip"));
    00814     }
    00815
    00816 protected:
    00817     // not virtual because needed in constructor
    00818     void addChildToEnd(IGUIElement* child)
    00819     {
    00820         if (child)
    00821         {
    00822             child->grab(); // prevent destruction when removed
    00823             child->remove(); // remove from old parent
    00824             child->LastParentRect = getAbsolutePosition();
    00825             child->Parent = this;
    00826             Children.push_back(child);
    00827         }
    00828     }
    00829
    00830     // not virtual because needed in constructor
    00831     void recalculateAbsolutePosition(bool recursive)
    00832     {
    00833         core::rect<s32> parentAbsolute(0,0,0,0);
    00834         core::rect<s32> parentAbsoluteClip;
    00835         f32 fw=0.f, fh=0.f;
    00836
    00837         if (Parent)
    00838         {
    00839             parentAbsolute = Parent->AbsoluteRect;
    00840
    00841             if (NoClip)
    00842             {
    00843                 IGUIElement* p=this;
    00844                 while (p && p->Parent)
    00845                     p = p->Parent;
    00846                 parentAbsoluteClip = p->AbsoluteClippingRect;
    00847             }
    00848             else
    00849                 parentAbsoluteClip = Parent->AbsoluteClippingRect;
    00850         }
    00851
    00852         const s32 diffx = parentAbsolute.getWidth() - LastParentRect.getWidth();
    00853         const s32 diffy = parentAbsolute.getHeight() - LastParentRect.getHeight();
    00854
    00855         if (AlignLeft == EGUIA_SCALE || AlignRight == EGUIA_SCALE)
    00856             fw = (f32)parentAbsolute.getWidth();
    00857
    00858         if (AlignTop == EGUIA_SCALE || AlignBottom == EGUIA_SCALE)
    00859             fh = (f32)parentAbsolute.getHeight();
    00860
    00861         switch (AlignLeft)
    00862         {
    00863             case EGUIA_UPPERLEFT:
    00864                 break;
    00865             case EGUIA_LOWERRIGHT:
    00866                 DesiredRect.UpperLeftCorner.X += diffx;
    00867                 break;
    00868             case EGUIA_CENTER:
    00869                 DesiredRect.UpperLeftCorner.X += diffx/2;
    00870                 break;
    00871             case EGUIA_SCALE:
    00872                 DesiredRect.UpperLeftCorner.X = core::round32(ScaleRect.UpperLeftCorner.X * fw);
    00873                 break;
    00874         }
    00875
    00876         switch (AlignRight)
    00877         {
    00878             case EGUIA_UPPERLEFT:
    00879                 break;
    00880             case EGUIA_LOWERRIGHT:
    00881                 DesiredRect.LowerRightCorner.X += diffx;
    00882                 break;
    00883             case EGUIA_CENTER:
    00884                 DesiredRect.LowerRightCorner.X += diffx/2;
    00885                 break;
    00886             case EGUIA_SCALE:
    00887                 DesiredRect.LowerRightCorner.X = core::round32(ScaleRect.LowerRightCorner.X * fw);
    00888                 break;
    00889         }
    00890
    00891         switch (AlignTop)
    00892         {
    00893             case EGUIA_UPPERLEFT:
    00894                 break;
    00895             case EGUIA_LOWERRIGHT:
    00896                 DesiredRect.UpperLeftCorner.Y += diffy;
    00897                 break;
    00898             case EGUIA_CENTER:
    00899                 DesiredRect.UpperLeftCorner.Y += diffy/2;
    00900                 break;
    00901             case EGUIA_SCALE:
    00902                 DesiredRect.UpperLeftCorner.Y = core::round32(ScaleRect.UpperLeftCorner.Y * fh);
    00903                 break;
    00904         }
    00905
    00906         switch (AlignBottom)
    00907         {
    00908             case EGUIA_UPPERLEFT:
    00909                 break;
    00910             case EGUIA_LOWERRIGHT:
    00911                 DesiredRect.LowerRightCorner.Y += diffy;
    00912                 break;
    00913             case EGUIA_CENTER:
    00914                 DesiredRect.LowerRightCorner.Y += diffy/2;
    00915                 break;
    00916             case EGUIA_SCALE:
    00917                 DesiredRect.LowerRightCorner.Y = core::round32(ScaleRect.LowerRightCorner.Y * fh);
    00918                 break;
    00919         }
    00920
    00921         RelativeRect = DesiredRect;
    00922
    00923         const s32 w = RelativeRect.getWidth();
    00924         const s32 h = RelativeRect.getHeight();
    00925
    00926         // make sure the desired rectangle is allowed
    00927         if (w < (s32)MinSize.Width)
    00928             RelativeRect.LowerRightCorner.X = RelativeRect.UpperLeftCorner.X + MinSize.Width;
    00929         if (h < (s32)MinSize.Height)
    00930             RelativeRect.LowerRightCorner.Y = RelativeRect.UpperLeftCorner.Y + MinSize.Height;
    00931         if (MaxSize.Width && w > (s32)MaxSize.Width)
    00932             RelativeRect.LowerRightCorner.X = RelativeRect.UpperLeftCorner.X + MaxSize.Width;
    00933         if (MaxSize.Height && h > (s32)MaxSize.Height)
    00934             RelativeRect.LowerRightCorner.Y = RelativeRect.UpperLeftCorner.Y + MaxSize.Height;
    00935
    00936         RelativeRect.repair();
    00937
    00938         AbsoluteRect = RelativeRect + parentAbsolute.UpperLeftCorner;
    00939
    00940         if (!Parent)
    00941             parentAbsoluteClip = AbsoluteRect;
    00942
    00943         AbsoluteClippingRect = AbsoluteRect;
    00944         AbsoluteClippingRect.clipAgainst(parentAbsoluteClip);
    00945
    00946         LastParentRect = parentAbsolute;
    00947
    00948         if ( recursive )
    00949         {
    00950             // update all children
    00951             core::list<IGUIElement*>::Iterator it = Children.begin();
    00952             for (; it != Children.end(); ++it)
    00953             {
    00954                 (*it)->recalculateAbsolutePosition(recursive);
    00955             }
    00956         }
    00957     }
    00958
    00959 protected:
    00960
    00962     core::list<IGUIElement*> Children;
    00963
    00965     IGUIElement* Parent;
    00966
    00968     core::rect<s32> RelativeRect;
    00969
    00971     core::rect<s32> AbsoluteRect;
    00972
    00974     core::rect<s32> AbsoluteClippingRect;
    00975
    00978     core::rect<s32> DesiredRect;
    00979
    00981     core::rect<s32> LastParentRect;
    00982
    00984     core::rect<f32> ScaleRect;
    00985
    00987     core::dimension2du MaxSize, MinSize;
    00988
    00990     bool IsVisible;
    00991
    00993     bool IsEnabled;
    00994
    00996     bool IsSubElement;
    00997
    00999     bool NoClip;
    01000
    01002     core::stringw Text;
    01003
    01005     core::stringw ToolTipText;
    01006
    01008     core::stringc Name;
    01009
    01011     s32 ID;
    01012
    01014     bool IsTabStop;
    01015
    01017     s32 TabOrder;
    01018
    01020     bool IsTabGroup;
    01021
    01023     EGUI_ALIGNMENT AlignLeft, AlignRight, AlignTop, AlignBottom;
    01024
    01026     IGUIEnvironment* Environment;
    01027
    01029     EGUI_ELEMENT_TYPE Type;
    01030 };
    01031
    01032
    01033 } // end namespace gui
    01034 } // end namespace irr
    01035
    01036 #endif
    01037