MyGUI
3.2.1
|
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