MyGUI  3.2.1
MyGUI_Widget.cpp
Go to the documentation of this file.
00001 /*
00002  * This source file is part of MyGUI. For the latest info, see http://mygui.info/
00003  * Distributed under the MIT License
00004  * (See accompanying file COPYING.MIT or copy at http://opensource.org/licenses/MIT)
00005  */
00006 
00007 #include "MyGUI_Precompiled.h"
00008 #include "MyGUI_Widget.h"
00009 #include "MyGUI_Gui.h"
00010 #include "MyGUI_InputManager.h"
00011 #include "MyGUI_SkinManager.h"
00012 #include "MyGUI_SubWidgetManager.h"
00013 #include "MyGUI_WidgetManager.h"
00014 #include "MyGUI_ResourceSkin.h"
00015 #include "MyGUI_WidgetDefines.h"
00016 #include "MyGUI_LayerItem.h"
00017 #include "MyGUI_LayerManager.h"
00018 #include "MyGUI_RenderItem.h"
00019 #include "MyGUI_ISubWidget.h"
00020 #include "MyGUI_ISubWidgetText.h"
00021 #include "MyGUI_TextBox.h"
00022 #include "MyGUI_FactoryManager.h"
00023 #include "MyGUI_CoordConverter.h"
00024 #include "MyGUI_RenderManager.h"
00025 #include "MyGUI_ToolTipManager.h"
00026 #include "MyGUI_LayoutManager.h"
00027 
00028 namespace MyGUI
00029 {
00030 
00031     Widget::Widget() :
00032         mWidgetClient(nullptr),
00033         mEnabled(true),
00034         mInheritsEnabled(true),
00035         mInheritsVisible(true),
00036         mAlpha(ALPHA_MAX),
00037         mRealAlpha(ALPHA_MAX),
00038         mInheritsAlpha(true),
00039         mParent(nullptr),
00040         mWidgetStyle(WidgetStyle::Child),
00041         mContainer(nullptr),
00042         mAlign(Align::Default),
00043         mVisible(true),
00044         mDepth(0)
00045     {
00046     }
00047 
00048     Widget::~Widget()
00049     {
00050     }
00051 
00052     void Widget::_initialise(WidgetStyle _style, const IntCoord& _coord, const std::string& _skinName, Widget* _parent, ICroppedRectangle* _croppedParent, const std::string& _name)
00053     {
00054         ResourceSkin* skinInfo = nullptr;
00055         ResourceLayout* templateInfo = nullptr;
00056 
00057         if (LayoutManager::getInstance().isExist(_skinName))
00058             templateInfo = LayoutManager::getInstance().getByName(_skinName);
00059         else
00060             skinInfo = SkinManager::getInstance().getByName(_skinName);
00061 
00062         mCoord = _coord;
00063 
00064         mAlign = Align::Default;
00065         mWidgetStyle = _style;
00066         mName = _name;
00067 
00068         mCroppedParent = _croppedParent;
00069         mParent = _parent;
00070 
00071 
00072 #if MYGUI_DEBUG_MODE == 1
00073         // проверяем соответсвие входных данных
00074         if (mWidgetStyle == WidgetStyle::Child)
00075         {
00076             MYGUI_ASSERT(mCroppedParent, "must be cropped");
00077             MYGUI_ASSERT(mParent, "must be parent");
00078         }
00079         else if (mWidgetStyle == WidgetStyle::Overlapped)
00080         {
00081             MYGUI_ASSERT((mParent == nullptr) == (mCroppedParent == nullptr), "error cropped");
00082         }
00083         else if (mWidgetStyle == WidgetStyle::Popup)
00084         {
00085             MYGUI_ASSERT(!mCroppedParent, "cropped must be nullptr");
00086             MYGUI_ASSERT(mParent, "must be parent");
00087         }
00088 #endif
00089 
00090         // корректируем абсолютные координаты
00091         mAbsolutePosition = _coord.point();
00092 
00093         if (nullptr != mCroppedParent)
00094             mAbsolutePosition += mCroppedParent->getAbsolutePosition();
00095 
00096         const WidgetInfo* root = initialiseWidgetSkinBase(skinInfo, templateInfo);
00097 
00098         // дочернее окно обыкновенное
00099         if (mWidgetStyle == WidgetStyle::Child)
00100         {
00101             if (mParent)
00102                 mParent->addChildItem(this);
00103         }
00104         // дочернее нуно перекрывающееся
00105         else if (mWidgetStyle == WidgetStyle::Overlapped)
00106         {
00107             // дочернее перекрывающееся
00108             if (mParent)
00109                 mParent->addChildNode(this);
00110         }
00111 
00112         // витр метод для наследников
00113         initialiseOverride();
00114 
00115         if (skinInfo != nullptr)
00116             setSkinProperty(skinInfo);
00117 
00118         if (root != nullptr)
00119         {
00120             for (VectorStringPairs::const_iterator iter = root->properties.begin(); iter != root->properties.end(); ++iter)
00121             {
00122                 setProperty(iter->first, iter->second);
00123             }
00124         }
00125     }
00126 
00127     void Widget::_shutdown()
00128     {
00129         // витр метод для наследников
00130         shutdownOverride();
00131 
00132         shutdownWidgetSkinBase();
00133 
00134         _destroyAllChildWidget();
00135 
00136         // дочернее окно обыкновенное
00137         if (mWidgetStyle == WidgetStyle::Child)
00138         {
00139             if (mParent)
00140                 mParent->removeChildItem(this);
00141         }
00142         // дочернее нуно перекрывающееся
00143         else if (mWidgetStyle == WidgetStyle::Overlapped)
00144         {
00145             // дочернее перекрывающееся
00146             if (mParent)
00147                 mParent->removeChildNode(this);
00148         }
00149 
00150         mParent = nullptr;
00151         mCroppedParent = nullptr;
00152     }
00153 
00154     void Widget::changeWidgetSkin(const std::string& _skinName)
00155     {
00156         ResourceSkin* skinInfo = nullptr;
00157         ResourceLayout* templateInfo = nullptr;
00158 
00159         if (LayoutManager::getInstance().isExist(_skinName))
00160             templateInfo = LayoutManager::getInstance().getByName(_skinName);
00161         else
00162             skinInfo = SkinManager::getInstance().getByName(_skinName);
00163 
00164         shutdownOverride();
00165 
00166         saveLayerItem();
00167 
00168         shutdownWidgetSkinBase();
00169         const WidgetInfo* root = initialiseWidgetSkinBase(skinInfo, templateInfo);
00170 
00171         restoreLayerItem();
00172 
00173         initialiseOverride();
00174 
00175         if (skinInfo != nullptr)
00176             setSkinProperty(skinInfo);
00177 
00178         if (root != nullptr)
00179         {
00180             for (VectorStringPairs::const_iterator iter = root->properties.begin(); iter != root->properties.end(); ++iter)
00181             {
00182                 setProperty(iter->first, iter->second);
00183             }
00184         }
00185     }
00186 
00187     const WidgetInfo* Widget::initialiseWidgetSkinBase(ResourceSkin* _skinInfo, ResourceLayout* _templateInfo)
00188     {
00189         const WidgetInfo* root  = nullptr;
00190         bool skinOnly = false;
00191 
00192         if (_skinInfo == nullptr)
00193         {
00194             skinOnly = true;
00195             std::string skinName;
00196 
00197             const VectorWidgetInfo& data = _templateInfo->getLayoutData();
00198             for (VectorWidgetInfo::const_iterator item = data.begin(); item != data.end(); ++item)
00199             {
00200                 if ((*item).name == "Root")
00201                 {
00202                     skinName = (*item).skin;
00203                     root = &(*item);
00204                     break;
00205                 }
00206             }
00207 
00208             _skinInfo = SkinManager::getInstance().getByName(skinName);
00209         }
00210 
00211         //SAVE
00212         const IntSize& _size = mCoord.size();
00213 
00214         if (_skinInfo != nullptr)
00215         {
00216             //FIXME - явный вызов
00217             Widget::setSize(_skinInfo->getSize());
00218 
00219             _createSkinItem(_skinInfo);
00220         }
00221 
00222         // выставляем альфу, корректировка по отцу автоматически
00223         _updateAlpha();
00224         _updateEnabled();
00225         _updateVisible();
00226 
00227         if (!skinOnly)
00228         {
00229             const MapString& properties = _skinInfo->getProperties();
00230             for (MapString::const_iterator item = properties.begin(); item != properties.end(); ++item)
00231             {
00232                 if (BackwardCompatibility::isIgnoreProperty((*item).first))
00233                     setUserString((*item).first, (*item).second);
00234             }
00235 
00236             // создаем детей скина
00237             const VectorChildSkinInfo& child = _skinInfo->getChild();
00238             for (VectorChildSkinInfo::const_iterator iter = child.begin(); iter != child.end(); ++iter)
00239             {
00240                 Widget* widget = baseCreateWidget(iter->style, iter->type, iter->skin, iter->coord, iter->align, iter->layer, iter->name, true);
00241                 // заполняем UserString пропертями
00242                 for (MapString::const_iterator prop = iter->params.begin(); prop != iter->params.end(); ++prop)
00243                     widget->setUserString(prop->first, prop->second);
00244             }
00245         }
00246 
00247         if (root != nullptr)
00248         {
00249             //FIXME - явный вызов
00250             Widget::setSize(root->intCoord.size());
00251 
00252             for (MapString::const_iterator iter = root->userStrings.begin(); iter != root->userStrings.end(); ++iter)
00253             {
00254                 setUserString(iter->first, iter->second);
00255             }
00256 
00257             for (VectorWidgetInfo::const_iterator iter = root->childWidgetsInfo.begin(); iter != root->childWidgetsInfo.end(); ++iter)
00258             {
00259                 _templateInfo->createWidget(*iter, "", this, true);
00260             }
00261         }
00262 
00263         //FIXME - явный вызов
00264         Widget::setSize(_size);
00265 
00266         return root;
00267     }
00268 
00269     void Widget::shutdownWidgetSkinBase()
00270     {
00271         setMaskPick("");
00272 
00273         _deleteSkinItem();
00274 
00275         // удаляем виджеты чтобы ли в скине
00276         for (VectorWidgetPtr::iterator iter = mWidgetChildSkin.begin(); iter != mWidgetChildSkin.end(); ++iter)
00277         {
00278             // Добавляем себя чтобы удалилось
00279             mWidgetChild.push_back(*iter);
00280             _destroyChildWidget(*iter);
00281         }
00282         mWidgetChildSkin.clear();
00283 
00284         mWidgetClient = nullptr;
00285     }
00286 
00287     Widget* Widget::baseCreateWidget(WidgetStyle _style, const std::string& _type, const std::string& _skin, const IntCoord& _coord, Align _align, const std::string& _layer, const std::string& _name, bool _template)
00288     {
00289         Widget* widget = nullptr;
00290 
00291         if (_template)
00292         {
00293             widget = WidgetManager::getInstance().createWidget(_style, _type, _skin, _coord, this, _style == WidgetStyle::Popup ? nullptr : this, _name);
00294             mWidgetChildSkin.push_back(widget);
00295         }
00296         else
00297         {
00298             if (mWidgetClient != nullptr)
00299             {
00300                 widget = mWidgetClient->baseCreateWidget(_style, _type, _skin, _coord, _align, _layer, _name, _template);
00301                 onWidgetCreated(widget);
00302                 return widget;
00303             }
00304             else
00305             {
00306                 widget = WidgetManager::getInstance().createWidget(_style, _type, _skin, _coord, this, _style == WidgetStyle::Popup ? nullptr : this, _name);
00307                 addWidget(widget);
00308             }
00309         }
00310 
00311         widget->setAlign(_align);
00312 
00313         // присоединяем виджет с уровню
00314         if (!_layer.empty() && widget->isRootWidget())
00315             LayerManager::getInstance().attachToLayerNode(_layer, widget);
00316 
00317         onWidgetCreated(widget);
00318 
00319         return widget;
00320     }
00321 
00322     Widget* Widget::createWidgetRealT(const std::string& _type, const std::string& _skin, const FloatCoord& _coord, Align _align, const std::string& _name)
00323     {
00324         return createWidgetT(_type, _skin, CoordConverter::convertFromRelative(_coord, getSize()), _align, _name);
00325     }
00326 
00327     void Widget::_updateView()
00328     {
00329         bool margin = mCroppedParent ? _checkMargin() : false;
00330 
00331         // вьюпорт стал битым
00332         if (margin)
00333         {
00334             // проверка на полный выход за границу
00335             if (_checkOutside())
00336             {
00337                 // запоминаем текущее состояние
00338                 mIsMargin = margin;
00339 
00340                 // скрываем
00341                 _setSubSkinVisible(false);
00342 
00343                 // вся иерархия должна быть проверенна
00344                 for (VectorWidgetPtr::iterator widget = mWidgetChild.begin(); widget != mWidgetChild.end(); ++widget)
00345                     (*widget)->_updateView();
00346                 for (VectorWidgetPtr::iterator widget = mWidgetChildSkin.begin(); widget != mWidgetChildSkin.end(); ++widget)
00347                     (*widget)->_updateView();
00348 
00349                 return;
00350             }
00351         }
00352         // мы не обрезаны и были нормальные
00353         else if (!mIsMargin)
00354         {
00355             _updateSkinItemView();
00356             return;
00357         }
00358 
00359         // запоминаем текущее состояние
00360         mIsMargin = margin;
00361 
00362         // если скин был скрыт, то покажем
00363         _setSubSkinVisible(true);
00364 
00365         // обновляем наших детей, а они уже решат обновлять ли своих детей
00366         for (VectorWidgetPtr::iterator widget = mWidgetChild.begin(); widget != mWidgetChild.end(); ++widget)
00367             (*widget)->_updateView();
00368         for (VectorWidgetPtr::iterator widget = mWidgetChildSkin.begin(); widget != mWidgetChildSkin.end(); ++widget)
00369             (*widget)->_updateView();
00370 
00371         _updateSkinItemView();
00372     }
00373 
00374     bool Widget::_setWidgetState(const std::string& _state)
00375     {
00376         return _setSkinItemState(_state);
00377     }
00378 
00379     void Widget::_destroyChildWidget(Widget* _widget)
00380     {
00381         MYGUI_ASSERT(nullptr != _widget, "invalid widget pointer");
00382 
00383         if (mParent != nullptr && mParent->getClientWidget() == this)
00384             mParent->onWidgetDestroy(_widget);
00385 
00386         onWidgetDestroy(_widget);
00387 
00388         VectorWidgetPtr::iterator iter = std::find(mWidgetChild.begin(), mWidgetChild.end(), _widget);
00389         if (iter != mWidgetChild.end())
00390         {
00391             // сохраняем указатель
00392             MyGUI::Widget* widget = *iter;
00393 
00394             // удаляем из списка
00395             mWidgetChild.erase(iter);
00396 
00397             // отписываем от всех
00398             WidgetManager::getInstance().unlinkFromUnlinkers(_widget);
00399 
00400             // непосредственное удаление
00401             WidgetManager::getInstance()._deleteWidget(widget);
00402         }
00403         else
00404         {
00405             MYGUI_EXCEPT("Widget '" << _widget->getName() << "' not found");
00406         }
00407     }
00408 
00409     // удаляет всех детей
00410     void Widget::_destroyAllChildWidget()
00411     {
00412         WidgetManager& manager = WidgetManager::getInstance();
00413         while (!mWidgetChild.empty())
00414         {
00415             // сразу себя отписывем, иначе вложенной удаление убивает все
00416             Widget* widget = mWidgetChild.back();
00417             mWidgetChild.pop_back();
00418 
00419             // отписываем от всех
00420             manager.unlinkFromUnlinkers(widget);
00421 
00422             // и сами удалим, так как его больше в списке нет
00423             WidgetManager::getInstance()._deleteWidget(widget);
00424         }
00425     }
00426 
00427     IntCoord Widget::getClientCoord()
00428     {
00429         MYGUI_ASSERT(mWidgetClient != this, "mWidgetClient can not be this widget");
00430         if (mWidgetClient != nullptr)
00431             return mWidgetClient->getCoord();
00432         return IntCoord(0, 0, mCoord.width, mCoord.height);
00433     }
00434 
00435     void Widget::setAlpha(float _alpha)
00436     {
00437         if (mAlpha == _alpha)
00438             return;
00439         mAlpha = _alpha;
00440 
00441         _updateAlpha();
00442     }
00443 
00444     void Widget::_updateAlpha()
00445     {
00446         if (nullptr != mParent)
00447             mRealAlpha = mAlpha * (mInheritsAlpha ? mParent->_getRealAlpha() : ALPHA_MAX);
00448         else
00449             mRealAlpha = mAlpha;
00450 
00451         for (VectorWidgetPtr::iterator widget = mWidgetChild.begin(); widget != mWidgetChild.end(); ++widget)
00452             (*widget)->_updateAlpha();
00453         for (VectorWidgetPtr::iterator widget = mWidgetChildSkin.begin(); widget != mWidgetChildSkin.end(); ++widget)
00454             (*widget)->_updateAlpha();
00455 
00456         _setSkinItemAlpha(mRealAlpha);
00457     }
00458 
00459     void Widget::setInheritsAlpha(bool _inherits)
00460     {
00461         mInheritsAlpha = _inherits;
00462         _updateAlpha();
00463     }
00464 
00465     ILayerItem* Widget::getLayerItemByPoint(int _left, int _top) const
00466     {
00467         // проверяем попадание
00468         if (!mEnabled
00469             || !mVisible
00470             || (!getNeedMouseFocus() && !getInheritsPick())
00471             || !_checkPoint(_left, _top)
00472             // если есть маска, проверяем еще и по маске
00473             || !isMaskPickInside(IntPoint(_left - mCoord.left, _top - mCoord.top), mCoord)
00474             )
00475             return nullptr;
00476 
00477         // спрашиваем у детишек
00478         for (VectorWidgetPtr::const_reverse_iterator widget = mWidgetChild.rbegin(); widget != mWidgetChild.rend(); ++widget)
00479         {
00480             // общаемся только с послушными детьми
00481             if ((*widget)->mWidgetStyle == WidgetStyle::Popup)
00482                 continue;
00483 
00484             ILayerItem* item = (*widget)->getLayerItemByPoint(_left - mCoord.left, _top - mCoord.top);
00485             if (item != nullptr)
00486                 return item;
00487         }
00488         // спрашиваем у детишек скина
00489         for (VectorWidgetPtr::const_reverse_iterator widget = mWidgetChildSkin.rbegin(); widget != mWidgetChildSkin.rend(); ++widget)
00490         {
00491             ILayerItem* item = (*widget)->getLayerItemByPoint(_left - mCoord.left, _top - mCoord.top);
00492             if (item != nullptr)
00493                 return item;
00494         }
00495 
00496         // непослушные дети
00497         return getInheritsPick() ? nullptr : const_cast<Widget*>(this);
00498     }
00499 
00500     void Widget::_updateAbsolutePoint()
00501     {
00502         // мы рут, нам не надо
00503         if (!mCroppedParent)
00504             return;
00505 
00506         mAbsolutePosition = mCroppedParent->getAbsolutePosition() + mCoord.point();
00507 
00508         for (VectorWidgetPtr::iterator widget = mWidgetChild.begin(); widget != mWidgetChild.end(); ++widget)
00509             (*widget)->_updateAbsolutePoint();
00510         for (VectorWidgetPtr::iterator widget = mWidgetChildSkin.begin(); widget != mWidgetChildSkin.end(); ++widget)
00511             (*widget)->_updateAbsolutePoint();
00512 
00513         _correctSkinItemView();
00514     }
00515 
00516     void Widget::_forcePick(Widget* _widget)
00517     {
00518         MYGUI_ASSERT(mWidgetClient != this, "mWidgetClient can not be this widget");
00519         if (mWidgetClient != nullptr)
00520         {
00521             mWidgetClient->_forcePick(_widget);
00522             return;
00523         }
00524 
00525         VectorWidgetPtr::iterator iter = std::find(mWidgetChild.begin(), mWidgetChild.end(), _widget);
00526         if (iter == mWidgetChild.end())
00527             return;
00528 
00529         VectorWidgetPtr copy = mWidgetChild;
00530         for (VectorWidgetPtr::iterator widget = copy.begin(); widget != copy.end(); ++widget)
00531         {
00532             if ((*widget) == _widget)
00533                 (*widget)->setDepth(-1);
00534             else if ((*widget)->getDepth() == -1)
00535                 (*widget)->setDepth(0);
00536         }
00537     }
00538 
00539     Widget* Widget::findWidget(const std::string& _name)
00540     {
00541         if (_name == mName)
00542             return this;
00543         MYGUI_ASSERT(mWidgetClient != this, "mWidgetClient can not be this widget");
00544         if (mWidgetClient != nullptr)
00545             return mWidgetClient->findWidget(_name);
00546 
00547         for (VectorWidgetPtr::iterator widget = mWidgetChild.begin(); widget != mWidgetChild.end(); ++widget)
00548         {
00549             Widget* find = (*widget)->findWidget(_name);
00550             if (nullptr != find)
00551                 return find;
00552         }
00553         return nullptr;
00554     }
00555 
00556     void Widget::setRealPosition(const FloatPoint& _point)
00557     {
00558         setPosition(CoordConverter::convertFromRelative(_point, mCroppedParent == nullptr ? RenderManager::getInstance().getViewSize() : mCroppedParent->getSize()));
00559     }
00560 
00561     void Widget::setRealSize(const FloatSize& _size)
00562     {
00563         setSize(CoordConverter::convertFromRelative(_size, mCroppedParent == nullptr ? RenderManager::getInstance().getViewSize() : mCroppedParent->getSize()));
00564     }
00565 
00566     void Widget::setRealCoord(const FloatCoord& _coord)
00567     {
00568         setCoord(CoordConverter::convertFromRelative(_coord, mCroppedParent == nullptr ? RenderManager::getInstance().getViewSize() : mCroppedParent->getSize()));
00569     }
00570 
00571     void Widget::_setAlign(const IntSize& _oldsize, const IntSize& _newSize)
00572     {
00573         const IntSize& size = _newSize;//getParentSize();
00574 
00575         bool need_move = false;
00576         bool need_size = false;
00577         IntCoord coord = mCoord;
00578 
00579         // первоначальное выравнивание
00580         if (mAlign.isHStretch())
00581         {
00582             // растягиваем
00583             coord.width = mCoord.width + (size.width - _oldsize.width);
00584             need_size = true;
00585         }
00586         else if (mAlign.isRight())
00587         {
00588             // двигаем по правому краю
00589             coord.left = mCoord.left + (size.width - _oldsize.width);
00590             need_move = true;
00591         }
00592         else if (mAlign.isHCenter())
00593         {
00594             // выравнивание по горизонтали без растяжения
00595             coord.left = (size.width - mCoord.width) / 2;
00596             need_move = true;
00597         }
00598 
00599         if (mAlign.isVStretch())
00600         {
00601             // растягиваем
00602             coord.height = mCoord.height + (size.height - _oldsize.height);
00603             need_size = true;
00604         }
00605         else if (mAlign.isBottom())
00606         {
00607             // двигаем по нижнему краю
00608             coord.top = mCoord.top + (size.height - _oldsize.height);
00609             need_move = true;
00610         }
00611         else if (mAlign.isVCenter())
00612         {
00613             // выравнивание по вертикали без растяжения
00614             coord.top = (size.height - mCoord.height) / 2;
00615             need_move = true;
00616         }
00617 
00618         if (need_move)
00619         {
00620             if (need_size)
00621                 setCoord(coord);
00622             else
00623                 setPosition(coord.point());
00624         }
00625         else if (need_size)
00626         {
00627             setSize(coord.size());
00628         }
00629         else
00630         {
00631             _updateView(); // только если не вызвано передвижение и сайз
00632         }
00633     }
00634 
00635     void Widget::setPosition(const IntPoint& _point)
00636     {
00637         // обновляем абсолютные координаты
00638         mAbsolutePosition += _point - mCoord.point();
00639 
00640         for (VectorWidgetPtr::iterator widget = mWidgetChild.begin(); widget != mWidgetChild.end(); ++widget)
00641             (*widget)->_updateAbsolutePoint();
00642         for (VectorWidgetPtr::iterator widget = mWidgetChildSkin.begin(); widget != mWidgetChildSkin.end(); ++widget)
00643             (*widget)->_updateAbsolutePoint();
00644 
00645         mCoord = _point;
00646 
00647         _updateView();
00648 
00649         eventChangeCoord(this);
00650     }
00651 
00652     void Widget::setSize(const IntSize& _size)
00653     {
00654         // устанавливаем новую координату а старую пускаем в расчеты
00655         IntSize old = mCoord.size();
00656         mCoord = _size;
00657 
00658         bool visible = true;
00659 
00660         // обновляем выравнивание
00661         bool margin = mCroppedParent ? _checkMargin() : false;
00662 
00663         if (margin)
00664         {
00665             // проверка на полный выход за границу
00666             if (_checkOutside())
00667             {
00668                 // скрываем
00669                 visible = false;
00670             }
00671         }
00672 
00673         _setSubSkinVisible(visible);
00674 
00675         // передаем старую координату , до вызова, текущая координата отца должна быть новой
00676         for (VectorWidgetPtr::iterator widget = mWidgetChild.begin(); widget != mWidgetChild.end(); ++widget)
00677             (*widget)->_setAlign(old, getSize());
00678         for (VectorWidgetPtr::iterator widget = mWidgetChildSkin.begin(); widget != mWidgetChildSkin.end(); ++widget)
00679             (*widget)->_setAlign(old, getSize());
00680 
00681         _setSkinItemAlign(old);
00682 
00683         // запоминаем текущее состояние
00684         mIsMargin = margin;
00685 
00686         eventChangeCoord(this);
00687     }
00688 
00689     void Widget::setCoord(const IntCoord& _coord)
00690     {
00691         // обновляем абсолютные координаты
00692         mAbsolutePosition += _coord.point() - mCoord.point();
00693 
00694         for (VectorWidgetPtr::iterator widget = mWidgetChild.begin(); widget != mWidgetChild.end(); ++widget)
00695             (*widget)->_updateAbsolutePoint();
00696         for (VectorWidgetPtr::iterator widget = mWidgetChildSkin.begin(); widget != mWidgetChildSkin.end(); ++widget)
00697             (*widget)->_updateAbsolutePoint();
00698 
00699         // устанавливаем новую координату а старую пускаем в расчеты
00700         IntCoord old = mCoord;
00701         mCoord = _coord;
00702 
00703         bool visible = true;
00704 
00705         // обновляем выравнивание
00706         bool margin = mCroppedParent ? _checkMargin() : false;
00707 
00708         if (margin)
00709         {
00710             // проверка на полный выход за границу
00711             if (_checkOutside())
00712             {
00713                 // скрываем
00714                 visible = false;
00715             }
00716         }
00717 
00718         _setSubSkinVisible(visible);
00719 
00720         // передаем старую координату , до вызова, текущая координата отца должна быть новой
00721         for (VectorWidgetPtr::iterator widget = mWidgetChild.begin(); widget != mWidgetChild.end(); ++widget)
00722             (*widget)->_setAlign(old.size(), getSize());
00723         for (VectorWidgetPtr::iterator widget = mWidgetChildSkin.begin(); widget != mWidgetChildSkin.end(); ++widget)
00724             (*widget)->_setAlign(old.size(), getSize());
00725 
00726         _setSkinItemAlign(old.size());
00727 
00728         // запоминаем текущее состояние
00729         mIsMargin = margin;
00730 
00731         eventChangeCoord(this);
00732     }
00733 
00734     void Widget::setAlign(Align _value)
00735     {
00736         mAlign = _value;
00737     }
00738 
00739     void Widget::detachFromWidget(const std::string& _layer)
00740     {
00741         std::string oldlayer = getLayer() != nullptr ? getLayer()->getName() : "";
00742 
00743         Widget* parent = getParent();
00744         if (parent)
00745         {
00746             // отдетачиваемся от лееров
00747             if ( ! isRootWidget() )
00748             {
00749                 detachFromLayerItemNode(true);
00750 
00751                 if (mWidgetStyle == WidgetStyle::Child)
00752                 {
00753                     mParent->removeChildItem(this);
00754                 }
00755                 else if (mWidgetStyle == WidgetStyle::Overlapped)
00756                 {
00757                     mParent->removeChildNode(this);
00758                 }
00759 
00760                 mWidgetStyle = WidgetStyle::Overlapped;
00761 
00762                 mCroppedParent = nullptr;
00763 
00764                 // обновляем координаты
00765                 mAbsolutePosition = mCoord.point();
00766 
00767                 for (VectorWidgetPtr::iterator widget = mWidgetChild.begin(); widget != mWidgetChild.end(); ++widget)
00768                     (*widget)->_updateAbsolutePoint();
00769                 for (VectorWidgetPtr::iterator widget = mWidgetChildSkin.begin(); widget != mWidgetChildSkin.end(); ++widget)
00770                     (*widget)->_updateAbsolutePoint();
00771 
00772                 // сбрасываем обрезку
00773                 mMargin.clear();
00774 
00775                 _updateView();
00776             }
00777 
00778             // нам нужен самый рутовый парент
00779             while (parent->getParent())
00780                 parent = parent->getParent();
00781 
00782             //mIWidgetCreator = parent->mIWidgetCreator;
00783             //mIWidgetCreator->_linkChildWidget(this);
00784             Gui::getInstance()._linkChildWidget(this);
00785             mParent->_unlinkChildWidget(this);
00786             mParent = nullptr;
00787         }
00788 
00789         if (!_layer.empty())
00790         {
00791             LayerManager::getInstance().attachToLayerNode(_layer, this);
00792         }
00793         else if (!oldlayer.empty())
00794         {
00795             LayerManager::getInstance().attachToLayerNode(oldlayer, this);
00796         }
00797 
00798         _updateAlpha();
00799     }
00800 
00801     void Widget::attachToWidget(Widget* _parent, WidgetStyle _style, const std::string& _layer)
00802     {
00803         MYGUI_ASSERT(_parent, "parent must be valid");
00804         MYGUI_ASSERT(_parent != this, "cyclic attach (attaching to self)");
00805 
00806         // attach to client if widget have it
00807         if (_parent->getClientWidget())
00808             _parent = _parent->getClientWidget();
00809 
00810         // проверяем на цикличность атача
00811         Widget* parent = _parent;
00812         while (parent->getParent())
00813         {
00814             MYGUI_ASSERT(parent != this, "cyclic attach");
00815             parent = parent->getParent();
00816         }
00817 
00818         // отдетачиваемся от всего
00819         detachFromWidget();
00820 
00821         mWidgetStyle = _style;
00822 
00823         if (_style == WidgetStyle::Popup)
00824         {
00825             //mIWidgetCreator->_unlinkChildWidget(this);
00826             //mIWidgetCreator = _parent;
00827             if (mParent == nullptr)
00828                 Gui::getInstance()._unlinkChildWidget(this);
00829             else
00830                 mParent->_unlinkChildWidget(this);
00831 
00832             mParent = _parent;
00833             mParent->_linkChildWidget(this);
00834 
00835             mCroppedParent = nullptr;
00836 
00837             if (!_layer.empty())
00838             {
00839                 LayerManager::getInstance().attachToLayerNode(_layer, this);
00840             }
00841         }
00842         else if (_style == WidgetStyle::Child)
00843         {
00844             LayerManager::getInstance().detachFromLayer(this);
00845 
00846             //mIWidgetCreator->_unlinkChildWidget(this);
00847             //mIWidgetCreator = _parent;
00848             if (mParent == nullptr)
00849                 Gui::getInstance()._unlinkChildWidget(this);
00850             else
00851                 mParent->_unlinkChildWidget(this);
00852 
00853             mParent = _parent;
00854             mParent->_linkChildWidget(this);
00855 
00856             mCroppedParent = _parent;
00857             mAbsolutePosition = _parent->getAbsolutePosition() + mCoord.point();
00858 
00859             for (VectorWidgetPtr::iterator widget = mWidgetChild.begin(); widget != mWidgetChild.end(); ++widget)
00860                 (*widget)->_updateAbsolutePoint();
00861             for (VectorWidgetPtr::iterator widget = mWidgetChildSkin.begin(); widget != mWidgetChildSkin.end(); ++widget)
00862                 (*widget)->_updateAbsolutePoint();
00863 
00864             mParent->addChildItem(this);
00865 
00866             _updateView();
00867         }
00868         else if (_style == WidgetStyle::Overlapped)
00869         {
00870             LayerManager::getInstance().detachFromLayer(this);
00871 
00872             //mIWidgetCreator->_unlinkChildWidget(this);
00873             //mIWidgetCreator = _parent;
00874             if (mParent == nullptr)
00875                 Gui::getInstance()._unlinkChildWidget(this);
00876             else
00877                 mParent->_unlinkChildWidget(this);
00878 
00879             mParent = _parent;
00880             mParent->_linkChildWidget(this);
00881 
00882             mCroppedParent = _parent;
00883             mAbsolutePosition = _parent->getAbsolutePosition() + mCoord.point();
00884 
00885             for (VectorWidgetPtr::iterator widget = mWidgetChild.begin(); widget != mWidgetChild.end(); ++widget)
00886                 (*widget)->_updateAbsolutePoint();
00887             for (VectorWidgetPtr::iterator widget = mWidgetChildSkin.begin(); widget != mWidgetChildSkin.end(); ++widget)
00888                 (*widget)->_updateAbsolutePoint();
00889 
00890             mParent->addChildNode(this);
00891 
00892             _updateView();
00893         }
00894 
00895         _updateAlpha();
00896     }
00897 
00898     void Widget::setWidgetStyle(WidgetStyle _style, const std::string& _layer)
00899     {
00900         if (_style == mWidgetStyle)
00901             return;
00902         if (nullptr == getParent())
00903             return;
00904 
00905         Widget* parent = mParent;
00906 
00907         detachFromWidget();
00908         attachToWidget(parent, _style, _layer);
00909         // ищем леер к которому мы присоедененны
00910     }
00911 
00912     Widget* Widget::createWidgetT(const std::string& _type, const std::string& _skin, const IntCoord& _coord, Align _align, const std::string& _name)
00913     {
00914         return baseCreateWidget(WidgetStyle::Child, _type, _skin, _coord, _align, "", _name, false);
00915     }
00916 
00917     Widget* Widget::createWidgetT(const std::string& _type, const std::string& _skin, int _left, int _top, int _width, int _height, Align _align, const std::string& _name)
00918     {
00919         return createWidgetT(_type, _skin, IntCoord(_left, _top, _width, _height), _align, _name);
00920     }
00921 
00922     Widget* Widget::createWidgetRealT(const std::string& _type, const std::string& _skin, float _left, float _top, float _width, float _height, Align _align, const std::string& _name)
00923     {
00924         return createWidgetRealT(_type, _skin, FloatCoord(_left, _top, _width, _height), _align, _name);
00925     }
00926 
00927     Widget* Widget::createWidgetT(WidgetStyle _style, const std::string& _type, const std::string& _skin, const IntCoord& _coord, Align _align, const std::string& _layer, const std::string& _name)
00928     {
00929         return baseCreateWidget(_style, _type, _skin, _coord, _align, _layer, _name, false);
00930     }
00931 
00932     EnumeratorWidgetPtr Widget::getEnumerator() const
00933     {
00934         MYGUI_ASSERT(mWidgetClient != this, "mWidgetClient can not be this widget");
00935         if (mWidgetClient != nullptr)
00936             return mWidgetClient->getEnumerator();
00937         return Enumerator<VectorWidgetPtr>(mWidgetChild.begin(), mWidgetChild.end());
00938     }
00939 
00940     size_t Widget::getChildCount()
00941     {
00942         MYGUI_ASSERT(mWidgetClient != this, "mWidgetClient can not be this widget");
00943         if (mWidgetClient != nullptr)
00944             return mWidgetClient->getChildCount();
00945         return mWidgetChild.size();
00946     }
00947 
00948     Widget* Widget::getChildAt(size_t _index)
00949     {
00950         MYGUI_ASSERT(mWidgetClient != this, "mWidgetClient can not be this widget");
00951         if (mWidgetClient != nullptr)
00952             return mWidgetClient->getChildAt(_index);
00953         MYGUI_ASSERT_RANGE(_index, mWidgetChild.size(), "Widget::getChildAt");
00954         return mWidgetChild[_index];
00955     }
00956 
00957     void Widget::baseUpdateEnable()
00958     {
00959         if (getInheritedEnabled())
00960             _setWidgetState("normal");
00961         else
00962             _setWidgetState("disabled");
00963     }
00964 
00965     void Widget::setVisible(bool _value)
00966     {
00967         if (mVisible == _value)
00968             return;
00969         mVisible = _value;
00970 
00971         _updateVisible();
00972     }
00973 
00974     void Widget::_updateVisible()
00975     {
00976         mInheritsVisible = mParent == nullptr || (mParent->getVisible() && mParent->getInheritedVisible());
00977         bool value = mVisible && mInheritsVisible;
00978 
00979         _setSkinItemVisible(value);
00980 
00981         for (VectorWidgetPtr::iterator widget = mWidgetChild.begin(); widget != mWidgetChild.end(); ++widget)
00982             (*widget)->_updateVisible();
00983         for (VectorWidgetPtr::iterator widget = mWidgetChildSkin.begin(); widget != mWidgetChildSkin.end(); ++widget)
00984             (*widget)->_updateVisible();
00985 
00986         if (!value && InputManager::getInstance().getMouseFocusWidget() == this)
00987             InputManager::getInstance()._resetMouseFocusWidget();
00988         if (!value && InputManager::getInstance().getKeyFocusWidget() == this)
00989             InputManager::getInstance().resetKeyFocusWidget();
00990     }
00991 
00992     void Widget::setEnabled(bool _value)
00993     {
00994         if (mEnabled == _value)
00995             return;
00996         mEnabled = _value;
00997 
00998         _updateEnabled();
00999     }
01000 
01001     void Widget::_updateEnabled()
01002     {
01003         mInheritsEnabled = mParent == nullptr || (mParent->getInheritedEnabled());
01004         mInheritsEnabled = mInheritsEnabled && mEnabled;
01005 
01006         for (VectorWidgetPtr::iterator iter = mWidgetChild.begin(); iter != mWidgetChild.end(); ++iter)
01007             (*iter)->_updateEnabled();
01008         for (VectorWidgetPtr::iterator iter = mWidgetChildSkin.begin(); iter != mWidgetChildSkin.end(); ++iter)
01009             (*iter)->_updateEnabled();
01010 
01011         baseUpdateEnable();
01012 
01013         if (!mInheritsEnabled)
01014             InputManager::getInstance().unlinkWidget(this);
01015     }
01016 
01017     void Widget::setColour(const Colour& _value)
01018     {
01019         _setSkinItemColour(_value);
01020 
01021         for (VectorWidgetPtr::iterator widget = mWidgetChildSkin.begin(); widget != mWidgetChildSkin.end(); ++widget)
01022             (*widget)->setColour(_value);
01023     }
01024 
01025     IntSize Widget::getParentSize() const
01026     {
01027         if (mCroppedParent)
01028             return static_cast<Widget*>(mCroppedParent)->getSize();
01029         if (getLayer())
01030             return getLayer()->getSize();
01031 
01032         return RenderManager::getInstance().getViewSize();
01033     }
01034 
01035     void Widget::_resetContainer(bool _updateOnly)
01036     {
01037         if (getNeedToolTip())
01038             ToolTipManager::getInstance()._unlinkWidget(this);
01039     }
01040 
01041     bool Widget::_checkPoint(int _left, int _top) const
01042     {
01043         return ! ((_getViewLeft() > _left) || (_getViewTop() > _top) || (_getViewRight() < _left) || (_getViewBottom() < _top));
01044     }
01045 
01046     void Widget::_linkChildWidget(Widget* _widget)
01047     {
01048         VectorWidgetPtr::iterator iter = std::find(mWidgetChild.begin(), mWidgetChild.end(), _widget);
01049         MYGUI_ASSERT(iter == mWidgetChild.end(), "widget already exist");
01050         addWidget(_widget);
01051     }
01052 
01053     void Widget::_unlinkChildWidget(Widget* _widget)
01054     {
01055         VectorWidgetPtr::iterator iter = std::remove(mWidgetChild.begin(), mWidgetChild.end(), _widget);
01056         MYGUI_ASSERT(iter != mWidgetChild.end(), "widget not found");
01057         mWidgetChild.erase(iter);
01058     }
01059 
01060     void Widget::shutdownOverride()
01061     {
01062     }
01063 
01064     void Widget::initialiseOverride()
01065     {
01066     }
01067 
01068     void Widget::setSkinProperty(ResourceSkin* _info)
01069     {
01070         const MapString& properties = _info->getProperties();
01071         for (MapString::const_iterator item = properties.begin(); item != properties.end(); ++item)
01072             setProperty((*item).first, (*item).second);
01073     }
01074 
01075     void Widget::setProperty(const std::string& _key, const std::string& _value)
01076     {
01077         std::string key = _key;
01078         std::string value = _value;
01079 
01080         if (BackwardCompatibility::checkProperty(this, key, value))
01081         {
01082             size_t index = key.find("_");
01083             if (index != std::string::npos)
01084             {
01085                 MYGUI_LOG(Warning, "Widget property '" << key << "' have type prefix - use '" << key.substr(index + 1) << "' instead [" << LayoutManager::getInstance().getCurrentLayout() << "]");
01086                 key = key.substr(index + 1);
01087             }
01088 
01089             setPropertyOverride(key, value);
01090         }
01091     }
01092 
01093     VectorWidgetPtr Widget::getSkinWidgetsByName(const std::string& _name)
01094     {
01095         VectorWidgetPtr result;
01096 
01097         for (VectorWidgetPtr::iterator iter = mWidgetChildSkin.begin(); iter != mWidgetChildSkin.end(); ++iter)
01098             (*iter)->findWidgets(_name, result);
01099 
01100         return result;
01101     }
01102 
01103     void Widget::findWidgets(const std::string& _name, VectorWidgetPtr& _result)
01104     {
01105         if (_name == mName)
01106             _result.push_back(this);
01107 
01108         MYGUI_ASSERT(mWidgetClient != this, "mWidgetClient can not be this widget");
01109         if (mWidgetClient != nullptr)
01110         {
01111             mWidgetClient->findWidgets(_name, _result);
01112         }
01113         else
01114         {
01115             for (VectorWidgetPtr::iterator widget = mWidgetChild.begin(); widget != mWidgetChild.end(); ++widget)
01116                 (*widget)->findWidgets(_name, _result);
01117         }
01118     }
01119 
01120     void Widget::destroySkinWidget(Widget* _widget)
01121     {
01122         mWidgetChild.push_back(_widget);
01123         WidgetManager::getInstance().destroyWidget(_widget);
01124     }
01125 
01126     void Widget::onWidgetCreated(Widget* _widget)
01127     {
01128     }
01129 
01130     void Widget::onWidgetDestroy(Widget* _widget)
01131     {
01132     }
01133 
01134     void Widget::setWidgetClient(Widget* _widget)
01135     {
01136         mWidgetClient = _widget;
01137     }
01138 
01139     Widget* Widget::_createSkinWidget(WidgetStyle _style, const std::string& _type, const std::string& _skin, const IntCoord& _coord, Align _align, const std::string& _layer, const std::string& _name)
01140     {
01141         return baseCreateWidget(_style, _type, _skin, _coord, _align, _layer, _name, true);
01142     }
01143 
01144     void Widget::setPropertyOverride(const std::string& _key, const std::string& _value)
01145     {
01147         if (_key == "Position")
01148             setPosition(utility::parseValue<IntPoint>(_value));
01149 
01151         else if (_key == "Size")
01152             setSize(utility::parseValue<IntSize>(_value));
01153 
01155         else if (_key == "Coord")
01156             setCoord(utility::parseValue<IntCoord>(_value));
01157 
01159         else if (_key == "Visible")
01160             setVisible(utility::parseValue<bool>(_value));
01161 
01163         else if (_key == "Depth")
01164             setDepth(utility::parseValue<int>(_value));
01165 
01167         else if (_key == "Alpha")
01168             setAlpha(utility::parseValue<float>(_value));
01169 
01171         else if (_key == "Colour")
01172             setColour(utility::parseValue<Colour>(_value));
01173 
01175         else if (_key == "InheritsAlpha")
01176             setInheritsAlpha(utility::parseValue<bool>(_value));
01177 
01179         else if (_key == "InheritsPick")
01180             setInheritsPick(utility::parseValue<bool>(_value));
01181 
01183         else if (_key == "MaskPick")
01184             setMaskPick(_value);
01185 
01187         else if (_key == "NeedKey")
01188             setNeedKeyFocus(utility::parseValue<bool>(_value));
01189 
01191         else if (_key == "NeedMouse")
01192             setNeedMouseFocus(utility::parseValue<bool>(_value));
01193 
01195         else if (_key == "Enabled")
01196             setEnabled(utility::parseValue<bool>(_value));
01197 
01199         else if (_key == "NeedToolTip")
01200             setNeedToolTip(utility::parseValue<bool>(_value));
01201 
01203         else if (_key == "Pointer")
01204             setPointer(_value);
01205 
01206         else
01207         {
01208             MYGUI_LOG(Warning, "Widget property '" << _key << "' not found" << " [" << LayoutManager::getInstance().getCurrentLayout() << "]");
01209             return;
01210         }
01211 
01212         eventChangeProperty(this, _key, _value);
01213     }
01214 
01215     void Widget::setPosition(int _left, int _top)
01216     {
01217         setPosition(IntPoint(_left, _top));
01218     }
01219 
01220     void Widget::setSize(int _width, int _height)
01221     {
01222         setSize(IntSize(_width, _height));
01223     }
01224 
01225     void Widget::setCoord(int _left, int _top, int _width, int _height)
01226     {
01227         setCoord(IntCoord(_left, _top, _width, _height));
01228     }
01229 
01230     void Widget::setRealPosition(float _left, float _top)
01231     {
01232         setRealPosition(FloatPoint(_left, _top));
01233     }
01234 
01235     void Widget::setRealSize(float _width, float _height)
01236     {
01237         setRealSize(FloatSize(_width, _height));
01238     }
01239 
01240     void Widget::setRealCoord(float _left, float _top, float _width, float _height)
01241     {
01242         setRealCoord(FloatCoord(_left, _top, _width, _height));
01243     }
01244 
01245     const std::string& Widget::getName() const
01246     {
01247         return mName;
01248     }
01249 
01250     bool Widget::getVisible() const
01251     {
01252         return mVisible;
01253     }
01254 
01255     Align Widget::getAlign() const
01256     {
01257         return mAlign;
01258     }
01259 
01260     float Widget::getAlpha() const
01261     {
01262         return mAlpha;
01263     }
01264 
01265     bool Widget::getInheritsAlpha()  const
01266     {
01267         return mInheritsAlpha;
01268     }
01269 
01270     bool Widget::isRootWidget() const
01271     {
01272         return nullptr == mCroppedParent;
01273     }
01274 
01275     Widget* Widget::getParent() const
01276     {
01277         return mParent;
01278     }
01279 
01280     void Widget::setEnabledSilent(bool _value)
01281     {
01282         mEnabled = _value;
01283     }
01284 
01285     bool Widget::getEnabled() const
01286     {
01287         return mEnabled;
01288     }
01289 
01290     Widget* Widget::getClientWidget()
01291     {
01292         return mWidgetClient;
01293     }
01294 
01295     WidgetStyle Widget::getWidgetStyle() const
01296     {
01297         return mWidgetStyle;
01298     }
01299 
01300     size_t Widget::_getItemIndex(Widget* _item)
01301     {
01302         return ITEM_NONE;
01303     }
01304 
01305     void Widget::_setContainer(Widget* _value)
01306     {
01307         mContainer = _value;
01308     }
01309 
01310     Widget* Widget::_getContainer()
01311     {
01312         return mContainer;
01313     }
01314 
01315     size_t Widget::_getContainerIndex(const IntPoint& _point)
01316     {
01317         return ITEM_NONE;
01318     }
01319 
01320     const IntCoord& Widget::getLayerItemCoord() const
01321     {
01322         return mCoord;
01323     }
01324 
01325     float Widget::_getRealAlpha() const
01326     {
01327         return mRealAlpha;
01328     }
01329 
01330     bool Widget::getInheritedEnabled() const
01331     {
01332         return mInheritsEnabled;
01333     }
01334 
01335     bool Widget::getInheritedVisible() const
01336     {
01337         return mInheritsVisible;
01338     }
01339 
01340     void Widget::resizeLayerItemView(const IntSize& _oldView, const IntSize& _newView)
01341     {
01342         _setAlign(_oldView, _newView);
01343     }
01344 
01345     void Widget::setDepth(int _value)
01346     {
01347         if (mDepth == _value)
01348             return;
01349 
01350         mDepth = _value;
01351 
01352         if (mParent != nullptr)
01353         {
01354             mParent->_unlinkChildWidget(this);
01355             mParent->_linkChildWidget(this);
01356             mParent->_updateChilds();
01357         }
01358     }
01359 
01360     int Widget::getDepth() const
01361     {
01362         return mDepth;
01363     }
01364 
01365     void Widget::addWidget(Widget* _widget)
01366     {
01367         // сортировка глубины от большого к меньшему
01368 
01369         int depth = _widget->getDepth();
01370 
01371         for (size_t index = 0; index < mWidgetChild.size(); ++index)
01372         {
01373             Widget* widget = mWidgetChild[index];
01374             if (widget->getDepth() < depth)
01375             {
01376                 mWidgetChild.insert(mWidgetChild.begin() + index, _widget);
01377                 _updateChilds();
01378                 return;
01379             }
01380         }
01381 
01382         mWidgetChild.push_back(_widget);
01383     }
01384 
01385     void Widget::_updateChilds()
01386     {
01387         for (VectorWidgetPtr::iterator widget = mWidgetChild.begin(); widget != mWidgetChild.end(); ++widget)
01388         {
01389             if ((*widget)->getWidgetStyle() == WidgetStyle::Child)
01390             {
01391                 (*widget)->detachFromLayerItemNode(true);
01392                 removeChildItem((*widget));
01393             }
01394         }
01395 
01396         for (VectorWidgetPtr::iterator widget = mWidgetChild.begin(); widget != mWidgetChild.end(); ++widget)
01397         {
01398             if ((*widget)->getWidgetStyle() == WidgetStyle::Child)
01399             {
01400                 addChildItem((*widget));
01401                 (*widget)->_updateView();
01402             }
01403         }
01404     }
01405 
01406 } // namespace MyGUI