MyGUI  3.0.3
MyGUI_MenuCtrl.cpp
Go to the documentation of this file.
00001 
00007 /*
00008     This file is part of MyGUI.
00009 
00010     MyGUI is free software: you can redistribute it and/or modify
00011     it under the terms of the GNU Lesser General Public License as published by
00012     the Free Software Foundation, either version 3 of the License, or
00013     (at your option) any later version.
00014 
00015     MyGUI is distributed in the hope that it will be useful,
00016     but WITHOUT ANY WARRANTY; without even the implied warranty of
00017     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00018     GNU Lesser General Public License for more details.
00019 
00020     You should have received a copy of the GNU Lesser General Public License
00021     along with MyGUI.  If not, see <http://www.gnu.org/licenses/>.
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         //MYGUI_ASSERT(nullptr != mWidgetClient, "Child Widget Client not found in skin (MenuCtrl must have Client)");
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         //MYGUI_ASSERT(!mSkinLine.empty(), "SkinLine property not found (MenuCtrl must have SkinLine property)");
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         //MYGUI_ASSERT(!mSubMenuSkin.empty(), "SubMenuSkin property not found (MenuCtrl must have SubMenuSkin property)");
00133 
00134         iterS = properties.find("SubMenuLayer");
00135         if (iterS != properties.end()) mSubMenuLayer = iterS->second;
00136         //MYGUI_ASSERT(!mSubMenuLayer.empty(), "SubMenuLayer property not found (MenuCtrl must have SubMenuLayer property)");
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 } // namespace MyGUI