MyGUI: MyGUI_Widget.cpp Source File

MyGUI 3.4.2

- Main Page
- Related Pages
- Namespaces
- Data Structures
- Files
- Examples

- File List
- Globals

MyGUI_Widget.cpp
Go to the documentation of this file.
1/*
2 * This source file is part of MyGUI. For the latest info, see http://mygui.info/
3 * Distributed under the MIT License
4 * (See accompanying file COPYING.MIT or copy at http://opensource.org/licenses/MIT)
5 */
6
7#include "MyGUI_Precompiled.h"
8#include "MyGUI_Widget.h"
9#include "MyGUI_Gui.h"
10#include "MyGUI_InputManager.h"
11#include "MyGUI_SkinManager.h"
12#include "MyGUI_SubWidgetManager.h"
13#include "MyGUI_WidgetManager.h"
14#include "MyGUI_ResourceSkin.h"
15#include "MyGUI_WidgetDefines.h"
16#include "MyGUI_LayerItem.h"
17#include "MyGUI_LayerManager.h"
18#include "MyGUI_RenderItem.h"
19#include "MyGUI_ISubWidget.h"
20#include "MyGUI_ISubWidgetText.h"
21#include "MyGUI_TextBox.h"
22#include "MyGUI_FactoryManager.h"
23#include "MyGUI_CoordConverter.h"
24#include "MyGUI_RenderManager.h"
25#include "MyGUI_ToolTipManager.h"
26#include "MyGUI_LayoutManager.h"
27
28namespace MyGUI
29{
30
31 Widget::Widget() :
32 mWidgetClient(nullptr),
33 mEnabled(true),
34 mInheritedEnabled(true),
35 mInheritedVisible(true),
36 mAlpha(ALPHA_MAX),
37 mRealAlpha(ALPHA_MAX),
38 mInheritsAlpha(true),
39 mParent(nullptr),
40 mWidgetStyle(WidgetStyle::Child),
41 mContainer(nullptr),
42 mAlign(Align::Default),
43 mVisible(true),
44 mDepth(0)
45 {
46 }
47
48 void Widget::_initialise(WidgetStyle _style, const IntCoord& _coord, const std::string& _skinName, Widget* _parent, ICroppedRectangle* _croppedParent, const std::string& _name)
49 {
50 ResourceSkin* skinInfo = nullptr;
51 ResourceLayout* templateInfo = nullptr;
52
53 if (LayoutManager::getInstance().isExist(_skinName))
54 templateInfo = LayoutManager::getInstance().getByName(_skinName);
55 else
56 skinInfo = SkinManager::getInstance().getByName(_skinName);
57
58 mCoord = _coord;
59
60 mAlign = Align::Default;
61 mWidgetStyle = _style;
62 mName = _name;
63
64 mCroppedParent = _croppedParent;
65 mParent = _parent;
66
67
68#if MYGUI_DEBUG_MODE == 1
69 // проверяем соответсвие входных данных
70 if (mWidgetStyle == WidgetStyle::Child)
71 {
72 MYGUI_ASSERT(mCroppedParent, "must be cropped");
73 MYGUI_ASSERT(mParent, "must be parent");
74 }
75 else if (mWidgetStyle == WidgetStyle::Overlapped)
76 {
77 MYGUI_ASSERT((mParent == nullptr) == (mCroppedParent == nullptr), "error cropped");
78 }
79 else if (mWidgetStyle == WidgetStyle::Popup)
80 {
81 MYGUI_ASSERT(!mCroppedParent, "cropped must be nullptr");
82 MYGUI_ASSERT(mParent, "must be parent");
83 }
84#endif
85
86 // корректируем абсолютные координаты
87 mAbsolutePosition = _coord.point();
88
89 if (nullptr != mCroppedParent)
90 mAbsolutePosition += mCroppedParent->getAbsolutePosition();
91
92 const WidgetInfo* root = initialiseWidgetSkinBase(skinInfo, templateInfo);
93
94 // дочернее окно обыкновенное
95 if (mWidgetStyle == WidgetStyle::Child)
96 {
97 if (mParent)
98 mParent->addChildItem(this);
99 }
100 // дочернее нуно перекрывающееся
101 else if (mWidgetStyle == WidgetStyle::Overlapped)
102 {
103 // дочернее перекрывающееся
104 if (mParent)
105 mParent->addChildNode(this);
106 }
107
108 // витр метод для наследников
109 initialiseOverride();
110
111 if (skinInfo != nullptr)
112 setSkinProperty(skinInfo);
113
114 if (root != nullptr)
115 {
116 for (VectorStringPairs::const_iterator iter = root->properties.begin(); iter != root->properties.end(); ++iter)
117 {
118 setProperty(iter->first, iter->second);
119 }
120 }
121 }
122
123 void Widget::_shutdown()
124 {
125 eventWidgetDestroyed(this);
126
127 setUserData(Any::Null);
128
129 // витр метод для наследников
130 shutdownOverride();
131
132 shutdownWidgetSkinBase();
133
134 _destroyAllChildWidget();
135
136 // дочернее окно обыкновенное
137 if (mWidgetStyle == WidgetStyle::Child)
138 {
139 if (mParent)
140 mParent->removeChildItem(this);
141 }
142 // дочернее нуно перекрывающееся
143 else if (mWidgetStyle == WidgetStyle::Overlapped)
144 {
145 // дочернее перекрывающееся
146 if (mParent)
147 mParent->removeChildNode(this);
148 }
149
150 mParent = nullptr;
151 mCroppedParent = nullptr;
152 }
153
154 void Widget::changeWidgetSkin(const std::string& _skinName)
155 {
156 ResourceSkin* skinInfo = nullptr;
157 ResourceLayout* templateInfo = nullptr;
158
159 if (LayoutManager::getInstance().isExist(_skinName))
160 templateInfo = LayoutManager::getInstance().getByName(_skinName);
161 else
162 skinInfo = SkinManager::getInstance().getByName(_skinName);
163
164 shutdownOverride();
165
166 saveLayerItem();
167
168 shutdownWidgetSkinBase();
169 const WidgetInfo* root = initialiseWidgetSkinBase(skinInfo, templateInfo);
170
171 restoreLayerItem();
172
173 initialiseOverride();
174
175 if (skinInfo != nullptr)
176 setSkinProperty(skinInfo);
177
178 if (root != nullptr)
179 {
180 for (VectorStringPairs::const_iterator iter = root->properties.begin(); iter != root->properties.end(); ++iter)
181 {
182 setProperty(iter->first, iter->second);
183 }
184 }
185 }
186
187 const WidgetInfo* Widget::initialiseWidgetSkinBase(ResourceSkin* _skinInfo, ResourceLayout* _templateInfo)
188 {
189 const WidgetInfo* root = nullptr;
190 bool skinOnly = false;
191
192 if (_skinInfo == nullptr)
193 {
194 skinOnly = true;
195 std::string skinName;
196
197 const VectorWidgetInfo& data = _templateInfo->getLayoutData();
198 for (VectorWidgetInfo::const_iterator item = data.begin(); item != data.end(); ++item)
199 {
200 if ((*item).name == "Root")
201 {
202 skinName = (*item).skin;
203 root = &(*item);
204 break;
205 }
206 }
207
208 _skinInfo = SkinManager::getInstance().getByName(skinName);
209 }
210
211 //SAVE
212 const IntSize& _size = mCoord.size();
213
214 if (_skinInfo != nullptr)
215 {
216 //FIXME - явный вызов
217 Widget::setSize(_skinInfo->getSize());
218
219 _createSkinItem(_skinInfo);
220 }
221
222 // выставляем альфу, корректировка по отцу автоматически
223 _updateAlpha();
224 _updateEnabled();
225 _updateVisible();
226
227 if (!skinOnly)
228 {
229 const MapString& properties = _skinInfo->getProperties();
230 for (MapString::const_iterator item = properties.begin(); item != properties.end(); ++item)
231 {
232 if (BackwardCompatibility::isIgnoreProperty((*item).first))
233 setUserString((*item).first, (*item).second);
234 }
235
236 // создаем детей скина
237 const VectorChildSkinInfo& child = _skinInfo->getChild();
238 for (VectorChildSkinInfo::const_iterator iter = child.begin(); iter != child.end(); ++iter)
239 {
240 Widget* widget = baseCreateWidget(iter->style, iter->type, iter->skin, iter->coord, iter->align, iter->layer, iter->name, true);
241 // заполняем UserString пропертями
242 for (MapString::const_iterator prop = iter->params.begin(); prop != iter->params.end(); ++prop)
243 widget->setUserString(prop->first, prop->second);
244 }
245 }
246
247 if (root != nullptr)
248 {
249 //FIXME - явный вызов
250 Widget::setSize(root->intCoord.size());
251
252 for (MapString::const_iterator iter = root->userStrings.begin(); iter != root->userStrings.end(); ++iter)
253 {
254 setUserString(iter->first, iter->second);
255 }
256
257 for (VectorWidgetInfo::const_iterator iter = root->childWidgetsInfo.begin(); iter != root->childWidgetsInfo.end(); ++iter)
258 {
259 _templateInfo->createWidget(*iter, "", this, true);
260 }
261 }
262
263 //FIXME - явный вызов
264 Widget::setSize(_size);
265
266 return root;
267 }
268
269 void Widget::shutdownWidgetSkinBase()
270 {
271 setMaskPick("");
272
273 _deleteSkinItem();
274
275 // удаляем виджеты чтобы ли в скине
276 for (VectorWidgetPtr::iterator iter = mWidgetChildSkin.begin(); iter != mWidgetChildSkin.end(); ++iter)
277 {
278 // Добавляем себя чтобы удалилось
279 mWidgetChild.push_back(*iter);
280 _destroyChildWidget(*iter);
281 }
282 mWidgetChildSkin.clear();
283
284 mWidgetClient = nullptr;
285 }
286
287 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)
288 {
289 Widget* widget = nullptr;
290
291 if (_template)
292 {
293 widget = WidgetManager::getInstance().createWidget(_style, _type, _skin, _coord, this, _style == WidgetStyle::Popup ? nullptr : this, _name);
294 mWidgetChildSkin.push_back(widget);
295 }
296 else
297 {
298 if (mWidgetClient != nullptr)
299 {
300 widget = mWidgetClient->baseCreateWidget(_style, _type, _skin, _coord, _align, _layer, _name, _template);
301 onWidgetCreated(widget);
302 return widget;
303 }
304 else
305 {
306 widget = WidgetManager::getInstance().createWidget(_style, _type, _skin, _coord, this, _style == WidgetStyle::Popup ? nullptr : this, _name);
307 addWidget(widget);
308 }
309 }
310
311 widget->setAlign(_align);
312
313 // присоединяем виджет с уровню
314 if (!_layer.empty() && widget->isRootWidget())
315 LayerManager::getInstance().attachToLayerNode(_layer, widget);
316
317 onWidgetCreated(widget);
318
319 return widget;
320 }
321
322 Widget* Widget::createWidgetRealT(const std::string& _type, const std::string& _skin, const FloatCoord& _coord, Align _align, const std::string& _name)
323 {
324 return createWidgetT(_type, _skin, CoordConverter::convertFromRelative(_coord, getSize()), _align, _name);
325 }
326
327 void Widget::_updateView()
328 {
329 bool margin = mCroppedParent ? _checkMargin() : false;
330
331 // вьюпорт стал битым
332 if (margin)
333 {
334 // проверка на полный выход за границу
335 if (_checkOutside())
336 {
337 // запоминаем текущее состояние
338 mIsMargin = margin;
339
340 // скрываем
341 _setSubSkinVisible(false);
342
343 // вся иерархия должна быть проверенна
344 for (VectorWidgetPtr::iterator widget = mWidgetChild.begin(); widget != mWidgetChild.end(); ++widget)
345 (*widget)->_updateView();
346 for (VectorWidgetPtr::iterator widget = mWidgetChildSkin.begin(); widget != mWidgetChildSkin.end(); ++widget)
347 (*widget)->_updateView();
348
349 return;
350 }
351 }
352 // мы не обрезаны и были нормальные
353 else if (!mIsMargin)
354 {
355 _updateSkinItemView();
356 return;
357 }
358
359 // запоминаем текущее состояние
360 mIsMargin = margin;
361
362 // если скин был скрыт, то покажем
363 _setSubSkinVisible(true);
364
365 // обновляем наших детей, а они уже решат обновлять ли своих детей
366 for (VectorWidgetPtr::iterator widget = mWidgetChild.begin(); widget != mWidgetChild.end(); ++widget)
367 (*widget)->_updateView();
368 for (VectorWidgetPtr::iterator widget = mWidgetChildSkin.begin(); widget != mWidgetChildSkin.end(); ++widget)
369 (*widget)->_updateView();
370
371 _updateSkinItemView();
372 }
373
374 bool Widget::_setWidgetState(const std::string& _state)
375 {
376 return _setSkinItemState(_state);
377 }
378
379 void Widget::_destroyChildWidget(Widget* _widget)
380 {
381 MYGUI_ASSERT(nullptr != _widget, "invalid widget pointer");
382
383 if (mParent != nullptr && mParent->getClientWidget() == this)
384 mParent->onWidgetDestroy(_widget);
385
386 onWidgetDestroy(_widget);
387
388 VectorWidgetPtr::iterator iter = std::find(mWidgetChild.begin(), mWidgetChild.end(), _widget);
389 if (iter != mWidgetChild.end())
390 {
391 // сохраняем указатель
392 MyGUI::Widget* widget = *iter;
393
394 // удаляем из списка
395 mWidgetChild.erase(iter);
396
397 // отписываем от всех
398 WidgetManager::getInstance().unlinkFromUnlinkers(_widget);
399
400 // непосредственное удаление
401 WidgetManager::getInstance()._deleteWidget(widget);
402 }
403 else
404 {
405 MYGUI_EXCEPT("Widget '" << _widget->getName() << "' not found");
406 }
407 }
408
409 // удаляет всех детей
410 void Widget::_destroyAllChildWidget()
411 {
412 WidgetManager& manager = WidgetManager::getInstance();
413 while (!mWidgetChild.empty())
414 {
415 // сразу себя отписывем, иначе вложенной удаление убивает все
416 Widget* widget = mWidgetChild.back();
417 mWidgetChild.pop_back();
418
419 // отписываем от всех
420 manager.unlinkFromUnlinkers(widget);
421
422 // и сами удалим, так как его больше в списке нет
423 WidgetManager::getInstance()._deleteWidget(widget);
424 }
425 }
426
427 IntCoord Widget::getClientCoord() const
428 {
429 if (mWidgetClient != nullptr)
430 return mWidgetClient->getCoord();
431 return IntCoord(0, 0, mCoord.width, mCoord.height);
432 }
433
434 void Widget::setAlpha(float _alpha)
435 {
436 if (mAlpha == _alpha)
437 return;
438 mAlpha = _alpha;
439
440 _updateAlpha();
441 }
442
443 void Widget::_updateAlpha()
444 {
445 if (nullptr != mParent)
446 mRealAlpha = mAlpha * (mInheritsAlpha ? mParent->_getRealAlpha() : ALPHA_MAX);
447 else
448 mRealAlpha = mAlpha;
449
450 for (VectorWidgetPtr::iterator widget = mWidgetChild.begin(); widget != mWidgetChild.end(); ++widget)
451 (*widget)->_updateAlpha();
452 for (VectorWidgetPtr::iterator widget = mWidgetChildSkin.begin(); widget != mWidgetChildSkin.end(); ++widget)
453 (*widget)->_updateAlpha();
454
455 _setSkinItemAlpha(mRealAlpha);
456 }
457
458 void Widget::setInheritsAlpha(bool _inherits)
459 {
460 mInheritsAlpha = _inherits;
461 _updateAlpha();
462 }
463
464 ILayerItem* Widget::getLayerItemByPoint(int _left, int _top) const
465 {
466 // проверяем попадание
467 if (!mEnabled
468 || !mInheritedVisible
469 || (!getNeedMouseFocus() && !getInheritsPick())
470 || !_checkPoint(_left, _top)
471 // если есть маска, проверяем еще и по маске
472 || !isMaskPickInside(IntPoint(_left - mCoord.left, _top - mCoord.top), mCoord)
473 )
474 return nullptr;
475
476 // спрашиваем у детишек
477 for (VectorWidgetPtr::const_reverse_iterator widget = mWidgetChild.rbegin(); widget != mWidgetChild.rend(); ++widget)
478 {
479 // общаемся только с послушными детьми
480 if ((*widget)->mWidgetStyle == WidgetStyle::Popup)
481 continue;
482
483 ILayerItem* item = (*widget)->getLayerItemByPoint(_left - mCoord.left, _top - mCoord.top);
484 if (item != nullptr)
485 return item;
486 }
487 // спрашиваем у детишек скина
488 for (VectorWidgetPtr::const_reverse_iterator widget = mWidgetChildSkin.rbegin(); widget != mWidgetChildSkin.rend(); ++widget)
489 {
490 ILayerItem* item = (*widget)->getLayerItemByPoint(_left - mCoord.left, _top - mCoord.top);
491 if (item != nullptr)
492 return item;
493 }
494
495 // непослушные дети
496 return getInheritsPick() ? nullptr : const_cast<Widget*>(this);
497 }
498
499 void Widget::_updateAbsolutePoint()
500 {
501 // мы рут, нам не надо
502 if (!mCroppedParent)
503 return;
504
505 mAbsolutePosition = mCroppedParent->getAbsolutePosition() + mCoord.point();
506
507 for (VectorWidgetPtr::iterator widget = mWidgetChild.begin(); widget != mWidgetChild.end(); ++widget)
508 (*widget)->_updateAbsolutePoint();
509 for (VectorWidgetPtr::iterator widget = mWidgetChildSkin.begin(); widget != mWidgetChildSkin.end(); ++widget)
510 (*widget)->_updateAbsolutePoint();
511
512 _correctSkinItemView();
513 }
514
515 void Widget::_forcePick(Widget* _widget)
516 {
517 if (mWidgetClient != nullptr)
518 {
519 mWidgetClient->_forcePick(_widget);
520 return;
521 }
522
523 VectorWidgetPtr::iterator iter = std::find(mWidgetChild.begin(), mWidgetChild.end(), _widget);
524 if (iter == mWidgetChild.end())
525 return;
526
527 VectorWidgetPtr copy = mWidgetChild;
528 for (VectorWidgetPtr::iterator widget = copy.begin(); widget != copy.end(); ++widget)
529 {
530 if ((*widget) == _widget)
531 (*widget)->setDepth(-1);
532 else if ((*widget)->getDepth() == -1)
533 (*widget)->setDepth(0);
534 }
535 }
536
537 Widget* Widget::findWidget(const std::string& _name)
538 {
539 if (_name == mName)
540 return this;
541 if (mWidgetClient != nullptr)
542 return mWidgetClient->findWidget(_name);
543
544 for (VectorWidgetPtr::iterator widget = mWidgetChild.begin(); widget != mWidgetChild.end(); ++widget)
545 {
546 Widget* find = (*widget)->findWidget(_name);
547 if (nullptr != find)
548 return find;
549 }
550 return nullptr;
551 }
552
553 void Widget::setRealPosition(const FloatPoint& _point)
554 {
555 setPosition(CoordConverter::convertFromRelative(_point, mCroppedParent == nullptr ? RenderManager::getInstance().getViewSize() : mCroppedParent->getSize()));
556 }
557
558 void Widget::setRealSize(const FloatSize& _size)
559 {
560 setSize(CoordConverter::convertFromRelative(_size, mCroppedParent == nullptr ? RenderManager::getInstance().getViewSize() : mCroppedParent->getSize()));
561 }
562
563 void Widget::setRealCoord(const FloatCoord& _coord)
564 {
565 setCoord(CoordConverter::convertFromRelative(_coord, mCroppedParent == nullptr ? RenderManager::getInstance().getViewSize() : mCroppedParent->getSize()));
566 }
567
568 void Widget::_setAlign(const IntSize& _oldsize, const IntSize& _newSize)
569 {
570 const IntSize& size = _newSize;//getParentSize();
571
572 bool need_move = false;
573 bool need_size = false;
574 IntCoord coord = mCoord;
575
576 // первоначальное выравнивание
577 if (mAlign.isHStretch())
578 {
579 // растягиваем
580 coord.width = mCoord.width + (size.width - _oldsize.width);
581 need_size = true;
582 }
583 else if (mAlign.isRight())
584 {
585 // двигаем по правому краю
586 coord.left = mCoord.left + (size.width - _oldsize.width);
587 need_move = true;
588 }
589 else if (mAlign.isHCenter())
590 {
591 // выравнивание по горизонтали без растяжения
592 coord.left = (size.width - mCoord.width) / 2;
593 need_move = true;
594 }
595
596 if (mAlign.isVStretch())
597 {
598 // растягиваем
599 coord.height = mCoord.height + (size.height - _oldsize.height);
600 need_size = true;
601 }
602 else if (mAlign.isBottom())
603 {
604 // двигаем по нижнему краю
605 coord.top = mCoord.top + (size.height - _oldsize.height);
606 need_move = true;
607 }
608 else if (mAlign.isVCenter())
609 {
610 // выравнивание по вертикали без растяжения
611 coord.top = (size.height - mCoord.height) / 2;
612 need_move = true;
613 }
614
615 if (need_move)
616 {
617 if (need_size)
618 setCoord(coord);
619 else
620 setPosition(coord.point());
621 }
622 else if (need_size)
623 {
624 setSize(coord.size());
625 }
626 else
627 {
628 _updateView(); // только если не вызвано передвижение и сайз
629 }
630 }
631
632 void Widget::setPosition(const IntPoint& _point)
633 {
634 // обновляем абсолютные координаты
635 mAbsolutePosition += _point - mCoord.point();
636
637 for (VectorWidgetPtr::iterator widget = mWidgetChild.begin(); widget != mWidgetChild.end(); ++widget)
638 (*widget)->_updateAbsolutePoint();
639 for (VectorWidgetPtr::iterator widget = mWidgetChildSkin.begin(); widget != mWidgetChildSkin.end(); ++widget)
640 (*widget)->_updateAbsolutePoint();
641
642 mCoord = _point;
643
644 _updateView();
645
646 eventChangeCoord(this);
647 }
648
649 void Widget::setSize(const IntSize& _size)
650 {
651 // устанавливаем новую координату а старую пускаем в расчеты
652 IntSize old = mCoord.size();
653 mCoord = _size;
654
655 bool visible = true;
656
657 // обновляем выравнивание
658 bool margin = mCroppedParent ? _checkMargin() : false;
659
660 if (margin)
661 {
662 // проверка на полный выход за границу
663 if (_checkOutside())
664 {
665 // скрываем
666 visible = false;
667 }
668 }
669
670 _setSubSkinVisible(visible);
671
672 // передаем старую координату , до вызова, текущая координата отца должна быть новой
673 for (VectorWidgetPtr::iterator widget = mWidgetChild.begin(); widget != mWidgetChild.end(); ++widget)
674 (*widget)->_setAlign(old, getSize());
675 for (VectorWidgetPtr::iterator widget = mWidgetChildSkin.begin(); widget != mWidgetChildSkin.end(); ++widget)
676 (*widget)->_setAlign(old, getSize());
677
678 _setSkinItemAlign(old);
679
680 // запоминаем текущее состояние
681 mIsMargin = margin;
682
683 eventChangeCoord(this);
684 }
685
686 void Widget::setCoord(const IntCoord& _coord)
687 {
688 // обновляем абсолютные координаты
689 mAbsolutePosition += _coord.point() - mCoord.point();
690
691 for (VectorWidgetPtr::iterator widget = mWidgetChild.begin(); widget != mWidgetChild.end(); ++widget)
692 (*widget)->_updateAbsolutePoint();
693 for (VectorWidgetPtr::iterator widget = mWidgetChildSkin.begin(); widget != mWidgetChildSkin.end(); ++widget)
694 (*widget)->_updateAbsolutePoint();
695
696 // устанавливаем новую координату а старую пускаем в расчеты
697 IntCoord old = mCoord;
698 mCoord = _coord;
699
700 bool visible = true;
701
702 // обновляем выравнивание
703 bool margin = mCroppedParent ? _checkMargin() : false;
704
705 if (margin)
706 {
707 // проверка на полный выход за границу
708 if (_checkOutside())
709 {
710 // скрываем
711 visible = false;
712 }
713 }
714
715 _setSubSkinVisible(visible);
716
717 // передаем старую координату , до вызова, текущая координата отца должна быть новой
718 for (VectorWidgetPtr::iterator widget = mWidgetChild.begin(); widget != mWidgetChild.end(); ++widget)
719 (*widget)->_setAlign(old.size(), getSize());
720 for (VectorWidgetPtr::iterator widget = mWidgetChildSkin.begin(); widget != mWidgetChildSkin.end(); ++widget)
721 (*widget)->_setAlign(old.size(), getSize());
722
723 _setSkinItemAlign(old.size());
724
725 // запоминаем текущее состояние
726 mIsMargin = margin;
727
728 eventChangeCoord(this);
729 }
730
731 void Widget::setAlign(Align _value)
732 {
733 mAlign = _value;
734 }
735
736 void Widget::detachFromWidget(const std::string& _layer)
737 {
738 std::string oldlayer = getLayer() != nullptr ? getLayer()->getName() : "";
739
740 Widget* parent = getParent();
741 if (parent)
742 {
743 // отдетачиваемся от лееров
744 if ( ! isRootWidget() )
745 {
746 detachFromLayerItemNode(true);
747
748 if (mWidgetStyle == WidgetStyle::Child)
749 {
750 mParent->removeChildItem(this);
751 }
752 else if (mWidgetStyle == WidgetStyle::Overlapped)
753 {
754 mParent->removeChildNode(this);
755 }
756
757 mWidgetStyle = WidgetStyle::Overlapped;
758
759 mCroppedParent = nullptr;
760
761 // обновляем координаты
762 mAbsolutePosition = mCoord.point();
763
764 for (VectorWidgetPtr::iterator widget = mWidgetChild.begin(); widget != mWidgetChild.end(); ++widget)
765 (*widget)->_updateAbsolutePoint();
766 for (VectorWidgetPtr::iterator widget = mWidgetChildSkin.begin(); widget != mWidgetChildSkin.end(); ++widget)
767 (*widget)->_updateAbsolutePoint();
768
769 // сбрасываем обрезку
770 mMargin.clear();
771
772 _updateView();
773 }
774
775 // нам нужен самый рутовый парент
776 while (parent->getParent())
777 parent = parent->getParent();
778
779 //mIWidgetCreator = parent->mIWidgetCreator;
780 //mIWidgetCreator->_linkChildWidget(this);
781 Gui::getInstance()._linkChildWidget(this);
782 mParent->_unlinkChildWidget(this);
783 mParent = nullptr;
784 }
785
786 if (!_layer.empty())
787 {
788 LayerManager::getInstance().attachToLayerNode(_layer, this);
789 }
790 else if (!oldlayer.empty())
791 {
792 LayerManager::getInstance().attachToLayerNode(oldlayer, this);
793 }
794
795 _updateAlpha();
796 }
797
798 void Widget::attachToWidget(Widget* _parent, WidgetStyle _style, const std::string& _layer)
799 {
800 MYGUI_ASSERT(_parent, "parent must be valid");
801 MYGUI_ASSERT(_parent != this, "cyclic attach (attaching to self)");
802
803 // attach to client if widget have it
804 if (_parent->getClientWidget())
805 _parent = _parent->getClientWidget();
806
807 // проверяем на цикличность атача
808 Widget* parent = _parent;
809 while (parent->getParent())
810 {
811 MYGUI_ASSERT(parent != this, "cyclic attach");
812 parent = parent->getParent();
813 }
814
815 // отдетачиваемся от всего
816 detachFromWidget();
817
818 mWidgetStyle = _style;
819
820 if (_style == WidgetStyle::Popup)
821 {
822 //mIWidgetCreator->_unlinkChildWidget(this);
823 //mIWidgetCreator = _parent;
824 if (mParent == nullptr)
825 Gui::getInstance()._unlinkChildWidget(this);
826 else
827 mParent->_unlinkChildWidget(this);
828
829 mParent = _parent;
830 mParent->_linkChildWidget(this);
831
832 mCroppedParent = nullptr;
833
834 if (!_layer.empty())
835 {
836 LayerManager::getInstance().attachToLayerNode(_layer, this);
837 }
838 }
839 else if (_style == WidgetStyle::Child)
840 {
841 LayerManager::getInstance().detachFromLayer(this);
842
843 //mIWidgetCreator->_unlinkChildWidget(this);
844 //mIWidgetCreator = _parent;
845 if (mParent == nullptr)
846 Gui::getInstance()._unlinkChildWidget(this);
847 else
848 mParent->_unlinkChildWidget(this);
849
850 mParent = _parent;
851 mParent->_linkChildWidget(this);
852
853 mCroppedParent = _parent;
854 mAbsolutePosition = _parent->getAbsolutePosition() + mCoord.point();
855
856 for (VectorWidgetPtr::iterator widget = mWidgetChild.begin(); widget != mWidgetChild.end(); ++widget)
857 (*widget)->_updateAbsolutePoint();
858 for (VectorWidgetPtr::iterator widget = mWidgetChildSkin.begin(); widget != mWidgetChildSkin.end(); ++widget)
859 (*widget)->_updateAbsolutePoint();
860
861 mParent->addChildItem(this);
862
863 _updateView();
864 }
865 else if (_style == WidgetStyle::Overlapped)
866 {
867 LayerManager::getInstance().detachFromLayer(this);
868
869 //mIWidgetCreator->_unlinkChildWidget(this);
870 //mIWidgetCreator = _parent;
871 if (mParent == nullptr)
872 Gui::getInstance()._unlinkChildWidget(this);
873 else
874 mParent->_unlinkChildWidget(this);
875
876 mParent = _parent;
877 mParent->_linkChildWidget(this);
878
879 mCroppedParent = _parent;
880 mAbsolutePosition = _parent->getAbsolutePosition() + mCoord.point();
881
882 for (VectorWidgetPtr::iterator widget = mWidgetChild.begin(); widget != mWidgetChild.end(); ++widget)
883 (*widget)->_updateAbsolutePoint();
884 for (VectorWidgetPtr::iterator widget = mWidgetChildSkin.begin(); widget != mWidgetChildSkin.end(); ++widget)
885 (*widget)->_updateAbsolutePoint();
886
887 mParent->addChildNode(this);
888
889 _updateView();
890 }
891
892 _updateAlpha();
893 }
894
895 void Widget::setWidgetStyle(WidgetStyle _style, const std::string& _layer)
896 {
897 if (_style == mWidgetStyle)
898 return;
899 if (nullptr == getParent())
900 return;
901
902 Widget* parent = mParent;
903
904 detachFromWidget();
905 attachToWidget(parent, _style, _layer);
906 // ищем леер к которому мы присоедененны
907 }
908
909 Widget* Widget::createWidgetT(const std::string& _type, const std::string& _skin, const IntCoord& _coord, Align _align, const std::string& _name)
910 {
911 return baseCreateWidget(WidgetStyle::Child, _type, _skin, _coord, _align, "", _name, false);
912 }
913
914 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)
915 {
916 return createWidgetT(_type, _skin, IntCoord(_left, _top, _width, _height), _align, _name);
917 }
918
919 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)
920 {
921 return createWidgetRealT(_type, _skin, FloatCoord(_left, _top, _width, _height), _align, _name);
922 }
923
924 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)
925 {
926 return baseCreateWidget(_style, _type, _skin, _coord, _align, _layer, _name, false);
927 }
928
929 EnumeratorWidgetPtr Widget::getEnumerator() const
930 {
931 if (mWidgetClient != nullptr)
932 return mWidgetClient->getEnumerator();
933 return Enumerator<VectorWidgetPtr>(mWidgetChild.begin(), mWidgetChild.end());
934 }
935
936 size_t Widget::getChildCount() const
937 {
938 if (mWidgetClient != nullptr)
939 return mWidgetClient->getChildCount();
940 return mWidgetChild.size();
941 }
942
943 Widget* Widget::getChildAt(size_t _index) const
944 {
945 if (mWidgetClient != nullptr)
946 return mWidgetClient->getChildAt(_index);
947 MYGUI_ASSERT_RANGE(_index, mWidgetChild.size(), "Widget::getChildAt");
948 return mWidgetChild[_index];
949 }
950
951 void Widget::baseUpdateEnable()
952 {
953 if (getInheritedEnabled())
954 _setWidgetState("normal");
955 else
956 _setWidgetState("disabled");
957 }
958
959 void Widget::setVisible(bool _value)
960 {
961 if (mVisible == _value)
962 return;
963 mVisible = _value;
964
965 _updateVisible();
966 }
967
968 void Widget::_updateVisible()
969 {
970 mInheritedVisible = mParent == nullptr || mParent->getInheritedVisible();
971 mInheritedVisible = mVisible && mInheritedVisible;
972
973 _setSkinItemVisible(mInheritedVisible);
974
975 for (VectorWidgetPtr::iterator widget = mWidgetChild.begin(); widget != mWidgetChild.end(); ++widget)
976 (*widget)->_updateVisible();
977 for (VectorWidgetPtr::iterator widget = mWidgetChildSkin.begin(); widget != mWidgetChildSkin.end(); ++widget)
978 (*widget)->_updateVisible();
979
980 if (!mInheritedVisible && InputManager::getInstance().getMouseFocusWidget() == this)
981 InputManager::getInstance()._resetMouseFocusWidget();
982 if (!mInheritedVisible && InputManager::getInstance().getKeyFocusWidget() == this)
983 InputManager::getInstance().resetKeyFocusWidget();
984 }
985
986 void Widget::setEnabled(bool _value)
987 {
988 if (mEnabled == _value)
989 return;
990 mEnabled = _value;
991
992 _updateEnabled();
993 }
994
995 void Widget::_updateEnabled()
996 {
997 mInheritedEnabled = mParent == nullptr || (mParent->getInheritedEnabled());
998 mInheritedEnabled = mInheritedEnabled && mEnabled;
999
1000 for (VectorWidgetPtr::iterator iter = mWidgetChild.begin(); iter != mWidgetChild.end(); ++iter)
1001 (*iter)->_updateEnabled();
1002 for (VectorWidgetPtr::iterator iter = mWidgetChildSkin.begin(); iter != mWidgetChildSkin.end(); ++iter)
1003 (*iter)->_updateEnabled();
1004
1005 baseUpdateEnable();
1006
1007 if (!mInheritedEnabled)
1008 InputManager::getInstance().unlinkWidget(this);
1009 }
1010
1011 void Widget::setColour(const Colour& _value)
1012 {
1013 _setSkinItemColour(_value);
1014
1015 for (VectorWidgetPtr::iterator widget = mWidgetChildSkin.begin(); widget != mWidgetChildSkin.end(); ++widget)
1016 (*widget)->setColour(_value);
1017 }
1018
1019 IntSize Widget::getParentSize() const
1020 {
1021 if (mCroppedParent)
1022 return static_cast<Widget*>(mCroppedParent)->getSize();
1023 if (getLayer())
1024 return getLayer()->getSize();
1025
1026 return RenderManager::getInstance().getViewSize();
1027 }
1028
1029 void Widget::_resetContainer(bool _updateOnly)
1030 {
1031 if (getNeedToolTip())
1032 ToolTipManager::getInstance()._unlinkWidget(this);
1033 }
1034
1035 bool Widget::_checkPoint(int _left, int _top) const
1036 {
1037 return ! ((_getViewLeft() > _left) || (_getViewTop() > _top) || (_getViewRight() < _left) || (_getViewBottom() < _top));
1038 }
1039
1040 void Widget::_linkChildWidget(Widget* _widget)
1041 {
1042 VectorWidgetPtr::iterator iter = std::find(mWidgetChild.begin(), mWidgetChild.end(), _widget);
1043 MYGUI_ASSERT(iter == mWidgetChild.end(), "widget already exist");
1044 addWidget(_widget);
1045 }
1046
1047 void Widget::_unlinkChildWidget(Widget* _widget)
1048 {
1049 VectorWidgetPtr::iterator iter = std::remove(mWidgetChild.begin(), mWidgetChild.end(), _widget);
1050 MYGUI_ASSERT(iter != mWidgetChild.end(), "widget not found");
1051 mWidgetChild.erase(iter);
1052 }
1053
1054 void Widget::shutdownOverride()
1055 {
1056 }
1057
1058 void Widget::initialiseOverride()
1059 {
1061 assignWidget(mWidgetClient, "Client");
1062 }
1063
1064 void Widget::setSkinProperty(ResourceSkin* _info)
1065 {
1066 const MapString& properties = _info->getProperties();
1067 for (MapString::const_iterator item = properties.begin(); item != properties.end(); ++item)
1068 setProperty((*item).first, (*item).second);
1069 }
1070
1071 void Widget::setProperty(const std::string& _key, const std::string& _value)
1072 {
1073 std::string key = _key;
1074 std::string value = _value;
1075
1076 if (BackwardCompatibility::checkProperty(this, key, value))
1077 {
1078 size_t index = key.find("_");
1079 if (index != std::string::npos)
1080 {
1081 MYGUI_LOG(Warning, "Widget property '" << key << "' have type prefix - use '" << key.substr(index + 1) << "' instead [" << LayoutManager::getInstance().getCurrentLayout() << "]");
1082 key = key.substr(index + 1);
1083 }
1084
1085 setPropertyOverride(key, value);
1086 }
1087 }
1088
1089 VectorWidgetPtr Widget::getSkinWidgetsByName(const std::string& _name) const
1090 {
1091 VectorWidgetPtr result;
1092
1093 for (const auto& childSkin : mWidgetChildSkin)
1094 childSkin->findWidgets(_name, result);
1095
1096 return result;
1097 }
1098
1099 void Widget::findWidgets(const std::string& _name, VectorWidgetPtr& _result)
1100 {
1101 if (_name == mName)
1102 _result.push_back(this);
1103
1104 if (mWidgetClient != nullptr)
1105 {
1106 mWidgetClient->findWidgets(_name, _result);
1107 }
1108 else
1109 {
1110 for (VectorWidgetPtr::iterator widget = mWidgetChild.begin(); widget != mWidgetChild.end(); ++widget)
1111 (*widget)->findWidgets(_name, _result);
1112 }
1113 }
1114
1115 void Widget::onWidgetCreated(Widget* _widget)
1116 {
1117 }
1118
1119 void Widget::onWidgetDestroy(Widget* _widget)
1120 {
1121 }
1122
1123 void Widget::setWidgetClient(Widget* _widget)
1124 {
1125 MYGUI_ASSERT(mWidgetClient != this, "mWidgetClient can not be this widget");
1126 mWidgetClient = _widget;
1127 }
1128
1129 Widget* Widget::_getClientWidget()
1130 {
1131 return getClientWidget() == nullptr ? this : getClientWidget();
1132 }
1133
1134 const Widget* Widget::_getClientWidget() const
1135 {
1136 return getClientWidget() == nullptr ? this : getClientWidget();
1137 }
1138
1139 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)
1140 {
1141 return baseCreateWidget(_style, _type, _skin, _coord, _align, _layer, _name, true);
1142 }
1143
1144 void Widget::setPropertyOverride(const std::string& _key, const std::string& _value)
1145 {
1147 if (_key == "Position")
1148 setPosition(utility::parseValue<IntPoint>(_value));
1149
1151 else if (_key == "Size")
1152 setSize(utility::parseValue<IntSize>(_value));
1153
1155 else if (_key == "Coord")
1156 setCoord(utility::parseValue<IntCoord>(_value));
1157
1159 else if (_key == "Visible")
1160 setVisible(utility::parseValue<bool>(_value));
1161
1163 else if (_key == "Depth")
1164 setDepth(utility::parseValue<int>(_value));
1165
1167 else if (_key == "Alpha")
1168 setAlpha(utility::parseValue<float>(_value));
1169
1171 else if (_key == "Colour")
1172 setColour(utility::parseValue<Colour>(_value));
1173
1175 else if (_key == "InheritsAlpha")
1176 setInheritsAlpha(utility::parseValue<bool>(_value));
1177
1179 else if (_key == "InheritsPick")
1180 setInheritsPick(utility::parseValue<bool>(_value));
1181
1183 else if (_key == "MaskPick")
1184 setMaskPick(_value);
1185
1187 else if (_key == "NeedKey")
1188 setNeedKeyFocus(utility::parseValue<bool>(_value));
1189
1191 else if (_key == "NeedMouse")
1192 setNeedMouseFocus(utility::parseValue<bool>(_value));
1193
1195 else if (_key == "Enabled")
1196 setEnabled(utility::parseValue<bool>(_value));
1197
1199 else if (_key == "NeedToolTip")
1200 setNeedToolTip(utility::parseValue<bool>(_value));
1201
1203 else if (_key == "Pointer")
1204 setPointer(_value);
1205
1206 else
1207 {
1208 MYGUI_LOG(Warning, "Widget '" << getName() << "|" << getTypeName() << "' have unknown property '" << _key << "' " << " [" << LayoutManager::getInstance().getCurrentLayout() << "]");
1209 return;
1210 }
1211
1212 eventChangeProperty(this, _key, _value);
1213 }
1214
1215 void Widget::setPosition(int _left, int _top)
1216 {
1217 setPosition(IntPoint(_left, _top));
1218 }
1219
1220 void Widget::setSize(int _width, int _height)
1221 {
1222 setSize(IntSize(_width, _height));
1223 }
1224
1225 void Widget::setCoord(int _left, int _top, int _width, int _height)
1226 {
1227 setCoord(IntCoord(_left, _top, _width, _height));
1228 }
1229
1230 void Widget::setRealPosition(float _left, float _top)
1231 {
1232 setRealPosition(FloatPoint(_left, _top));
1233 }
1234
1235 void Widget::setRealSize(float _width, float _height)
1236 {
1237 setRealSize(FloatSize(_width, _height));
1238 }
1239
1240 void Widget::setRealCoord(float _left, float _top, float _width, float _height)
1241 {
1242 setRealCoord(FloatCoord(_left, _top, _width, _height));
1243 }
1244
1245 const std::string& Widget::getName() const
1246 {
1247 return mName;
1248 }
1249
1250 bool Widget::getVisible() const
1251 {
1252 return mVisible;
1253 }
1254
1255 Align Widget::getAlign() const
1256 {
1257 return mAlign;
1258 }
1259
1260 float Widget::getAlpha() const
1261 {
1262 return mAlpha;
1263 }
1264
1265 bool Widget::getInheritsAlpha() const
1266 {
1267 return mInheritsAlpha;
1268 }
1269
1270 bool Widget::isRootWidget() const
1271 {
1272 return nullptr == mCroppedParent;
1273 }
1274
1275 Widget* Widget::getParent() const
1276 {
1277 return mParent;
1278 }
1279
1280 void Widget::setEnabledSilent(bool _value)
1281 {
1282 mEnabled = _value;
1283 }
1284
1285 bool Widget::getEnabled() const
1286 {
1287 return mEnabled;
1288 }
1289
1290 Widget* Widget::getClientWidget()
1291 {
1292 return mWidgetClient;
1293 }
1294
1295 const Widget* Widget::getClientWidget() const
1296 {
1297 return mWidgetClient;
1298 }
1299
1300 WidgetStyle Widget::getWidgetStyle() const
1301 {
1302 return mWidgetStyle;
1303 }
1304
1305 size_t Widget::_getItemIndex(Widget* _item) const
1306 {
1307 return ITEM_NONE;
1308 }
1309
1310 void Widget::_setContainer(Widget* _value)
1311 {
1312 mContainer = _value;
1313 }
1314
1315 Widget* Widget::_getContainer() const
1316 {
1317 return mContainer;
1318 }
1319
1320 size_t Widget::_getContainerIndex(const IntPoint& _point) const
1321 {
1322 return ITEM_NONE;
1323 }
1324
1325 const IntCoord& Widget::getLayerItemCoord() const
1326 {
1327 return mCoord;
1328 }
1329
1330 float Widget::_getRealAlpha() const
1331 {
1332 return mRealAlpha;
1333 }
1334
1335 bool Widget::getInheritedEnabled() const
1336 {
1337 return mInheritedEnabled;
1338 }
1339
1340 bool Widget::getInheritedVisible() const
1341 {
1342 return mInheritedVisible;
1343 }
1344
1345 void Widget::resizeLayerItemView(const IntSize& _oldView, const IntSize& _newView)
1346 {
1347 _setAlign(_oldView, _newView);
1348 }
1349
1350 void Widget::setDepth(int _value)
1351 {
1352 if (mDepth == _value)
1353 return;
1354
1355 mDepth = _value;
1356
1357 if (mParent != nullptr)
1358 {
1359 mParent->_unlinkChildWidget(this);
1360 mParent->_linkChildWidget(this);
1361 mParent->_updateChilds();
1362 }
1363 }
1364
1365 int Widget::getDepth() const
1366 {
1367 return mDepth;
1368 }
1369
1370 void Widget::addWidget(Widget* _widget)
1371 {
1372 // сортировка глубины от большого к меньшему
1373
1374 int depth = _widget->getDepth();
1375
1376 for (size_t index = 0; index < mWidgetChild.size(); ++index)
1377 {
1378 Widget* widget = mWidgetChild[index];
1379 if (widget->getDepth() < depth)
1380 {
1381 mWidgetChild.insert(mWidgetChild.begin() + index, _widget);
1382 _updateChilds();
1383 return;
1384 }
1385 }
1386
1387 mWidgetChild.push_back(_widget);
1388 }
1389
1390 void Widget::_updateChilds()
1391 {
1392 for (VectorWidgetPtr::iterator widget = mWidgetChild.begin(); widget != mWidgetChild.end(); ++widget)
1393 {
1394 if ((*widget)->getWidgetStyle() == WidgetStyle::Child)
1395 {
1396 (*widget)->detachFromLayerItemNode(false);
1397 removeChildItem((*widget));
1398 }
1399 }
1400
1401 for (VectorWidgetPtr::iterator widget = mWidgetChild.begin(); widget != mWidgetChild.end(); ++widget)
1402 {
1403 if ((*widget)->getWidgetStyle() == WidgetStyle::Child)
1404 {
1405 addChildItem((*widget));
1406 (*widget)->_updateView();
1407 }
1408 }
1409 }
1410
1411} // namespace MyGUI
MyGUI_CoordConverter.h
MYGUI_ASSERT
#define MYGUI_ASSERT(exp, dest)
Definition MyGUI_Diagnostic.h:29
MYGUI_EXCEPT
#define MYGUI_EXCEPT(dest)
Definition MyGUI_Diagnostic.h:21
MYGUI_ASSERT_RANGE
#define MYGUI_ASSERT_RANGE(index, size, owner)
Definition MyGUI_Diagnostic.h:40
MYGUI_LOG
#define MYGUI_LOG(level, text)
Definition MyGUI_Diagnostic.h:17
MyGUI_FactoryManager.h
MyGUI_Gui.h
MyGUI_ISubWidget.h
MyGUI_ISubWidgetText.h
MyGUI_InputManager.h
MyGUI_LayerItem.h
MyGUI_LayerManager.h
MyGUI_LayoutManager.h
MyGUI_Precompiled.h
MyGUI_RenderItem.h
MyGUI_RenderManager.h
MyGUI_ResourceSkin.h
MyGUI_SkinManager.h
MyGUI_SubWidgetManager.h
MyGUI_TextBox.h
MyGUI_ToolTipManager.h
MyGUI_Widget.h
MyGUI_WidgetDefines.h
MyGUI_WidgetManager.h
MyGUI::Any::Null
static AnyEmpty Null
Definition MyGUI_Any.h:59
MyGUI::BackwardCompatibility::isIgnoreProperty
static bool isIgnoreProperty(const std::string &_key)
Definition MyGUI_BackwardCompatibility.cpp:1077
MyGUI::BackwardCompatibility::checkProperty
static bool checkProperty(Widget *_owner, std::string &_key, std::string &_value)
Definition MyGUI_BackwardCompatibility.cpp:1086
MyGUI::CoordConverter::convertFromRelative
static IntCoord convertFromRelative(const FloatCoord &_coord, const IntSize &_view)
Definition MyGUI_CoordConverter.h:33
MyGUI::Enumerator
Definition MyGUI_Enumerator.h:49
MyGUI::Gui::_unlinkChildWidget
void _unlinkChildWidget(Widget *_widget)
Definition MyGUI_Gui.cpp:277
MyGUI::Gui::_linkChildWidget
void _linkChildWidget(Widget *_widget)
Definition MyGUI_Gui.cpp:270
MyGUI::Gui::getInstance
static Gui & getInstance()
Definition MyGUI_Gui.cpp:34
MyGUI::ICroppedRectangle
Definition MyGUI_ICroppedRectangle.h:17
MyGUI::ICroppedRectangle::mIsMargin
bool mIsMargin
Definition MyGUI_ICroppedRectangle.h:248
MyGUI::ICroppedRectangle::mCoord
IntCoord mCoord
Definition MyGUI_ICroppedRectangle.h:245
MyGUI::ICroppedRectangle::mMargin
IntRect mMargin
Definition MyGUI_ICroppedRectangle.h:244
MyGUI::ICroppedRectangle::getAbsolutePosition
const IntPoint & getAbsolutePosition() const
Definition MyGUI_ICroppedRectangle.h:67
MyGUI::ICroppedRectangle::_checkMargin
bool _checkMargin()
Definition MyGUI_ICroppedRectangle.h:185
MyGUI::ICroppedRectangle::_checkOutside
bool _checkOutside() const
Definition MyGUI_ICroppedRectangle.h:235
MyGUI::ICroppedRectangle::mCroppedParent
ICroppedRectangle * mCroppedParent
Definition MyGUI_ICroppedRectangle.h:249
MyGUI::ICroppedRectangle::mAbsolutePosition
IntPoint mAbsolutePosition
Definition MyGUI_ICroppedRectangle.h:246
MyGUI::ICroppedRectangle::getCoord
const IntCoord & getCoord() const
Definition MyGUI_ICroppedRectangle.h:61
MyGUI::ICroppedRectangle::getSize
IntSize getSize() const
Definition MyGUI_ICroppedRectangle.h:56
MyGUI::ICroppedRectangle::_getViewRight
int _getViewRight() const
Definition MyGUI_ICroppedRectangle.h:137
MyGUI::ICroppedRectangle::_getViewLeft
int _getViewLeft() const
Definition MyGUI_ICroppedRectangle.h:133
MyGUI::ICroppedRectangle::_getViewTop
int _getViewTop() const
Definition MyGUI_ICroppedRectangle.h:141
MyGUI::ICroppedRectangle::_getViewBottom
int _getViewBottom() const
Definition MyGUI_ICroppedRectangle.h:145
MyGUI::ILayer::getName
const std::string & getName() const
Definition MyGUI_ILayer.h:29
MyGUI::ILayer::getSize
virtual const IntSize & getSize() const =0
MyGUI::ILayerItem
Definition MyGUI_ILayerItem.h:20
MyGUI::ILayerItem::getLayerItemByPoint
virtual ILayerItem * getLayerItemByPoint(int _left, int _top) const =0
MyGUI::InputManager::unlinkWidget
void unlinkWidget(Widget *_widget)
Definition MyGUI_InputManager.cpp:704
MyGUI::InputManager::resetKeyFocusWidget
void resetKeyFocusWidget(Widget *_widget)
Definition MyGUI_InputManager.cpp:609
MyGUI::InputManager::_resetMouseFocusWidget
void _resetMouseFocusWidget()
Definition MyGUI_InputManager.cpp:454
MyGUI::InputManager::getInstance
static InputManager & getInstance()
MyGUI::LayerItem::removeChildNode
void removeChildNode(LayerItem *_item)
Definition MyGUI_LayerItem.cpp:49
MyGUI::LayerItem::detachFromLayerItemNode
void detachFromLayerItemNode(bool _deep)
Definition MyGUI_LayerItem.cpp:166
MyGUI::LayerItem::addChildItem
void addChildItem(LayerItem *_item)
Definition MyGUI_LayerItem.cpp:22
MyGUI::LayerItem::addChildNode
void addChildNode(LayerItem *_item)
Definition MyGUI_LayerItem.cpp:38
MyGUI::LayerItem::removeChildItem
void removeChildItem(LayerItem *_item)
Definition MyGUI_LayerItem.cpp:31
MyGUI::LayerItem::getLayer
ILayer * getLayer() const
Definition MyGUI_LayerItem.cpp:206
MyGUI::LayerItem::restoreLayerItem
void restoreLayerItem()
Definition MyGUI_LayerItem.cpp:87
MyGUI::LayerItem::saveLayerItem
void saveLayerItem()
Definition MyGUI_LayerItem.cpp:82
MyGUI::LayerManager::detachFromLayer
void detachFromLayer(Widget *_item)
Definition MyGUI_LayerManager.cpp:147
MyGUI::LayerManager::getInstance
static LayerManager & getInstance()
MyGUI::LayerManager::attachToLayerNode
void attachToLayerNode(const std::string &_name, Widget *_item)
Definition MyGUI_LayerManager.cpp:124
MyGUI::LayoutManager::getCurrentLayout
const std::string & getCurrentLayout() const
Definition MyGUI_LayoutManager.cpp:105
MyGUI::LayoutManager::getInstance
static LayoutManager & getInstance()
MyGUI::LayoutManager::getByName
ResourceLayout * getByName(const std::string &_name, bool _throw=true) const
Definition MyGUI_LayoutManager.cpp:86
MyGUI::RenderManager::getViewSize
virtual const IntSize & getViewSize() const =0
MyGUI::RenderManager::getInstance
static RenderManager & getInstance()
MyGUI::ResourceLayout
Definition MyGUI_ResourceLayout.h:20
MyGUI::ResourceLayout::getLayoutData
const VectorWidgetInfo & getLayoutData() const
Definition MyGUI_ResourceLayout.cpp:185
MyGUI::ResourceLayout::createWidget
Widget * createWidget(const WidgetInfo &_widgetInfo, const std::string &_prefix="", Widget *_parent=nullptr, bool _template=false)
Definition MyGUI_ResourceLayout.cpp:114
MyGUI::ResourceSkin
Definition MyGUI_ResourceSkin.h:23
MyGUI::ResourceSkin::getSize
const IntSize & getSize() const
Definition MyGUI_ResourceSkin.cpp:265
MyGUI::ResourceSkin::getProperties
const MapString & getProperties() const
Definition MyGUI_ResourceSkin.cpp:285
MyGUI::ResourceSkin::getChild
const VectorChildSkinInfo & getChild() const
Definition MyGUI_ResourceSkin.cpp:290
MyGUI::SkinItem::_correctSkinItemView
void _correctSkinItemView()
Definition MyGUI_SkinItem.cpp:52
MyGUI::SkinItem::_setSkinItemAlpha
void _setSkinItemAlpha(float _value)
Definition MyGUI_SkinItem.cpp:46
MyGUI::SkinItem::_createSkinItem
void _createSkinItem(ResourceSkin *_info)
Definition MyGUI_SkinItem.cpp:80
MyGUI::SkinItem::_setSkinItemColour
void _setSkinItemColour(const Colour &_value)
Definition MyGUI_SkinItem.cpp:36
MyGUI::SkinItem::_deleteSkinItem
void _deleteSkinItem()
Definition MyGUI_SkinItem.cpp:117
MyGUI::SkinItem::_setSkinItemState
bool _setSkinItemState(const std::string &_state)
Definition MyGUI_SkinItem.cpp:64
MyGUI::SkinItem::_updateSkinItemView
void _updateSkinItemView()
Definition MyGUI_SkinItem.cpp:58
MyGUI::SkinItem::_setSubSkinVisible
void _setSubSkinVisible(bool _visible)
Definition MyGUI_SkinItem.cpp:146
MyGUI::SkinItem::_setSkinItemAlign
void _setSkinItemAlign(const IntSize &_size)
Definition MyGUI_SkinItem.cpp:24
MyGUI::SkinItem::_setSkinItemVisible
void _setSkinItemVisible(bool _value)
Definition MyGUI_SkinItem.cpp:30
MyGUI::SkinManager::getInstance
static SkinManager & getInstance()
MyGUI::SkinManager::getByName
ResourceSkin * getByName(const std::string &_name) const
Definition MyGUI_SkinManager.cpp:80
MyGUI::ToolTipManager::getInstance
static ToolTipManager & getInstance()
MyGUI::ToolTipManager::_unlinkWidget
void _unlinkWidget(Widget *_widget) override
Definition MyGUI_ToolTipManager.cpp:136
MyGUI::UserData::setUserData
void setUserData(Any _data)
Definition MyGUI_WidgetUserData.cpp:54
MyGUI::UserData::setUserString
void setUserString(const std::string &_key, const std::string &_value)
Definition MyGUI_WidgetUserData.cpp:14
MyGUI::Widget
widget description should be here.
Definition MyGUI_Widget.h:37
MyGUI::Widget::getParent
Widget * getParent() const
Definition MyGUI_Widget.cpp:1275
MyGUI::Widget::attachToWidget
void attachToWidget(Widget *_parent, WidgetStyle _style=WidgetStyle::Child, const std::string &_layer="")
Definition MyGUI_Widget.cpp:798
MyGUI::Widget::detachFromWidget
void detachFromWidget(const std::string &_layer="")
Definition MyGUI_Widget.cpp:736
MyGUI::Widget::getInheritedEnabled
bool getInheritedEnabled() const
Definition MyGUI_Widget.cpp:1335
MyGUI::Widget::_destroyAllChildWidget
void _destroyAllChildWidget()
Definition MyGUI_Widget.cpp:410
MyGUI::Widget::setCoord
void setCoord(const IntCoord &_value) override
Definition MyGUI_Widget.cpp:686
MyGUI::Widget::getSkinWidgetsByName
VectorWidgetPtr getSkinWidgetsByName(const std::string &_name) const
Definition MyGUI_Widget.cpp:1089
MyGUI::Widget::setAlpha
void setAlpha(float _value)
Definition MyGUI_Widget.cpp:434
MyGUI::Widget::createWidgetT
Widget * createWidgetT(const std::string &_type, const std::string &_skin, const IntCoord &_coord, Align _align, const std::string &_name="")
Definition MyGUI_Widget.cpp:909
MyGUI::Widget::getLayerItemByPoint
ILayerItem * getLayerItemByPoint(int _left, int _top) const override
Definition MyGUI_Widget.cpp:464
MyGUI::Widget::setProperty
void setProperty(const std::string &_key, const std::string &_value)
Definition MyGUI_Widget.cpp:1071
MyGUI::Widget::_checkPoint
bool _checkPoint(int _left, int _top) const
Definition MyGUI_Widget.cpp:1035
MyGUI::Widget::_destroyChildWidget
void _destroyChildWidget(Widget *_widget)
Definition MyGUI_Widget.cpp:379
MyGUI::Widget::onWidgetDestroy
virtual void onWidgetDestroy(Widget *_widget)
Definition MyGUI_Widget.cpp:1119
MyGUI::Widget::eventChangeProperty
EventHandle_WidgetStringString eventChangeProperty
Definition MyGUI_Widget.h:268
MyGUI::Widget::_setWidgetState
bool _setWidgetState(const std::string &_value)
Definition MyGUI_Widget.cpp:374
MyGUI::Widget::setWidgetStyle
void setWidgetStyle(WidgetStyle _style, const std::string &_layer="")
Definition MyGUI_Widget.cpp:895
MyGUI::Widget::assignWidget
void assignWidget(T *&_widget, const std::string &_name)
Definition MyGUI_Widget.h:336
MyGUI::Widget::initialiseOverride
virtual void initialiseOverride()
Definition MyGUI_Widget.cpp:1058
MyGUI::Widget::findWidget
Widget * findWidget(const std::string &_name)
Definition MyGUI_Widget.cpp:537
MyGUI::Widget::getChildCount
size_t getChildCount() const
Definition MyGUI_Widget.cpp:936
MyGUI::Widget::getName
const std::string & getName() const
Get name of widget.
Definition MyGUI_Widget.cpp:1245
MyGUI::Widget::getChildAt
Widget * getChildAt(size_t _index) const
Definition MyGUI_Widget.cpp:943
MyGUI::Widget::_shutdown
void _shutdown()
Definition MyGUI_Widget.cpp:123
MyGUI::Widget::setVisible
virtual void setVisible(bool _value)
Definition MyGUI_Widget.cpp:959
MyGUI::Widget::getEnabled
bool getEnabled() const
Definition MyGUI_Widget.cpp:1285
MyGUI::Widget::setRealPosition
void setRealPosition(const FloatPoint &_value)
Definition MyGUI_Widget.cpp:553
MyGUI::Widget::_setAlign
void _setAlign(const IntSize &_oldsize, const IntSize &_newSize)
Definition MyGUI_Widget.cpp:568
MyGUI::Widget::baseUpdateEnable
virtual void baseUpdateEnable()
Definition MyGUI_Widget.cpp:951
MyGUI::Widget::setEnabled
virtual void setEnabled(bool _value)
Definition MyGUI_Widget.cpp:986
MyGUI::Widget::setPosition
void setPosition(const IntPoint &_value) override
Definition MyGUI_Widget.cpp:632
MyGUI::Widget::_createSkinWidget
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="")
Definition MyGUI_Widget.cpp:1139
MyGUI::Widget::getLayerItemCoord
const IntCoord & getLayerItemCoord() const override
Definition MyGUI_Widget.cpp:1325
MyGUI::Widget::getParentSize
IntSize getParentSize() const
Definition MyGUI_Widget.cpp:1019
MyGUI::Widget::setRealCoord
void setRealCoord(const FloatCoord &_value)
Definition MyGUI_Widget.cpp:563
MyGUI::Widget::getVisible
bool getVisible() const
Definition MyGUI_Widget.cpp:1250
MyGUI::Widget::setInheritsAlpha
void setInheritsAlpha(bool _value)
Definition MyGUI_Widget.cpp:458
MyGUI::Widget::setSize
void setSize(const IntSize &_value) override
Definition MyGUI_Widget.cpp:649
MyGUI::Widget::setDepth
void setDepth(int _value)
Definition MyGUI_Widget.cpp:1350
MyGUI::Widget::getClientWidget
Widget * getClientWidget()
Definition MyGUI_Widget.cpp:1290
MyGUI::Widget::getClientCoord
IntCoord getClientCoord() const
Definition MyGUI_Widget.cpp:427
MyGUI::Widget::isRootWidget
bool isRootWidget() const
Definition MyGUI_Widget.cpp:1270
MyGUI::Widget::getAlign
Align getAlign() const
Definition MyGUI_Widget.cpp:1255
MyGUI::Widget::eventChangeCoord
EventHandle_WidgetVoid eventChangeCoord
Definition MyGUI_Widget.h:274
MyGUI::Widget::onWidgetCreated
virtual void onWidgetCreated(Widget *_widget)
Definition MyGUI_Widget.cpp:1115
MyGUI::Widget::setAlign
virtual void setAlign(Align _value)
Definition MyGUI_Widget.cpp:731
MyGUI::Widget::_initialise
void _initialise(WidgetStyle _style, const IntCoord &_coord, const std::string &_skinName, Widget *_parent, ICroppedRectangle *_croppedParent, const std::string &_name)
Definition MyGUI_Widget.cpp:48
MyGUI::Widget::getDepth
int getDepth() const
Definition MyGUI_Widget.cpp:1365
MyGUI::Widget::changeWidgetSkin
void changeWidgetSkin(const std::string &_skinName)
Definition MyGUI_Widget.cpp:154
MyGUI::Widget::_resetContainer
virtual void _resetContainer(bool _update)
Definition MyGUI_Widget.cpp:1029
MyGUI::Widget::getWidgetStyle
WidgetStyle getWidgetStyle() const
Definition MyGUI_Widget.cpp:1300
MyGUI::Widget::getInheritsAlpha
bool getInheritsAlpha() const
Definition MyGUI_Widget.cpp:1265
MyGUI::Widget::setWidgetClient
void setWidgetClient(Widget *_widget)
Definition MyGUI_Widget.cpp:1123
MyGUI::Widget::getAlpha
float getAlpha() const
Definition MyGUI_Widget.cpp:1260
MyGUI::Widget::setColour
void setColour(const Colour &_value)
Definition MyGUI_Widget.cpp:1011
MyGUI::Widget::_getContainer
Widget * _getContainer() const
Definition MyGUI_Widget.cpp:1315
MyGUI::Widget::setPropertyOverride
virtual void setPropertyOverride(const std::string &_key, const std::string &_value)
Definition MyGUI_Widget.cpp:1144
MyGUI::Widget::_setContainer
void _setContainer(Widget *_value)
Definition MyGUI_Widget.cpp:1310
MyGUI::Widget::_getContainerIndex
virtual size_t _getContainerIndex(const IntPoint &_point) const
Definition MyGUI_Widget.cpp:1320
MyGUI::Widget::setRealSize
void setRealSize(const FloatSize &_value)
Definition MyGUI_Widget.cpp:558
MyGUI::Widget::_updateView
void _updateView()
Definition MyGUI_Widget.cpp:327
MyGUI::Widget::_forcePick
void _forcePick(Widget *_widget)
Definition MyGUI_Widget.cpp:515
MyGUI::Widget::getTypeName
virtual const std::string & getTypeName() const override
Definition MyGUI_Widget.h:41
MyGUI::Widget::createWidgetRealT
Widget * createWidgetRealT(const std::string &_type, const std::string &_skin, const FloatCoord &_coord, Align _align, const std::string &_name="")
Definition MyGUI_Widget.cpp:322
MyGUI::Widget::eventWidgetDestroyed
EventHandle_WidgetVoid eventWidgetDestroyed
Definition MyGUI_Widget.h:280
MyGUI::Widget::findWidgets
void findWidgets(const std::string &_name, VectorWidgetPtr &_result)
Definition MyGUI_Widget.cpp:1099
MyGUI::Widget::_getItemIndex
virtual size_t _getItemIndex(Widget *_item) const
Definition MyGUI_Widget.cpp:1305
MyGUI::Widget::shutdownOverride
virtual void shutdownOverride()
Definition MyGUI_Widget.cpp:1054
MyGUI::Widget::_updateChilds
void _updateChilds()
Definition MyGUI_Widget.cpp:1390
MyGUI::Widget::Widget
Widget()
Definition MyGUI_Widget.cpp:31
MyGUI::Widget::setEnabledSilent
void setEnabledSilent(bool _value)
Definition MyGUI_Widget.cpp:1280
MyGUI::Widget::getEnumerator
EnumeratorWidgetPtr getEnumerator() const
Definition MyGUI_Widget.cpp:929
MyGUI::Widget::_getClientWidget
Widget * _getClientWidget()
If there is client widget return it, otherwise return this.
Definition MyGUI_Widget.cpp:1129
MyGUI::Widget::baseCreateWidget
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)
Definition MyGUI_Widget.cpp:287
MyGUI::Widget::getInheritedVisible
bool getInheritedVisible() const
Definition MyGUI_Widget.cpp:1340
MyGUI::WidgetInput::setPointer
void setPointer(const std::string &_value)
Definition MyGUI_WidgetInput.cpp:142
MyGUI::WidgetInput::getInheritsPick
bool getInheritsPick() const
Definition MyGUI_WidgetInput.cpp:177
MyGUI::WidgetInput::setNeedMouseFocus
void setNeedMouseFocus(bool _value)
Definition MyGUI_WidgetInput.cpp:162
MyGUI::WidgetInput::setMaskPick
void setMaskPick(const std::string &_filename)
Definition MyGUI_WidgetInput.cpp:24
MyGUI::WidgetInput::setNeedKeyFocus
void setNeedKeyFocus(bool _value)
Definition MyGUI_WidgetInput.cpp:152
MyGUI::WidgetInput::getNeedToolTip
bool getNeedToolTip() const
Definition MyGUI_WidgetInput.cpp:137
MyGUI::WidgetInput::getNeedMouseFocus
bool getNeedMouseFocus() const
Definition MyGUI_WidgetInput.cpp:167
MyGUI::WidgetInput::isMaskPickInside
bool isMaskPickInside(const IntPoint &_point, const IntCoord &_coord) const
Definition MyGUI_WidgetInput.cpp:37
MyGUI::WidgetInput::setInheritsPick
void setInheritsPick(bool _value)
Definition MyGUI_WidgetInput.cpp:172
MyGUI::WidgetInput::setNeedToolTip
void setNeedToolTip(bool _value)
Definition MyGUI_WidgetInput.cpp:132
MyGUI::WidgetManager
Definition MyGUI_WidgetManager.h:22
MyGUI::WidgetManager::createWidget
Widget * createWidget(WidgetStyle _style, const std::string &_type, const std::string &_skin, const IntCoord &_coord, Widget *_parent, ICroppedRectangle *_cropeedParent, const std::string &_name)
Definition MyGUI_WidgetManager.cpp:104
MyGUI::WidgetManager::getInstance
static WidgetManager & getInstance()
MyGUI::WidgetManager::_deleteWidget
void _deleteWidget(Widget *_widget)
Definition MyGUI_WidgetManager.cpp:169
MyGUI::WidgetManager::unlinkFromUnlinkers
void unlinkFromUnlinkers(Widget *_widget)
Definition MyGUI_WidgetManager.cpp:146
MyGUI::utility::parseValue
T parseValue(const std::string &_value)
Definition MyGUI_StringUtility.h:112
MyGUI
Definition MyGUI_ActionController.h:15
MyGUI::IntPoint
types::TPoint< int > IntPoint
Definition MyGUI_Types.h:27
MyGUI::FloatCoord
types::TCoord< float > FloatCoord
Definition MyGUI_Types.h:37
MyGUI::MapString
std::map< std::string, std::string > MapString
Definition MyGUI_Types.h:40
MyGUI::FloatPoint
types::TPoint< float > FloatPoint
Definition MyGUI_Types.h:28
MyGUI::VectorWidgetInfo
std::vector< WidgetInfo > VectorWidgetInfo
Definition MyGUI_LayoutData.h:51
MyGUI::FloatSize
types::TSize< float > FloatSize
Definition MyGUI_Types.h:31
MyGUI::VectorChildSkinInfo
std::vector< ChildSkinInfo > VectorChildSkinInfo
Definition MyGUI_ChildSkinInfo.h:33
MyGUI::IntCoord
types::TCoord< int > IntCoord
Definition MyGUI_Types.h:36
MyGUI::IntSize
types::TSize< int > IntSize
Definition MyGUI_Types.h:30
MyGUI::ALPHA_MAX
const float ALPHA_MAX
Definition MyGUI_Macros.h:20
MyGUI::ITEM_NONE
const size_t ITEM_NONE
Definition MyGUI_Macros.h:18
MyGUI::VectorWidgetPtr
std::vector< Widget * > VectorWidgetPtr
Definition MyGUI_WidgetDefines.h:20
MyGUI::Align
Definition MyGUI_Align.h:20
MyGUI::Align::isHStretch
bool isHStretch() const
Definition MyGUI_Align.h:69
MyGUI::Align::isVCenter
bool isVCenter() const
Definition MyGUI_Align.h:49
MyGUI::Align::Default
@ Default
Definition MyGUI_Align.h:36
MyGUI::Align::isVStretch
bool isVStretch() const
Definition MyGUI_Align.h:84
MyGUI::Align::isRight
bool isRight() const
Definition MyGUI_Align.h:64
MyGUI::Align::isHCenter
bool isHCenter() const
Definition MyGUI_Align.h:44
MyGUI::Align::isBottom
bool isBottom() const
Definition MyGUI_Align.h:79
MyGUI::Colour
Definition MyGUI_Colour.h:17
MyGUI::WidgetInfo
Definition MyGUI_LayoutData.h:23
MyGUI::WidgetInfo::userStrings
MapString userStrings
Definition MyGUI_LayoutData.h:36
MyGUI::WidgetInfo::properties
VectorStringPairs properties
Definition MyGUI_LayoutData.h:35
MyGUI::WidgetInfo::intCoord
IntCoord intCoord
Definition MyGUI_LayoutData.h:47
MyGUI::WidgetInfo::childWidgetsInfo
std::vector< WidgetInfo > childWidgetsInfo
Definition MyGUI_LayoutData.h:33
MyGUI::WidgetStyle
Definition MyGUI_WidgetStyle.h:19
MyGUI::WidgetStyle::Popup
@ Popup
Definition MyGUI_WidgetStyle.h:23
MyGUI::WidgetStyle::Child
@ Child
Definition MyGUI_WidgetStyle.h:22
MyGUI::WidgetStyle::Overlapped
@ Overlapped
Definition MyGUI_WidgetStyle.h:24
MyGUI::types::TCoord< int >
MyGUI::types::TCoord::height
T height
Definition MyGUI_TCoord.h:25
MyGUI::types::TCoord::width
T width
Definition MyGUI_TCoord.h:24
MyGUI::types::TCoord::top
T top
Definition MyGUI_TCoord.h:23
MyGUI::types::TCoord::point
TPoint< T > point() const
Definition MyGUI_TCoord.h:185
MyGUI::types::TCoord::size
TSize< T > size() const
Definition MyGUI_TCoord.h:190
MyGUI::types::TCoord::left
T left
Definition MyGUI_TCoord.h:22
MyGUI::types::TPoint< float >
MyGUI::types::TRect::clear
void clear()
Definition MyGUI_TRect.h:116
MyGUI::types::TSize
Definition MyGUI_TSize.h:19
MyGUI::types::TSize::width
T width
Definition MyGUI_TSize.h:20
MyGUI::types::TSize::height
T height
Definition MyGUI_TSize.h:21