00001
00002
00003
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
00044 if (parent)
00045 {
00046 parent->addChildToEnd(this);
00047 recalculateAbsolutePosition(true);
00048 }
00049 }
00050
00051
00053 virtual ~IGUIElement()
00054 {
00055
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
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
00247
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
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
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 virtual bool isEnabled() const
00459 {
00460 _IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
00461 return IsEnabled;
00462 }
00463
00464
00466 virtual void setEnabled(bool enabled)
00467 {
00468 IsEnabled = enabled;
00469 }
00470
00471
00473 virtual void setText(const wchar_t* text)
00474 {
00475 Text = text;
00476 }
00477
00478
00480 virtual const wchar_t* getText() const
00481 {
00482 return Text.c_str();
00483 }
00484
00485
00487 virtual void setToolTipText(const wchar_t* text)
00488 {
00489 ToolTipText = text;
00490 }
00491
00492
00494 virtual const core::stringw& getToolTipText() const
00495 {
00496 return ToolTipText;
00497 }
00498
00499
00501 virtual s32 getID() const
00502 {
00503 return ID;
00504 }
00505
00506
00508 virtual void setID(s32 id)
00509 {
00510 ID = id;
00511 }
00512
00513
00515 virtual bool OnEvent(const SEvent& event)
00516 {
00517 return Parent ? Parent->OnEvent(event) : false;
00518 }
00519
00520
00522
00523 virtual bool bringToFront(IGUIElement* element)
00524 {
00525 core::list<IGUIElement*>::Iterator it = Children.begin();
00526 for (; it != Children.end(); ++it)
00527 {
00528 if (element == (*it))
00529 {
00530 Children.erase(it);
00531 Children.push_back(element);
00532 return true;
00533 }
00534 }
00535
00536 _IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
00537 return false;
00538 }
00539
00540
00542 virtual const core::list<IGUIElement*>& getChildren() const
00543 {
00544 return Children;
00545 }
00546
00547
00549
00555 virtual IGUIElement* getElementFromId(s32 id, bool searchchildren=false) const
00556 {
00557 IGUIElement* e = 0;
00558
00559 core::list<IGUIElement*>::ConstIterator it = Children.begin();
00560 for (; it != Children.end(); ++it)
00561 {
00562 if ((*it)->getID() == id)
00563 return (*it);
00564
00565 if (searchchildren)
00566 e = (*it)->getElementFromId(id, true);
00567
00568 if (e)
00569 return e;
00570 }
00571
00572 return e;
00573 }
00574
00575
00578 bool isMyChild(IGUIElement* child) const
00579 {
00580 if (!child)
00581 return false;
00582 do
00583 {
00584 if (child->Parent)
00585 child = child->Parent;
00586
00587 } while (child->Parent && child != this);
00588
00589 _IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
00590 return child == this;
00591 }
00592
00593
00595
00602 bool getNextElement(s32 startOrder, bool reverse, bool group,
00603 IGUIElement*& first, IGUIElement*& closest, bool includeInvisible=false) const
00604 {
00605
00606 s32 wanted = startOrder + ( reverse ? -1 : 1 );
00607 if (wanted==-2)
00608 wanted = 1073741824;
00609
00610 core::list<IGUIElement*>::ConstIterator it = Children.begin();
00611
00612 s32 closestOrder, currentOrder;
00613
00614 while(it != Children.end())
00615 {
00616
00617 if ( ( (*it)->isVisible() || includeInvisible ) &&
00618 (group == true || (*it)->isTabGroup() == false) )
00619 {
00620
00621 if ((*it)->isTabStop() && ((*it)->isTabGroup() == group))
00622 {
00623 currentOrder = (*it)->getTabOrder();
00624
00625
00626 if (currentOrder == wanted)
00627 {
00628 closest = *it;
00629 return true;
00630 }
00631
00632
00633 if (closest)
00634 {
00635 closestOrder = closest->getTabOrder();
00636 if ( ( reverse && currentOrder > closestOrder && currentOrder < startOrder)
00637 ||(!reverse && currentOrder < closestOrder && currentOrder > startOrder))
00638 {
00639 closest = *it;
00640 }
00641 }
00642 else
00643 if ( (reverse && currentOrder < startOrder) || (!reverse && currentOrder > startOrder) )
00644 {
00645 closest = *it;
00646 }
00647
00648
00649 if (first)
00650 {
00651 closestOrder = first->getTabOrder();
00652
00653 if ( (reverse && closestOrder < currentOrder) || (!reverse && closestOrder > currentOrder) )
00654 {
00655 first = *it;
00656 }
00657 }
00658 else
00659 {
00660 first = *it;
00661 }
00662 }
00663
00664 if ((*it)->getNextElement(startOrder, reverse, group, first, closest))
00665 {
00666 _IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
00667 return true;
00668 }
00669 }
00670 ++it;
00671 }
00672 _IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
00673 return false;
00674 }
00675
00676
00678
00682 EGUI_ELEMENT_TYPE getType() const
00683 {
00684 return Type;
00685 }
00686
00688
00696 virtual bool hasType(EGUI_ELEMENT_TYPE type) const
00697 {
00698 return type == Type;
00699 }
00700
00701
00703
00705 virtual const c8* getTypeName() const
00706 {
00707 return GUIElementTypeNames[Type];
00708 }
00709
00710
00712
00714 virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options=0) const
00715 {
00716 out->addInt("Id", ID );
00717 out->addString("Caption", getText());
00718 out->addRect("Rect", DesiredRect);
00719 out->addPosition2d("MinSize", core::position2di(MinSize.Width, MinSize.Height));
00720 out->addPosition2d("MaxSize", core::position2di(MaxSize.Width, MaxSize.Height));
00721 out->addEnum("LeftAlign", AlignLeft, GUIAlignmentNames);
00722 out->addEnum("RightAlign", AlignRight, GUIAlignmentNames);
00723 out->addEnum("TopAlign", AlignTop, GUIAlignmentNames);
00724 out->addEnum("BottomAlign", AlignBottom, GUIAlignmentNames);
00725 out->addBool("Visible", IsVisible);
00726 out->addBool("Enabled", IsEnabled);
00727 out->addBool("TabStop", IsTabStop);
00728 out->addBool("TabGroup", IsTabGroup);
00729 out->addInt("TabOrder", TabOrder);
00730 out->addBool("NoClip", NoClip);
00731 }
00732
00733
00735
00737 virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options=0)
00738 {
00739 setID(in->getAttributeAsInt("Id"));
00740 setText(in->getAttributeAsStringW("Caption").c_str());
00741 setVisible(in->getAttributeAsBool("Visible"));
00742 setEnabled(in->getAttributeAsBool("Enabled"));
00743 IsTabStop = in->getAttributeAsBool("TabStop");
00744 IsTabGroup = in->getAttributeAsBool("TabGroup");
00745 TabOrder = in->getAttributeAsInt("TabOrder");
00746
00747 core::position2di p = in->getAttributeAsPosition2d("MaxSize");
00748 setMaxSize(core::dimension2du(p.X,p.Y));
00749
00750 p = in->getAttributeAsPosition2d("MinSize");
00751 setMinSize(core::dimension2du(p.X,p.Y));
00752
00753 setAlignment((EGUI_ALIGNMENT) in->getAttributeAsEnumeration("LeftAlign", GUIAlignmentNames),
00754 (EGUI_ALIGNMENT)in->getAttributeAsEnumeration("RightAlign", GUIAlignmentNames),
00755 (EGUI_ALIGNMENT)in->getAttributeAsEnumeration("TopAlign", GUIAlignmentNames),
00756 (EGUI_ALIGNMENT)in->getAttributeAsEnumeration("BottomAlign", GUIAlignmentNames));
00757
00758 setRelativePosition(in->getAttributeAsRect("Rect"));
00759
00760 setNotClipped(in->getAttributeAsBool("NoClip"));
00761 }
00762
00763 protected:
00764
00765 void addChildToEnd(IGUIElement* child)
00766 {
00767 if (child)
00768 {
00769 child->grab();
00770 child->remove();
00771 child->LastParentRect = getAbsolutePosition();
00772 child->Parent = this;
00773 Children.push_back(child);
00774 }
00775 }
00776
00777
00778 void recalculateAbsolutePosition(bool recursive)
00779 {
00780 core::rect<s32> parentAbsolute(0,0,0,0);
00781 core::rect<s32> parentAbsoluteClip;
00782 f32 fw=0.f, fh=0.f;
00783
00784 if (Parent)
00785 {
00786 parentAbsolute = Parent->AbsoluteRect;
00787
00788 if (NoClip)
00789 {
00790 IGUIElement* p=this;
00791 while (p && p->Parent)
00792 p = p->Parent;
00793 parentAbsoluteClip = p->AbsoluteClippingRect;
00794 }
00795 else
00796 parentAbsoluteClip = Parent->AbsoluteClippingRect;
00797 }
00798
00799 const s32 diffx = parentAbsolute.getWidth() - LastParentRect.getWidth();
00800 const s32 diffy = parentAbsolute.getHeight() - LastParentRect.getHeight();
00801
00802 if (AlignLeft == EGUIA_SCALE || AlignRight == EGUIA_SCALE)
00803 fw = (f32)parentAbsolute.getWidth();
00804
00805 if (AlignTop == EGUIA_SCALE || AlignBottom == EGUIA_SCALE)
00806 fh = (f32)parentAbsolute.getHeight();
00807
00808 switch (AlignLeft)
00809 {
00810 case EGUIA_UPPERLEFT:
00811 break;
00812 case EGUIA_LOWERRIGHT:
00813 DesiredRect.UpperLeftCorner.X += diffx;
00814 break;
00815 case EGUIA_CENTER:
00816 DesiredRect.UpperLeftCorner.X += diffx/2;
00817 break;
00818 case EGUIA_SCALE:
00819 DesiredRect.UpperLeftCorner.X = core::round32(ScaleRect.UpperLeftCorner.X * fw);
00820 break;
00821 }
00822
00823 switch (AlignRight)
00824 {
00825 case EGUIA_UPPERLEFT:
00826 break;
00827 case EGUIA_LOWERRIGHT:
00828 DesiredRect.LowerRightCorner.X += diffx;
00829 break;
00830 case EGUIA_CENTER:
00831 DesiredRect.LowerRightCorner.X += diffx/2;
00832 break;
00833 case EGUIA_SCALE:
00834 DesiredRect.LowerRightCorner.X = core::round32(ScaleRect.LowerRightCorner.X * fw);
00835 break;
00836 }
00837
00838 switch (AlignTop)
00839 {
00840 case EGUIA_UPPERLEFT:
00841 break;
00842 case EGUIA_LOWERRIGHT:
00843 DesiredRect.UpperLeftCorner.Y += diffy;
00844 break;
00845 case EGUIA_CENTER:
00846 DesiredRect.UpperLeftCorner.Y += diffy/2;
00847 break;
00848 case EGUIA_SCALE:
00849 DesiredRect.UpperLeftCorner.Y = core::round32(ScaleRect.UpperLeftCorner.Y * fh);
00850 break;
00851 }
00852
00853 switch (AlignBottom)
00854 {
00855 case EGUIA_UPPERLEFT:
00856 break;
00857 case EGUIA_LOWERRIGHT:
00858 DesiredRect.LowerRightCorner.Y += diffy;
00859 break;
00860 case EGUIA_CENTER:
00861 DesiredRect.LowerRightCorner.Y += diffy/2;
00862 break;
00863 case EGUIA_SCALE:
00864 DesiredRect.LowerRightCorner.Y = core::round32(ScaleRect.LowerRightCorner.Y * fh);
00865 break;
00866 }
00867
00868 RelativeRect = DesiredRect;
00869
00870 const s32 w = RelativeRect.getWidth();
00871 const s32 h = RelativeRect.getHeight();
00872
00873
00874 if (w < (s32)MinSize.Width)
00875 RelativeRect.LowerRightCorner.X = RelativeRect.UpperLeftCorner.X + MinSize.Width;
00876 if (h < (s32)MinSize.Height)
00877 RelativeRect.LowerRightCorner.Y = RelativeRect.UpperLeftCorner.Y + MinSize.Height;
00878 if (MaxSize.Width && w > (s32)MaxSize.Width)
00879 RelativeRect.LowerRightCorner.X = RelativeRect.UpperLeftCorner.X + MaxSize.Width;
00880 if (MaxSize.Height && h > (s32)MaxSize.Height)
00881 RelativeRect.LowerRightCorner.Y = RelativeRect.UpperLeftCorner.Y + MaxSize.Height;
00882
00883 RelativeRect.repair();
00884
00885 AbsoluteRect = RelativeRect + parentAbsolute.UpperLeftCorner;
00886
00887 if (!Parent)
00888 parentAbsoluteClip = AbsoluteRect;
00889
00890 AbsoluteClippingRect = AbsoluteRect;
00891 AbsoluteClippingRect.clipAgainst(parentAbsoluteClip);
00892
00893 LastParentRect = parentAbsolute;
00894
00895 if ( recursive )
00896 {
00897
00898 core::list<IGUIElement*>::Iterator it = Children.begin();
00899 for (; it != Children.end(); ++it)
00900 {
00901 (*it)->recalculateAbsolutePosition(recursive);
00902 }
00903 }
00904 }
00905
00906 protected:
00907
00909 core::list<IGUIElement*> Children;
00910
00912 IGUIElement* Parent;
00913
00915 core::rect<s32> RelativeRect;
00916
00918 core::rect<s32> AbsoluteRect;
00919
00921 core::rect<s32> AbsoluteClippingRect;
00922
00925 core::rect<s32> DesiredRect;
00926
00928 core::rect<s32> LastParentRect;
00929
00931 core::rect<f32> ScaleRect;
00932
00934 core::dimension2du MaxSize, MinSize;
00935
00937 bool IsVisible;
00938
00940 bool IsEnabled;
00941
00943 bool IsSubElement;
00944
00946 bool NoClip;
00947
00949 core::stringw Text;
00950
00952 core::stringw ToolTipText;
00953
00955 s32 ID;
00956
00958 bool IsTabStop;
00959
00961 s32 TabOrder;
00962
00964 bool IsTabGroup;
00965
00967 EGUI_ALIGNMENT AlignLeft, AlignRight, AlignTop, AlignBottom;
00968
00970 IGUIEnvironment* Environment;
00971
00973 EGUI_ELEMENT_TYPE Type;
00974 };
00975
00976
00977 }
00978 }
00979
00980 #endif
00981