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, 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 parent->addChild(this);
00046
00047 }
00048
00049
00051 virtual ~IGUIElement()
00052 {
00053
00054 core::list<IGUIElement*>::Iterator it = Children.begin();
00055 for (; it != Children.end(); ++it)
00056 {
00057 (*it)->Parent = 0;
00058 (*it)->drop();
00059 }
00060 }
00061
00062
00064 IGUIElement* getParent() const
00065 {
00066 return Parent;
00067 }
00068
00069
00071 core::rect<s32> getRelativePosition() const
00072 {
00073 return RelativeRect;
00074 }
00075
00076
00078
00079 void setRelativePosition(const core::rect<s32>& r)
00080 {
00081 if (Parent)
00082 {
00083 const core::rect<s32>& r2 = Parent->getAbsolutePosition();
00084
00085 core::dimension2df d((f32)(r2.getSize().Width), (f32)(r2.getSize().Height));
00086
00087 if (AlignLeft == EGUIA_SCALE)
00088 ScaleRect.UpperLeftCorner.X = (f32)r.UpperLeftCorner.X / d.Width;
00089 if (AlignRight == EGUIA_SCALE)
00090 ScaleRect.LowerRightCorner.X = (f32)r.LowerRightCorner.X / d.Width;
00091 if (AlignTop == EGUIA_SCALE)
00092 ScaleRect.UpperLeftCorner.Y = (f32)r.UpperLeftCorner.Y / d.Height;
00093 if (AlignBottom == EGUIA_SCALE)
00094 ScaleRect.LowerRightCorner.Y = (f32)r.LowerRightCorner.Y / d.Height;
00095 }
00096
00097 DesiredRect = r;
00098 updateAbsolutePosition();
00099 }
00100
00102
00103 void setRelativePosition(const core::position2di & position)
00104 {
00105 const core::dimension2di mySize = RelativeRect.getSize();
00106 const core::rect<s32> rectangle(position.X, position.Y,
00107 position.X + mySize.Width, position.Y + mySize.Height);
00108 setRelativePosition(rectangle);
00109 }
00110
00111
00113
00117 void setRelativePositionProportional(const core::rect<f32>& r)
00118 {
00119 if (!Parent)
00120 return;
00121
00122 const core::dimension2di& d = Parent->getAbsolutePosition().getSize();
00123
00124 DesiredRect = core::rect<s32>(
00125 core::floor32((f32)d.Width * r.UpperLeftCorner.X),
00126 core::floor32((f32)d.Height * r.UpperLeftCorner.Y),
00127 core::floor32((f32)d.Width * r.LowerRightCorner.X),
00128 core::floor32((f32)d.Height * r.LowerRightCorner.Y));
00129
00130 ScaleRect = r;
00131
00132 updateAbsolutePosition();
00133 }
00134
00135
00137 core::rect<s32> getAbsolutePosition() const
00138 {
00139 return AbsoluteRect;
00140 }
00141
00142
00144 core::rect<s32> getAbsoluteClippingRect() const
00145 {
00146 return AbsoluteClippingRect;
00147 }
00148
00149
00151
00152 void setNotClipped(bool noClip)
00153 {
00154 NoClip = noClip;
00155 updateAbsolutePosition();
00156 }
00157
00158
00160
00161 bool isNotClipped() const
00162 {
00163 return NoClip;
00164 }
00165
00166
00168
00169 void setMaxSize(core::dimension2du size)
00170 {
00171 MaxSize = size;
00172 updateAbsolutePosition();
00173 }
00174
00175
00177 void setMinSize(core::dimension2du size)
00178 {
00179 MinSize = size;
00180 if (MinSize.Width < 1)
00181 MinSize.Width = 1;
00182 if (MinSize.Height < 1)
00183 MinSize.Height = 1;
00184 updateAbsolutePosition();
00185 }
00186
00187
00188 void setAlignment(EGUI_ALIGNMENT left, EGUI_ALIGNMENT right, EGUI_ALIGNMENT top, EGUI_ALIGNMENT bottom)
00189 {
00190 AlignLeft = left;
00191 AlignRight = right;
00192 AlignTop = top;
00193 AlignBottom = bottom;
00194
00195 if (Parent)
00196 {
00197 core::rect<s32> r(Parent->getAbsolutePosition());
00198
00199 core::dimension2df d((f32)r.getSize().Width, (f32)r.getSize().Height);
00200
00201 if (AlignLeft == EGUIA_SCALE)
00202 ScaleRect.UpperLeftCorner.X = (f32)DesiredRect.UpperLeftCorner.X / d.Width;
00203 if (AlignRight == EGUIA_SCALE)
00204 ScaleRect.LowerRightCorner.X = (f32)DesiredRect.LowerRightCorner.X / d.Width;
00205 if (AlignTop == EGUIA_SCALE)
00206 ScaleRect.UpperLeftCorner.Y = (f32)DesiredRect.UpperLeftCorner.Y / d.Height;
00207 if (AlignBottom == EGUIA_SCALE)
00208 ScaleRect.LowerRightCorner.Y = (f32)DesiredRect.LowerRightCorner.Y / d.Height;
00209 }
00210 }
00211
00212
00214 virtual void updateAbsolutePosition()
00215 {
00216 core::rect<s32> parentAbsolute(0,0,0,0);
00217 core::rect<s32> parentAbsoluteClip;
00218 f32 fw=0.f, fh=0.f;
00219
00220 if (Parent)
00221 {
00222 parentAbsolute = Parent->AbsoluteRect;
00223
00224 if (NoClip)
00225 {
00226 IGUIElement* p=this;
00227 while (p && p->Parent)
00228 p = p->Parent;
00229 parentAbsoluteClip = p->AbsoluteClippingRect;
00230 }
00231 else
00232 parentAbsoluteClip = Parent->AbsoluteClippingRect;
00233 }
00234
00235 const s32 diffx = parentAbsolute.getWidth() - LastParentRect.getWidth();
00236 const s32 diffy = parentAbsolute.getHeight() - LastParentRect.getHeight();
00237
00238 if (AlignLeft == EGUIA_SCALE || AlignRight == EGUIA_SCALE)
00239 fw = (f32)parentAbsolute.getWidth();
00240
00241 if (AlignTop == EGUIA_SCALE || AlignBottom == EGUIA_SCALE)
00242 fh = (f32)parentAbsolute.getHeight();
00243
00244 switch (AlignLeft)
00245 {
00246 case EGUIA_UPPERLEFT:
00247 break;
00248 case EGUIA_LOWERRIGHT:
00249 DesiredRect.UpperLeftCorner.X += diffx;
00250 break;
00251 case EGUIA_CENTER:
00252 DesiredRect.UpperLeftCorner.X += diffx/2;
00253 break;
00254 case EGUIA_SCALE:
00255 DesiredRect.UpperLeftCorner.X = (s32)(ScaleRect.UpperLeftCorner.X * fw);
00256 break;
00257 }
00258
00259 switch (AlignRight)
00260 {
00261 case EGUIA_UPPERLEFT:
00262 break;
00263 case EGUIA_LOWERRIGHT:
00264 DesiredRect.LowerRightCorner.X += diffx;
00265 break;
00266 case EGUIA_CENTER:
00267 DesiredRect.LowerRightCorner.X += diffx/2;
00268 break;
00269 case EGUIA_SCALE:
00270 DesiredRect.LowerRightCorner.X = (s32)(ScaleRect.LowerRightCorner.X * fw);
00271 break;
00272 }
00273
00274 switch (AlignTop)
00275 {
00276 case EGUIA_UPPERLEFT:
00277 break;
00278 case EGUIA_LOWERRIGHT:
00279 DesiredRect.UpperLeftCorner.Y += diffy;
00280 break;
00281 case EGUIA_CENTER:
00282 DesiredRect.UpperLeftCorner.Y += diffy/2;
00283 break;
00284 case EGUIA_SCALE:
00285 DesiredRect.UpperLeftCorner.Y = (s32)(ScaleRect.UpperLeftCorner.Y * fh);
00286 break;
00287 }
00288
00289 switch (AlignBottom)
00290 {
00291 case EGUIA_UPPERLEFT:
00292 break;
00293 case EGUIA_LOWERRIGHT:
00294 DesiredRect.LowerRightCorner.Y += diffy;
00295 break;
00296 case EGUIA_CENTER:
00297 DesiredRect.LowerRightCorner.Y += diffy/2;
00298 break;
00299 case EGUIA_SCALE:
00300 DesiredRect.LowerRightCorner.Y = (s32)(ScaleRect.LowerRightCorner.Y * fh);
00301 break;
00302 }
00303
00304 RelativeRect = DesiredRect;
00305
00306 const s32 w = RelativeRect.getWidth();
00307 const s32 h = RelativeRect.getHeight();
00308
00309
00310 if (w < (s32)MinSize.Width)
00311 RelativeRect.LowerRightCorner.X = RelativeRect.UpperLeftCorner.X + MinSize.Width;
00312 if (h < (s32)MinSize.Height)
00313 RelativeRect.LowerRightCorner.Y = RelativeRect.UpperLeftCorner.Y + MinSize.Height;
00314 if (MaxSize.Width && w > (s32)MaxSize.Width)
00315 RelativeRect.LowerRightCorner.X = RelativeRect.UpperLeftCorner.X + MaxSize.Width;
00316 if (MaxSize.Height && h > (s32)MaxSize.Height)
00317 RelativeRect.LowerRightCorner.Y = RelativeRect.UpperLeftCorner.Y + MaxSize.Height;
00318
00319 RelativeRect.repair();
00320
00321 AbsoluteRect = RelativeRect + parentAbsolute.UpperLeftCorner;
00322
00323 if (!Parent)
00324 parentAbsoluteClip = AbsoluteRect;
00325
00326 AbsoluteClippingRect = AbsoluteRect;
00327 AbsoluteClippingRect.clipAgainst(parentAbsoluteClip);
00328
00329 LastParentRect = parentAbsolute;
00330
00331
00332 core::list<IGUIElement*>::Iterator it = Children.begin();
00333 for (; it != Children.end(); ++it)
00334 {
00335 (*it)->updateAbsolutePosition();
00336 }
00337 }
00338
00339
00341
00352 IGUIElement* getElementFromPoint(const core::position2d<s32>& point)
00353 {
00354 IGUIElement* target = 0;
00355
00356
00357
00358
00359 core::list<IGUIElement*>::Iterator it = Children.getLast();
00360
00361 if (isVisible())
00362 {
00363 while(it != Children.end())
00364 {
00365 target = (*it)->getElementFromPoint(point);
00366 if (target)
00367 return target;
00368
00369 --it;
00370 }
00371 }
00372
00373 if (isVisible() && isPointInside(point))
00374 target = this;
00375
00376 return target;
00377 }
00378
00379
00381
00382 virtual bool isPointInside(const core::position2d<s32>& point) const
00383 {
00384 return AbsoluteClippingRect.isPointInside(point);
00385 }
00386
00387
00389 virtual void addChild(IGUIElement* child)
00390 {
00391 if (child)
00392 {
00393 child->grab();
00394 child->remove();
00395 child->LastParentRect = getAbsolutePosition();
00396 child->Parent = this;
00397 Children.push_back(child);
00398 child->updateAbsolutePosition();
00399 }
00400 }
00401
00403 virtual void removeChild(IGUIElement* child)
00404 {
00405 core::list<IGUIElement*>::Iterator it = Children.begin();
00406 for (; it != Children.end(); ++it)
00407 if ((*it) == child)
00408 {
00409 (*it)->Parent = 0;
00410 (*it)->drop();
00411 Children.erase(it);
00412 return;
00413 }
00414 }
00415
00416
00418 virtual void remove()
00419 {
00420 if (Parent)
00421 Parent->removeChild(this);
00422 }
00423
00424
00426 virtual void draw()
00427 {
00428 if ( isVisible() )
00429 {
00430 core::list<IGUIElement*>::Iterator it = Children.begin();
00431 for (; it != Children.end(); ++it)
00432 (*it)->draw();
00433 }
00434 }
00435
00436
00438 virtual void OnPostRender(u32 timeMs)
00439 {
00440 if ( isVisible() )
00441 {
00442 core::list<IGUIElement*>::Iterator it = Children.begin();
00443 for (; it != Children.end(); ++it)
00444 (*it)->OnPostRender( timeMs );
00445 }
00446 }
00447
00448
00450 virtual void move(core::position2d<s32> absoluteMovement)
00451 {
00452 setRelativePosition(DesiredRect + absoluteMovement);
00453 }
00454
00455
00457 virtual bool isVisible() const
00458 {
00459 _IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
00460 return IsVisible;
00461 }
00462
00463
00465 virtual void setVisible(bool visible)
00466 {
00467 IsVisible = visible;
00468 }
00469
00470
00472 virtual bool isSubElement() const
00473 {
00474 _IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
00475 return IsSubElement;
00476 }
00477
00478
00480
00482 virtual void setSubElement(bool subElement)
00483 {
00484 IsSubElement = subElement;
00485 }
00486
00487
00489
00491 void setTabStop(bool enable)
00492 {
00493 IsTabStop = enable;
00494 }
00495
00496
00498 bool isTabStop() const
00499 {
00500 _IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
00501 return IsTabStop;
00502 }
00503
00504
00506
00508 void setTabOrder(s32 index)
00509 {
00510
00511 if (index < 0)
00512 {
00513 TabOrder = 0;
00514 IGUIElement *el = getTabGroup();
00515 while (IsTabGroup && el && el->Parent)
00516 el = el->Parent;
00517
00518 IGUIElement *first=0, *closest=0;
00519 if (el)
00520 {
00521
00522 el->getNextElement(-1, true, IsTabGroup, first, closest, true);
00523 if (first)
00524 {
00525 TabOrder = first->getTabOrder() + 1;
00526 }
00527 }
00528
00529 }
00530 else
00531 TabOrder = index;
00532 }
00533
00534
00536 s32 getTabOrder() const
00537 {
00538 return TabOrder;
00539 }
00540
00541
00543
00545 void setTabGroup(bool isGroup)
00546 {
00547 IsTabGroup = isGroup;
00548 }
00549
00550
00552 bool isTabGroup() const
00553 {
00554 _IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
00555 return IsTabGroup;
00556 }
00557
00558
00560 IGUIElement* getTabGroup()
00561 {
00562 IGUIElement *ret=this;
00563
00564 while (ret && !ret->isTabGroup())
00565 ret = ret->getParent();
00566
00567 return ret;
00568 }
00569
00570
00572 virtual bool isEnabled() const
00573 {
00574 _IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
00575 return IsEnabled;
00576 }
00577
00578
00580 virtual void setEnabled(bool enabled)
00581 {
00582 IsEnabled = enabled;
00583 }
00584
00585
00587 virtual void setText(const wchar_t* text)
00588 {
00589 Text = text;
00590 }
00591
00592
00594 virtual const wchar_t* getText() const
00595 {
00596 return Text.c_str();
00597 }
00598
00599
00601 virtual void setToolTipText(const wchar_t* text)
00602 {
00603 ToolTipText = text;
00604 }
00605
00606
00608 virtual const core::stringw& getToolTipText() const
00609 {
00610 return ToolTipText;
00611 }
00612
00613
00615 virtual s32 getID() const
00616 {
00617 return ID;
00618 }
00619
00620
00622 virtual void setID(s32 id)
00623 {
00624 ID = id;
00625 }
00626
00627
00629 virtual bool OnEvent(const SEvent& event)
00630 {
00631 return Parent ? Parent->OnEvent(event) : false;
00632 }
00633
00634
00636
00637 virtual bool bringToFront(IGUIElement* element)
00638 {
00639 core::list<IGUIElement*>::Iterator it = Children.begin();
00640 for (; it != Children.end(); ++it)
00641 {
00642 if (element == (*it))
00643 {
00644 Children.erase(it);
00645 Children.push_back(element);
00646 return true;
00647 }
00648 }
00649
00650 _IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
00651 return false;
00652 }
00653
00654
00656 virtual const core::list<IGUIElement*>& getChildren() const
00657 {
00658 return Children;
00659 }
00660
00661
00663
00669 virtual IGUIElement* getElementFromId(s32 id, bool searchchildren=false) const
00670 {
00671 IGUIElement* e = 0;
00672
00673 core::list<IGUIElement*>::ConstIterator it = Children.begin();
00674 for (; it != Children.end(); ++it)
00675 {
00676 if ((*it)->getID() == id)
00677 return (*it);
00678
00679 if (searchchildren)
00680 e = (*it)->getElementFromId(id, true);
00681
00682 if (e)
00683 return e;
00684 }
00685
00686 return e;
00687 }
00688
00689
00692 bool isMyChild(IGUIElement* child) const
00693 {
00694 if (!child)
00695 return false;
00696 do
00697 {
00698 if (child->Parent)
00699 child = child->Parent;
00700
00701 } while (child->Parent && child != this);
00702
00703 _IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
00704 return child == this;
00705 }
00706
00707
00709
00716 bool getNextElement(s32 startOrder, bool reverse, bool group,
00717 IGUIElement*& first, IGUIElement*& closest, bool includeInvisible=false) const
00718 {
00719
00720 s32 wanted = startOrder + ( reverse ? -1 : 1 );
00721 if (wanted==-2)
00722 wanted = 1073741824;
00723
00724 core::list<IGUIElement*>::ConstIterator it = Children.begin();
00725
00726 s32 closestOrder, currentOrder;
00727
00728 while(it != Children.end())
00729 {
00730
00731 if ( ( (*it)->isVisible() || includeInvisible ) &&
00732 (group == true || (*it)->isTabGroup() == false) )
00733 {
00734
00735 if ((*it)->isTabStop() && ((*it)->isTabGroup() == group))
00736 {
00737 currentOrder = (*it)->getTabOrder();
00738
00739
00740 if (currentOrder == wanted)
00741 {
00742 closest = *it;
00743 return true;
00744 }
00745
00746
00747 if (closest)
00748 {
00749 closestOrder = closest->getTabOrder();
00750 if ( ( reverse && currentOrder > closestOrder && currentOrder < startOrder)
00751 ||(!reverse && currentOrder < closestOrder && currentOrder > startOrder))
00752 {
00753 closest = *it;
00754 }
00755 }
00756 else
00757 if ( (reverse && currentOrder < startOrder) || (!reverse && currentOrder > startOrder) )
00758 {
00759 closest = *it;
00760 }
00761
00762
00763 if (first)
00764 {
00765 closestOrder = first->getTabOrder();
00766
00767 if ( (reverse && closestOrder < currentOrder) || (!reverse && closestOrder > currentOrder) )
00768 {
00769 first = *it;
00770 }
00771 }
00772 else
00773 {
00774 first = *it;
00775 }
00776 }
00777
00778 if ((*it)->getNextElement(startOrder, reverse, group, first, closest))
00779 {
00780 _IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
00781 return true;
00782 }
00783 }
00784 ++it;
00785 }
00786 _IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
00787 return false;
00788 }
00789
00790
00792
00796 EGUI_ELEMENT_TYPE getType() const
00797 {
00798 return Type;
00799 }
00800
00801
00803
00805 virtual const c8* getTypeName() const
00806 {
00807 return GUIElementTypeNames[Type];
00808 }
00809
00810
00812
00814 virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options=0) const
00815 {
00816 out->addInt("Id", ID );
00817 out->addString("Caption", getText());
00818 out->addRect("Rect", DesiredRect);
00819 out->addPosition2d("MinSize", core::position2di(MinSize.Width, MinSize.Height));
00820 out->addPosition2d("MaxSize", core::position2di(MaxSize.Width, MaxSize.Height));
00821 out->addEnum("LeftAlign", AlignLeft, GUIAlignmentNames);
00822 out->addEnum("RightAlign", AlignRight, GUIAlignmentNames);
00823 out->addEnum("TopAlign", AlignTop, GUIAlignmentNames);
00824 out->addEnum("BottomAlign", AlignBottom, GUIAlignmentNames);
00825 out->addBool("Visible", IsVisible);
00826 out->addBool("Enabled", IsEnabled);
00827 out->addBool("TabStop", IsTabStop);
00828 out->addBool("TabGroup", IsTabGroup);
00829 out->addInt("TabOrder", TabOrder);
00830 out->addBool("NoClip", NoClip);
00831 }
00832
00833
00835
00837 virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options=0)
00838 {
00839 setID(in->getAttributeAsInt("Id"));
00840 setText(in->getAttributeAsStringW("Caption").c_str());
00841 setVisible(in->getAttributeAsBool("Visible"));
00842 setEnabled(in->getAttributeAsBool("Enabled"));
00843 IsTabStop = in->getAttributeAsBool("TabStop");
00844 IsTabGroup = in->getAttributeAsBool("TabGroup");
00845 TabOrder = in->getAttributeAsInt("TabOrder");
00846
00847 core::position2di p = in->getAttributeAsPosition2d("MaxSize");
00848 setMaxSize(core::dimension2du(p.X,p.Y));
00849
00850 p = in->getAttributeAsPosition2d("MinSize");
00851 setMinSize(core::dimension2du(p.X,p.Y));
00852
00853 setAlignment((EGUI_ALIGNMENT) in->getAttributeAsEnumeration("LeftAlign", GUIAlignmentNames),
00854 (EGUI_ALIGNMENT)in->getAttributeAsEnumeration("RightAlign", GUIAlignmentNames),
00855 (EGUI_ALIGNMENT)in->getAttributeAsEnumeration("TopAlign", GUIAlignmentNames),
00856 (EGUI_ALIGNMENT)in->getAttributeAsEnumeration("BottomAlign", GUIAlignmentNames));
00857
00858 setRelativePosition(in->getAttributeAsRect("Rect"));
00859
00860 setNotClipped(in->getAttributeAsBool("NoClip"));
00861 }
00862
00863 protected:
00864
00866 core::list<IGUIElement*> Children;
00867
00869 IGUIElement* Parent;
00870
00872 core::rect<s32> RelativeRect;
00873
00875 core::rect<s32> AbsoluteRect;
00876
00878 core::rect<s32> AbsoluteClippingRect;
00879
00882 core::rect<s32> DesiredRect;
00883
00885 core::rect<s32> LastParentRect;
00886
00888 core::rect<f32> ScaleRect;
00889
00891 core::dimension2du MaxSize, MinSize;
00892
00894 bool IsVisible;
00895
00897 bool IsEnabled;
00898
00900 bool IsSubElement;
00901
00903 bool NoClip;
00904
00906 core::stringw Text;
00907
00909 core::stringw ToolTipText;
00910
00912 s32 ID;
00913
00915 bool IsTabStop;
00916
00918 s32 TabOrder;
00919
00921 bool IsTabGroup;
00922
00924 EGUI_ALIGNMENT AlignLeft, AlignRight, AlignTop, AlignBottom;
00925
00927 IGUIEnvironment* Environment;
00928
00930 EGUI_ELEMENT_TYPE Type;
00931 };
00932
00933
00934 }
00935 }
00936
00937 #endif
00938