00001
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023 #include "MyGUI_Precompiled.h"
00024 #include "MyGUI_MenuCtrl.h"
00025 #include "MyGUI_ResourceSkin.h"
00026 #include "MyGUI_MenuItem.h"
00027 #include "MyGUI_StaticImage.h"
00028 #include "MyGUI_MenuBar.h"
00029 #include "MyGUI_WidgetManager.h"
00030 #include "MyGUI_LayerManager.h"
00031 #include "MyGUI_ControllerManager.h"
00032 #include "MyGUI_InputManager.h"
00033 #include "MyGUI_Gui.h"
00034
00035 namespace MyGUI
00036 {
00037
00038 const float POPUP_MENU_SPEED_COEF = 3.0f;
00039
00040 MenuCtrl::MenuCtrl() :
00041 mHideByAccept(true),
00042 mMenuDropMode(false),
00043 mIsMenuDrop(true),
00044 mHideByLostKey(false),
00045 mHeightLine(1),
00046 mSubmenuImageSize(0),
00047 mShutdown(false),
00048 mSeparatorHeight(0),
00049 mAlignVert(true),
00050 mDistanceButton(0),
00051 mPopupAccept(false),
00052 mOwner(nullptr),
00053 mAnimateSmooth(false)
00054 {
00055 }
00056
00057 void MenuCtrl::_initialise(WidgetStyle _style, const IntCoord& _coord, Align _align, ResourceSkin* _info, Widget* _parent, ICroppedRectangle * _croppedParent, IWidgetCreator * _creator, const std::string& _name)
00058 {
00059 Base::_initialise(_style, _coord, _align, _info, _parent, _croppedParent, _creator, _name);
00060
00061
00062 Widget* parent = getParent();
00063 if (parent)
00064 {
00065 mOwner = parent->castType<MenuItem>(false);
00066 if ( ! mOwner )
00067 {
00068 Widget* client = parent;
00069 parent = client->getParent();
00070 if (parent && parent->getClientWidget())
00071 {
00072 mOwner = parent->castType<MenuItem>(false);
00073 }
00074 }
00075 }
00076
00077 initialiseWidgetSkin(_info);
00078 }
00079
00080 MenuCtrl::~MenuCtrl()
00081 {
00082 mShutdown = true;
00083 shutdownWidgetSkin();
00084 }
00085
00086 void MenuCtrl::baseChangeWidgetSkin(ResourceSkin* _info)
00087 {
00088 shutdownWidgetSkin();
00089 Base::baseChangeWidgetSkin(_info);
00090 initialiseWidgetSkin(_info);
00091 }
00092
00093 void MenuCtrl::initialiseWidgetSkin(ResourceSkin* _info)
00094 {
00095
00096 mNeedKeyFocus = true;
00097
00098 for (VectorWidgetPtr::iterator iter=mWidgetChildSkin.begin(); iter!=mWidgetChildSkin.end(); ++iter)
00099 {
00100 if (*(*iter)->_getInternalData<std::string>() == "Client")
00101 {
00102 MYGUI_DEBUG_ASSERT( ! mWidgetClient, "widget already assigned");
00103 mWidgetClient = (*iter);
00104 }
00105 }
00106
00107
00108
00109 const MapString& properties = _info->getProperties();
00110 MapString::const_iterator iterS = properties.find("SkinLine");
00111 if (iterS != properties.end()) mSkinLine = iterS->second;
00112
00113
00114 iterS = properties.find("HeightLine");
00115 if (iterS != properties.end()) mHeightLine = utility::parseInt(iterS->second);
00116 if (mHeightLine < 1)
00117 {
00118 MYGUI_LOG(Warning, "MenuCtrl HeightLine can't be less thah 1. Set to 1.");
00119 mHeightLine = 1;
00120 }
00121
00122 iterS = properties.find("SeparatorHeight");
00123 if (iterS != properties.end()) mSeparatorHeight = utility::parseInt(iterS->second);
00124 iterS = properties.find("SeparatorSkin");
00125 if (iterS != properties.end()) mSeparatorSkin = iterS->second;
00126
00127 iterS = properties.find("SubmenuImageSize");
00128 if (iterS != properties.end()) mSubmenuImageSize = utility::parseInt(iterS->second);
00129
00130 iterS = properties.find("SubMenuSkin");
00131 if (iterS != properties.end()) mSubMenuSkin = iterS->second;
00132
00133
00134 iterS = properties.find("SubMenuLayer");
00135 if (iterS != properties.end()) mSubMenuLayer = iterS->second;
00136
00137
00138 iterS = properties.find("AlignVert");
00139 if (iterS != properties.end()) mAlignVert = utility::parseBool(iterS->second);
00140 iterS = properties.find("DistanceButton");
00141 if (iterS != properties.end()) mDistanceButton = utility::parseInt(iterS->second);
00142
00143 if (mSeparatorHeight < 1) mSeparatorHeight = mHeightLine;
00144 }
00145
00146 void MenuCtrl::shutdownWidgetSkin()
00147 {
00148 mWidgetClient = nullptr;
00149 }
00150
00151 Widget* MenuCtrl::baseCreateWidget(WidgetStyle _style, const std::string& _type, const std::string& _skin, const IntCoord& _coord, Align _align, const std::string& _layer, const std::string& _name)
00152 {
00153 Widget* widget = nullptr;
00154 if (mWidgetClient != nullptr)
00155 widget = mWidgetClient->createWidgetT(_style, _type, _skin, _coord, _align, _layer, _name);
00156 else
00157 widget = Base::baseCreateWidget(_style, _type, _skin, _coord, _align, _layer, _name);
00158
00159 MenuItem* child = widget->castType<MenuItem>(false);
00160 if (child)
00161 {
00162 _wrapItem(child, mItemsInfo.size(), "", MenuItemType::Normal, "", Any::Null);
00163 }
00164 return widget;
00165 }
00166
00167 MenuItem* MenuCtrl::insertItemAt(size_t _index, const UString& _name, MenuItemType _type, const std::string& _id, Any _data)
00168 {
00169 MYGUI_ASSERT_RANGE_INSERT(_index, mItemsInfo.size(), "MenuCtrl::insertItemAt");
00170 if (_index == ITEM_NONE) _index = mItemsInfo.size();
00171
00172 MenuItem* item = _getClientWidget()->createWidget<MenuItem>(getSkinByType(_type), IntCoord(), Align::Default);
00173 _wrapItem(item, _index, _name, _type, _id, _data);
00174
00175 return item;
00176 }
00177
00178 void MenuCtrl::removeItemAt(size_t _index)
00179 {
00180 MYGUI_ASSERT_RANGE(_index, mItemsInfo.size(), "MenuCtrl::removeItemAt");
00181
00182 if ( mItemsInfo[_index].submenu )
00183 {
00184 WidgetManager::getInstance().destroyWidget(mItemsInfo[_index].submenu);
00185 }
00186 WidgetManager::getInstance().destroyWidget(mItemsInfo[_index].item);
00187 }
00188
00189 void MenuCtrl::removeAllItems()
00190 {
00191 while (mItemsInfo.size() > 0)
00192 {
00193 if ( mItemsInfo.back().submenu )
00194 {
00195 WidgetManager::getInstance().destroyWidget(mItemsInfo.back().submenu);
00196 }
00197 WidgetManager::getInstance().destroyWidget(mItemsInfo.back().item);
00198 }
00199 }
00200
00201 const UString& MenuCtrl::getItemNameAt(size_t _index)
00202 {
00203 MYGUI_ASSERT_RANGE(_index, mItemsInfo.size(), "MenuCtrl::getItemNameAt");
00204 return mItemsInfo[_index].name;
00205 }
00206
00207 void MenuCtrl::setButtonImageIndex(Button* _button, size_t _index)
00208 {
00209 StaticImage* image = _button->getStaticImage();
00210 if ( nullptr == image ) return;
00211 if (image->getItemResource())
00212 {
00213 static const size_t CountIcons = 2;
00214 static const char * IconNames[CountIcons + 1] = { "None", "Popup", "" };
00215 if (_index >= CountIcons) _index = CountIcons;
00216 image->setItemName(IconNames[_index]);
00217 }
00218 else
00219 {
00220 image->setItemSelect(_index);
00221 }
00222 }
00223
00224 void MenuCtrl::update()
00225 {
00226 IntSize size;
00227
00228 if (mAlignVert)
00229 {
00230 for (VectorMenuItemInfo::iterator iter=mItemsInfo.begin(); iter!=mItemsInfo.end(); ++iter)
00231 {
00232 int height = iter->type == MenuItemType::Separator ? mSeparatorHeight : mHeightLine;
00233 iter->item->setCoord(0, size.height, _getClientWidget()->getWidth(), height);
00234 size.height += height + mDistanceButton;
00235
00236 int width = iter->width;
00237 if (width > size.width) size.width = width;
00238 }
00239
00240 }
00241 else
00242 {
00243 for (VectorMenuItemInfo::iterator iter=mItemsInfo.begin(); iter!=mItemsInfo.end(); ++iter)
00244 {
00245 int width = iter->type == MenuItemType::Separator ? mSeparatorHeight : iter->width;
00246 iter->item->setCoord(size.width, 0, width, mHeightLine);
00247 size.width += width + mDistanceButton;
00248 }
00249 size.height = mHeightLine;
00250 size.width = mCoord.width;
00251 }
00252
00253 setSize(size + mCoord.size() - _getClientWidget()->getSize());
00254 }
00255
00256 void MenuCtrl::setItemDataAt(size_t _index, Any _data)
00257 {
00258 MYGUI_ASSERT_RANGE(_index, mItemsInfo.size(), "MenuCtrl::setItemDataAt");
00259 mItemsInfo[_index].data = _data;
00260 }
00261
00262 MenuCtrl* MenuCtrl::getItemChildAt(size_t _index)
00263 {
00264 MYGUI_ASSERT_RANGE(_index, mItemsInfo.size(), "MenuCtrl::getItemChildAt");
00265 return mItemsInfo[_index].submenu;
00266 }
00267
00268 void MenuCtrl::removeItemChildAt(size_t _index)
00269 {
00270 MYGUI_ASSERT_RANGE(_index, mItemsInfo.size(), "MenuCtrl::removeItemChildAt");
00271
00272 if (mItemsInfo[_index].submenu != nullptr)
00273 {
00274 WidgetManager::getInstance().destroyWidget(mItemsInfo[_index].submenu);
00275 mItemsInfo[_index].submenu = nullptr;
00276 }
00277
00278 update();
00279 }
00280
00281 void MenuCtrl::setItemNameAt(size_t _index, const UString& _name)
00282 {
00283 MYGUI_ASSERT_RANGE(_index, mItemsInfo.size(), "MenuCtrl::setItemNameAt");
00284
00285 mItemsInfo[_index].name = _name;
00286 MenuItem* item = mItemsInfo[_index].item;
00287 item->setCaption(_name);
00288
00289 update();
00290 }
00291
00292 void MenuCtrl::setItemIdAt(size_t _index, const std::string& _id)
00293 {
00294 MYGUI_ASSERT_RANGE(_index, mItemsInfo.size(), "MenuCtrl::setItemIdAt");
00295 mItemsInfo[_index].id = _id;
00296 }
00297
00298 const std::string& MenuCtrl::getItemIdAt(size_t _index)
00299 {
00300 MYGUI_ASSERT_RANGE(_index, mItemsInfo.size(), "MenuCtrl::getItemIdAt");
00301 return mItemsInfo[_index].id;
00302 }
00303
00304 void MenuCtrl::_notifyDeleteItem(MenuItem* _item)
00305 {
00306
00307 if (mShutdown) return;
00308
00309 size_t index = getItemIndex(_item);
00310 mItemsInfo.erase(mItemsInfo.begin() + index);
00311 update();
00312 }
00313
00314 void MenuCtrl::_notifyUpdateName(MenuItem* _item)
00315 {
00316 size_t index = getItemIndex(_item);
00317 mItemsInfo[index].name = _item->getCaption();
00318
00319 ISubWidgetText* text = _item->getSubWidgetText();
00320 mItemsInfo[index].width = text ? (text->getTextSize().width + _item->getSize().width - text->getWidth()) : 0;
00321 update();
00322 }
00323
00324 MenuItemType MenuCtrl::getItemTypeAt(size_t _index)
00325 {
00326 MYGUI_ASSERT_RANGE(_index, mItemsInfo.size(), "MenuCtrl::getItemTypeAt");
00327 return mItemsInfo[_index].type;
00328 }
00329
00330 void MenuCtrl::setItemTypeAt(size_t _index, MenuItemType _type)
00331 {
00332 MYGUI_ASSERT_RANGE(_index, mItemsInfo.size(), "MenuCtrl::setItemTypeAt");
00333 ItemInfo& info = mItemsInfo[_index];
00334 if (info.type == _type) return;
00335
00336
00337 info.type = _type;
00338 info.item->changeWidgetSkin(getSkinByType(_type));
00339 setButtonImageIndex(info.item, getIconIndexByType(_type ));
00340 info.item->setCaption(info.name);
00341
00342 update();
00343 }
00344
00345 void MenuCtrl::notifyMenuCtrlAccept(MenuItem* _item)
00346 {
00347 Widget* sender = this;
00348
00349 WidgetManager::getInstance().addWidgetToUnlink(sender);
00350 eventMenuCtrlAccept(this, _item);
00351 WidgetManager::getInstance().removeWidgetFromUnlink(sender);
00352
00353
00354 if (sender == nullptr) return;
00355
00356 WidgetManager::getInstance().addWidgetToUnlink(sender);
00357
00358 MenuItem* parent_item = getMenuItemParent();
00359 if (parent_item)
00360 {
00361 MenuCtrl* parent_ctrl = parent_item->getMenuCtrlParent();
00362 if (parent_ctrl)
00363 {
00364 parent_ctrl->notifyMenuCtrlAccept(_item);
00365 }
00366 }
00367
00368 WidgetManager::getInstance().removeWidgetFromUnlink(sender);
00369
00370
00371 if (sender == nullptr) return;
00372
00373
00374 if (mHideByAccept)
00375 {
00376 setVisibleSmooth(false);
00377 }
00378 else
00379 {
00380 InputManager::getInstance().setKeyFocusWidget(nullptr);
00381 }
00382 }
00383
00384 void MenuCtrl::setItemChildVisibleAt(size_t _index, bool _visible)
00385 {
00386 MYGUI_ASSERT_RANGE(_index, mItemsInfo.size(), "MenuCtrl::setItemChildVisibleAt");
00387
00388 if (_visible)
00389 {
00390 if (mItemsInfo[_index].submenu && mItemsInfo[_index].submenu->getItemCount())
00391 {
00392
00393 int offset = mItemsInfo[0].item->getAbsoluteTop() - this->getAbsoluteTop();
00394
00395 const IntCoord& coord = mItemsInfo[_index].item->getAbsoluteCoord();
00396 IntPoint point(this->getAbsoluteRect().right, coord.top - offset);
00397
00398 MenuCtrl* menu = mItemsInfo[_index].submenu;
00399
00400 if (this->mAlignVert)
00401 {
00402 if (point.left + menu->getWidth() > MyGUI::Gui::getInstance().getViewSize().width)
00403 point.left -= menu->getWidth();
00404 if (point.top + menu->getHeight() > MyGUI::Gui::getInstance().getViewSize().height)
00405 point.top -= menu->getHeight();
00406 }
00407 else
00408 {
00409 point.set(coord.left, this->getAbsoluteRect().bottom);
00410 }
00411
00412 menu->setPosition(point);
00413 menu->setVisibleSmooth(true);
00414 }
00415 }
00416 else
00417 {
00418 if (mItemsInfo[_index].submenu)
00419 {
00420 mItemsInfo[_index].submenu->setVisibleSmooth(false);
00421 }
00422 }
00423 }
00424
00425 void MenuCtrl::notifyRootKeyChangeFocus(Widget* _sender, bool _focus)
00426 {
00427 MenuItem* item = _sender->castType<MenuItem>();
00428 if (item->getItemType() == MenuItemType::Popup)
00429 {
00430 if (_focus)
00431 {
00432 if (!mMenuDropMode || mIsMenuDrop)
00433 {
00434 item->setItemChildVisible(true);
00435 item->setButtonPressed(true);
00436 }
00437 }
00438 else
00439 {
00440 item->setItemChildVisible(false);
00441 item->setButtonPressed(false);
00442 }
00443 }
00444 }
00445
00446 Widget* MenuCtrl::createItemChildByType(size_t _index, const std::string& _type)
00447 {
00448 MYGUI_ASSERT_RANGE(_index, mItemsInfo.size(), "MenuCtrl::createItemChildByType");
00449 removeItemChildAt(_index);
00450 Widget* child = mItemsInfo[_index].item->createWidgetT(WidgetStyle::Popup, _type, mSubMenuSkin, IntCoord(), Align::Default, mSubMenuLayer);
00451 MYGUI_ASSERT(child->isType<MenuCtrl>(), "child must have MenuCtrl base type");
00452 return child;
00453 }
00454
00455 void MenuCtrl::notifyMouseButtonClick(Widget* _sender)
00456 {
00457 MenuItem* item = _sender->castType<MenuItem>();
00458 if (mMenuDropMode)
00459 {
00460 if (mIsMenuDrop)
00461 {
00462 if (item->getItemType() == MenuItemType::Popup)
00463 {
00464 item->setButtonPressed(false);
00465 item->setItemChildVisible(false);
00466 mIsMenuDrop = false;
00467 }
00468 }
00469 else
00470 {
00471 if (item->getItemType() == MenuItemType::Popup)
00472 {
00473 mIsMenuDrop = true;
00474 item->setButtonPressed(true);
00475 item->setItemChildVisible(true);
00476 InputManager::getInstance().setKeyFocusWidget(item);
00477 }
00478 }
00479 }
00480 else
00481 {
00482 if ((item->getItemType() == MenuItemType::Popup && mPopupAccept) ||
00483 item->getItemType() == MenuItemType::Normal)
00484 {
00485 notifyMenuCtrlAccept(item);
00486 }
00487 }
00488
00489 }
00490
00491 void MenuCtrl::onKeyChangeRootFocus(bool _focus)
00492 {
00493 if (mMenuDropMode)
00494 {
00495 mIsMenuDrop = false;
00496 }
00497 if ( ! _focus && mHideByLostKey)
00498 {
00499 setVisibleSmooth(false);
00500 eventMenuCtrlClose(this);
00501 }
00502 Base::onKeyChangeRootFocus(_focus);
00503 }
00504
00505 void MenuCtrl::notifyMouseSetFocus(Widget* _sender, Widget* _new)
00506 {
00507 InputManager::getInstance().setKeyFocusWidget(_sender);
00508 }
00509
00510 void MenuCtrl::_wrapItemChild(MenuItem* _item, MenuCtrl* _widget)
00511 {
00512
00513 size_t index = getItemIndex(_item);
00514 if (mItemsInfo[index].submenu != nullptr)
00515 {
00516 WidgetManager::getInstance().destroyWidget(mItemsInfo[index].submenu);
00517 }
00518 mItemsInfo[index].submenu = _widget;
00519
00520 mItemsInfo[index].submenu->setVisible(false);
00521
00522 update();
00523 }
00524
00525 void MenuCtrl::_wrapItem(MenuItem* _item, size_t _index, const UString& _name, MenuItemType _type, const std::string& _id, Any _data)
00526 {
00527 _item->setAlign(mAlignVert ? Align::Top | Align::HStretch : Align::Default);
00528 _item->setCoord(0, 0, _getClientWidget()->getWidth(), mHeightLine);
00529 _item->eventRootKeyChangeFocus = newDelegate(this, &MenuCtrl::notifyRootKeyChangeFocus);
00530 _item->eventMouseButtonClick = newDelegate(this, &MenuCtrl::notifyMouseButtonClick);
00531 _item->eventMouseSetFocus = newDelegate(this, &MenuCtrl::notifyMouseSetFocus);
00532
00533 setButtonImageIndex(_item, getIconIndexByType(_type ));
00534
00535 MenuCtrl* submenu = nullptr;
00536
00537 ItemInfo info = ItemInfo(_item, _name, _type, submenu, _id, _data);
00538
00539 mItemsInfo.insert(mItemsInfo.begin() + _index, info);
00540
00541
00542 _item->setCaption(_name);
00543
00544 update();
00545 }
00546
00547 void MenuCtrl::setVisible(bool _visible)
00548 {
00549
00550 if (mAnimateSmooth)
00551 {
00552 ControllerManager::getInstance().removeItem(this);
00553 setAlpha(ALPHA_MAX);
00554 setEnabledSilent(true);
00555 mAnimateSmooth = false;
00556 }
00557
00558 if (_visible)
00559 {
00560 if (mOwner == nullptr && mHideByLostKey)
00561 {
00562 MyGUI::InputManager::getInstance().setKeyFocusWidget(this);
00563 }
00564 }
00565
00566 Base::setVisible(_visible);
00567 }
00568
00569 void MenuCtrl::setVisibleSmooth(bool _visible)
00570 {
00571 mAnimateSmooth = true;
00572 ControllerManager::getInstance().removeItem(this);
00573
00574 if (_visible)
00575 {
00576 setEnabledSilent(true);
00577 if ( ! isVisible() )
00578 {
00579 setAlpha(ALPHA_MIN);
00580 Base::setVisible(true);
00581 }
00582
00583 ControllerFadeAlpha* controller = createControllerFadeAlpha(ALPHA_MAX, POPUP_MENU_SPEED_COEF, true);
00584 controller->eventPostAction = newDelegate(action::actionWidgetShow);
00585 ControllerManager::getInstance().addItem(this, controller);
00586 }
00587 else
00588 {
00589 setEnabledSilent(false);
00590
00591 ControllerFadeAlpha* controller = createControllerFadeAlpha(ALPHA_MIN, POPUP_MENU_SPEED_COEF, false);
00592 controller->eventPostAction = newDelegate(action::actionWidgetHide);
00593 ControllerManager::getInstance().addItem(this, controller);
00594 }
00595 }
00596
00597 ControllerFadeAlpha* MenuCtrl::createControllerFadeAlpha(float _alpha, float _coef, bool _enable)
00598 {
00599 ControllerItem* item = ControllerManager::getInstance().createItem(ControllerFadeAlpha::getClassTypeName());
00600 ControllerFadeAlpha* controller = item->castType<ControllerFadeAlpha>();
00601
00602 controller->setAlpha(_alpha);
00603 controller->setCoef(_coef);
00604 controller->setEnabled(_enable);
00605
00606 return controller;
00607 }
00608
00609 MenuItem* MenuCtrl::insertItem(MenuItem* _to, const UString& _name, MenuItemType _type, const std::string& _id, Any _data)
00610 {
00611 return insertItemAt(getItemIndex(_to), _name, _type, _id, _data);
00612 }
00613
00614 MenuItem* MenuCtrl::addItem(const UString& _name, MenuItemType _type, const std::string& _id, Any _data)
00615 {
00616 return insertItemAt(ITEM_NONE, _name, _type, _id, _data);
00617 }
00618
00619 void MenuCtrl::removeItem(MenuItem* _item)
00620 {
00621 removeItemAt(getItemIndex(_item));
00622 }
00623
00624 MenuItem* MenuCtrl::getItemAt(size_t _index)
00625 {
00626 MYGUI_ASSERT_RANGE(_index, mItemsInfo.size(), "MenuCtrl::getItemAt");
00627 return mItemsInfo[_index].item;
00628 }
00629
00630 size_t MenuCtrl::getItemIndex(MenuItem* _item)
00631 {
00632 for (size_t pos=0; pos<mItemsInfo.size(); pos++)
00633 {
00634 if (mItemsInfo[pos].item == _item) return pos;
00635 }
00636 MYGUI_EXCEPT("item (" << _item << ") not found, source 'MenuCtrl::getItemIndex'");
00637 }
00638
00639 MenuItem* MenuCtrl::findItemWith(const UString& _name)
00640 {
00641 for (size_t pos=0; pos<mItemsInfo.size(); pos++)
00642 {
00643 if (mItemsInfo[pos].name == _name) return mItemsInfo[pos].item;
00644 }
00645 return nullptr;
00646 }
00647
00648 MenuItem* MenuCtrl::getItemById(const std::string& _id)
00649 {
00650 for (size_t pos=0; pos<mItemsInfo.size(); pos++)
00651 {
00652 if (mItemsInfo[pos].id == _id) return mItemsInfo[pos].item;
00653 }
00654 MYGUI_EXCEPT("item id (" << _id << ") not found, source 'MenuCtrl::getItemById'");
00655 }
00656
00657 size_t MenuCtrl::getItemIndexById(const std::string& _id)
00658 {
00659 for (size_t pos=0; pos<mItemsInfo.size(); pos++)
00660 {
00661 if (mItemsInfo[pos].id == _id) return pos;
00662 }
00663 MYGUI_EXCEPT("item id (" << _id << ") not found, source 'MenuCtrl::getItemById'");
00664 }
00665
00666 size_t MenuCtrl::findItemIndexWith(const UString& _name)
00667 {
00668 for (size_t pos=0; pos<mItemsInfo.size(); pos++)
00669 {
00670 if (mItemsInfo[pos].name == _name) return pos;
00671 }
00672 return ITEM_NONE;
00673 }
00674
00675 size_t MenuCtrl::findItemIndex(MenuItem* _item)
00676 {
00677 for (size_t pos=0; pos<mItemsInfo.size(); pos++)
00678 {
00679 if (mItemsInfo[pos].item == _item) return pos;
00680 }
00681 return ITEM_NONE;
00682 }
00683
00684 Widget* MenuCtrl::_getClientWidget()
00685 {
00686 return mWidgetClient == nullptr ? this : mWidgetClient;
00687 }
00688
00689 const Widget* MenuCtrl::_getClientWidget() const
00690 {
00691 return mWidgetClient == nullptr ? this : mWidgetClient;
00692 }
00693
00694 }