1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/menucmn.cpp
3 // Purpose: wxMenu and wxMenuBar methods common to all ports
4 // Author: Vadim Zeitlin
8 // Copyright: (c) wxWidgets team
9 // Licence: wxWindows licence
10 ///////////////////////////////////////////////////////////////////////////////
12 // ============================================================================
14 // ============================================================================
16 // ----------------------------------------------------------------------------
18 // ----------------------------------------------------------------------------
20 // For compilers that support precompilation, includes "wx.h".
21 #include "wx/wxprec.h"
36 #include "wx/stockitem.h"
38 // ----------------------------------------------------------------------------
40 // ----------------------------------------------------------------------------
42 #include "wx/listimpl.cpp"
44 WX_DEFINE_LIST(wxMenuList
)
45 WX_DEFINE_LIST(wxMenuItemList
)
47 // ============================================================================
49 // ============================================================================
51 // ----------------------------------------------------------------------------
52 // XTI for wxMenu(Bar)
53 // ----------------------------------------------------------------------------
55 wxDEFINE_FLAGS( wxMenuStyle
)
56 wxBEGIN_FLAGS( wxMenuStyle
)
57 wxFLAGS_MEMBER(wxMENU_TEAROFF
)
58 wxEND_FLAGS( wxMenuStyle
)
60 wxIMPLEMENT_DYNAMIC_CLASS_XTI(wxMenu
, wxEvtHandler
, "wx/menu.h")
61 wxCOLLECTION_TYPE_INFO( wxMenuItem
*, wxMenuItemList
) ;
63 #if wxUSE_EXTENDED_RTTI
64 template<> void wxCollectionToVariantArray( wxMenuItemList
const &theList
,
67 wxListCollectionToAnyList
<wxMenuItemList::compatibility_iterator
>( theList
, value
) ;
71 wxBEGIN_PROPERTIES_TABLE(wxMenu
)
72 wxEVENT_PROPERTY( Select
, wxEVT_COMMAND_MENU_SELECTED
, wxCommandEvent
)
74 wxPROPERTY( Title
, wxString
, SetTitle
, GetTitle
, wxString(), \
75 0 /*flags*/, wxT("Helpstring"), wxT("group") )
77 wxREADONLY_PROPERTY_FLAGS( MenuStyle
, wxMenuStyle
, long, GetStyle
, \
78 wxEMPTY_PARAMETER_VALUE
, 0 /*flags*/, wxT("Helpstring"), \
79 wxT("group")) // style
81 wxPROPERTY_COLLECTION( MenuItems
, wxMenuItemList
, wxMenuItem
*, Append
, \
82 GetMenuItems
, 0 /*flags*/, wxT("Helpstring"), wxT("group"))
83 wxEND_PROPERTIES_TABLE()
85 wxEMPTY_HANDLERS_TABLE(wxMenu
)
87 wxDIRECT_CONSTRUCTOR_2( wxMenu
, wxString
, Title
, long, MenuStyle
)
89 wxDEFINE_FLAGS( wxMenuBarStyle
)
91 wxBEGIN_FLAGS( wxMenuBarStyle
)
92 wxFLAGS_MEMBER(wxMB_DOCKABLE
)
93 wxEND_FLAGS( wxMenuBarStyle
)
95 #if wxUSE_EXTENDED_RTTI
96 // the negative id would lead the window (its superclass !) to
97 // vetoe streaming out otherwise
98 bool wxMenuBarStreamingCallback( const wxObject
*WXUNUSED(object
), wxObjectWriter
*,
99 wxObjectWriterCallback
*, const wxStringToAnyHashMap
& )
105 wxIMPLEMENT_DYNAMIC_CLASS_XTI_CALLBACK(wxMenuBar
, wxWindow
, "wx/menu.h", \
106 wxMenuBarStreamingCallback
)
109 #if wxUSE_EXTENDED_RTTI
110 WX_DEFINE_LIST( wxMenuInfoHelperList
)
112 wxIMPLEMENT_DYNAMIC_CLASS_XTI(wxMenuInfoHelper
, wxObject
, "wx/menu.h")
114 wxBEGIN_PROPERTIES_TABLE(wxMenuInfoHelper
)
115 wxREADONLY_PROPERTY( Menu
, wxMenu
*, GetMenu
, wxEMPTY_PARAMETER_VALUE
, \
116 0 /*flags*/, wxT("Helpstring"), wxT("group"))
118 wxREADONLY_PROPERTY( Title
, wxString
, GetTitle
, wxString(), \
119 0 /*flags*/, wxT("Helpstring"), wxT("group"))
120 wxEND_PROPERTIES_TABLE()
122 wxEMPTY_HANDLERS_TABLE(wxMenuInfoHelper
)
124 wxCONSTRUCTOR_2( wxMenuInfoHelper
, wxMenu
*, Menu
, wxString
, Title
)
126 wxCOLLECTION_TYPE_INFO( wxMenuInfoHelper
*, wxMenuInfoHelperList
) ;
128 template<> void wxCollectionToVariantArray( wxMenuInfoHelperList
const &theList
,
131 wxListCollectionToAnyList
<wxMenuInfoHelperList::compatibility_iterator
>( theList
, value
) ;
136 wxBEGIN_PROPERTIES_TABLE(wxMenuBar
)
137 wxPROPERTY_COLLECTION( MenuInfos
, wxMenuInfoHelperList
, wxMenuInfoHelper
*, AppendMenuInfo
, \
138 GetMenuInfos
, 0 /*flags*/, wxT("Helpstring"), wxT("group"))
139 wxEND_PROPERTIES_TABLE()
141 wxEMPTY_HANDLERS_TABLE(wxMenuBar
)
143 wxCONSTRUCTOR_DUMMY( wxMenuBar
)
145 #if wxUSE_EXTENDED_RTTI
147 const wxMenuInfoHelperList
& wxMenuBarBase::GetMenuInfos() const
149 wxMenuInfoHelperList
* list
= const_cast< wxMenuInfoHelperList
* > (& m_menuInfos
);
150 WX_CLEAR_LIST( wxMenuInfoHelperList
, *list
);
151 for (size_t i
= 0 ; i
< GetMenuCount(); ++i
)
153 wxMenuInfoHelper
* info
= new wxMenuInfoHelper();
154 info
->Create( GetMenu(i
), GetMenuLabel(i
));
162 // ----------------------------------------------------------------------------
163 // XTI for wxMenuItem
164 // ----------------------------------------------------------------------------
166 #if wxUSE_EXTENDED_RTTI
168 bool wxMenuItemStreamingCallback( const wxObject
*object
, wxObjectWriter
*,
169 wxObjectWriterCallback
*, const wxStringToAnyHashMap
& )
171 const wxMenuItem
* mitem
= wx_dynamic_cast(const wxMenuItem
*, object
);
172 if ( mitem
->GetMenu() && !mitem
->GetMenu()->GetTitle().empty() )
174 // we don't stream out the first two items for menus with a title,
175 // they will be reconstructed
176 if ( mitem
->GetMenu()->FindItemByPosition(0) == mitem
||
177 mitem
->GetMenu()->FindItemByPosition(1) == mitem
)
185 wxBEGIN_ENUM( wxItemKind
)
186 wxENUM_MEMBER( wxITEM_SEPARATOR
)
187 wxENUM_MEMBER( wxITEM_NORMAL
)
188 wxENUM_MEMBER( wxITEM_CHECK
)
189 wxENUM_MEMBER( wxITEM_RADIO
)
190 wxEND_ENUM( wxItemKind
)
192 wxIMPLEMENT_DYNAMIC_CLASS_XTI_CALLBACK(wxMenuItem
, wxObject
, "wx/menuitem.h", \
193 wxMenuItemStreamingCallback
)
195 wxBEGIN_PROPERTIES_TABLE(wxMenuItem
)
196 wxPROPERTY( Parent
, wxMenu
*, SetMenu
, GetMenu
, wxEMPTY_PARAMETER_VALUE
, \
197 0 /*flags*/, wxT("Helpstring"), wxT("group") )
198 wxPROPERTY( Id
, int, SetId
, GetId
, wxEMPTY_PARAMETER_VALUE
, \
199 0 /*flags*/, wxT("Helpstring"), wxT("group") )
200 wxPROPERTY( ItemLabel
, wxString
, SetItemLabel
, GetItemLabel
, wxString(), \
201 0 /*flags*/, wxT("Helpstring"), wxT("group") )
202 wxPROPERTY( Help
, wxString
, SetHelp
, GetHelp
, wxString(), \
203 0 /*flags*/, wxT("Helpstring"), wxT("group") )
204 wxREADONLY_PROPERTY( Kind
, wxItemKind
, GetKind
, wxEMPTY_PARAMETER_VALUE
, \
205 0 /*flags*/, wxT("Helpstring"), wxT("group") )
206 wxPROPERTY( SubMenu
, wxMenu
*, SetSubMenu
, GetSubMenu
, wxEMPTY_PARAMETER_VALUE
, \
207 0 /*flags*/, wxT("Helpstring"), wxT("group") )
208 wxPROPERTY( Enabled
, bool, Enable
, IsEnabled
, wxAny((bool)true), \
209 0 /*flags*/, wxT("Helpstring"), wxT("group") )
210 wxPROPERTY( Checked
, bool, Check
, IsChecked
, wxAny((bool)false), \
211 0 /*flags*/, wxT("Helpstring"), wxT("group") )
212 wxPROPERTY( Checkable
, bool, SetCheckable
, IsCheckable
, wxAny((bool)false), \
213 0 /*flags*/, wxT("Helpstring"), wxT("group") )
214 wxEND_PROPERTIES_TABLE()
216 wxEMPTY_HANDLERS_TABLE(wxMenuItem
)
218 wxDIRECT_CONSTRUCTOR_6( wxMenuItem
, wxMenu
*, Parent
, int, Id
, wxString
, \
219 Text
, wxString
, Help
, wxItemKind
, Kind
, wxMenu
*, SubMenu
)
221 // ----------------------------------------------------------------------------
223 // ----------------------------------------------------------------------------
225 wxMenuItemBase::wxMenuItemBase(wxMenu
*parentMenu
,
227 const wxString
& text
,
228 const wxString
& help
,
235 m_id
= wxWindow::NewControlId();
239 m_id
= wxID_SEPARATOR
;
241 // there is a lot of existing code just doing Append(wxID_SEPARATOR)
242 // and it makes sense to omit the following optional parameters,
243 // including the kind one which doesn't default to wxITEM_SEPARATOR,
244 // of course, so override it here
245 kind
= wxITEM_SEPARATOR
;
249 // (popup) menu titles in wxMSW use this ID to indicate that
250 // it's not a real menu item, so we don't want the check below to
256 // ids are limited to 16 bits under MSW so portable code shouldn't
257 // use ids outside of this range (negative ids generated by wx are
259 wxASSERT_MSG( (itemid
>= 0 && itemid
< SHRT_MAX
) ||
260 (itemid
>= wxID_AUTO_LOWEST
&& itemid
<= wxID_AUTO_HIGHEST
),
261 wxS("invalid itemid value") );
265 // notice that parentMenu can be NULL: the item can be attached to the menu
266 // later with SetMenu()
268 m_parentMenu
= parentMenu
;
278 wxMenuItemBase::~wxMenuItemBase()
285 wxAcceleratorEntry
*wxMenuItemBase::GetAccel() const
287 return wxAcceleratorEntry::Create(GetItemLabel());
290 void wxMenuItemBase::SetAccel(wxAcceleratorEntry
*accel
)
292 wxString text
= m_text
.BeforeFirst(wxT('\t'));
296 text
+= accel
->ToString();
302 #endif // wxUSE_ACCEL
304 void wxMenuItemBase::SetItemLabel(const wxString
& str
)
308 if ( m_text
.empty() && !IsSeparator() )
310 wxASSERT_MSG( wxIsStockID(GetId()),
311 wxT("A non-stock menu item with an empty label?") );
312 m_text
= wxGetStockLabel(GetId(), wxSTOCK_WITH_ACCELERATOR
|
313 wxSTOCK_WITH_MNEMONIC
);
317 void wxMenuItemBase::SetHelp(const wxString
& str
)
321 if ( m_help
.empty() && !IsSeparator() && wxIsStockID(GetId()) )
323 // get a stock help string
324 m_help
= wxGetStockHelpString(GetId());
329 wxString
wxMenuItemBase::GetLabelText(const wxString
& text
)
331 return wxStripMenuCodes(text
);
335 #if WXWIN_COMPATIBILITY_2_8
336 wxString
wxMenuItemBase::GetLabelFromText(const wxString
& text
)
338 return GetLabelText(text
);
342 bool wxMenuBase::ms_locked
= true;
344 // ----------------------------------------------------------------------------
345 // wxMenu ctor and dtor
346 // ----------------------------------------------------------------------------
348 void wxMenuBase::Init(long style
)
353 m_invokingWindow
= NULL
;
356 m_eventHandler
= this;
359 wxMenuBase::~wxMenuBase()
361 WX_CLEAR_LIST(wxMenuItemList
, m_items
);
364 // ----------------------------------------------------------------------------
365 // wxMenu item adding/removing
366 // ----------------------------------------------------------------------------
368 void wxMenuBase::AddSubMenu(wxMenu
*submenu
)
370 wxCHECK_RET( submenu
, wxT("can't add a NULL submenu") );
372 submenu
->SetParent((wxMenu
*)this);
375 wxMenuItem
* wxMenuBase::DoAppend(wxMenuItem
*item
)
377 wxCHECK_MSG( item
, NULL
, wxT("invalid item in wxMenu::Append()") );
379 m_items
.Append(item
);
380 item
->SetMenu((wxMenu
*)this);
381 if ( item
->IsSubMenu() )
383 AddSubMenu(item
->GetSubMenu());
389 wxMenuItem
* wxMenuBase::Insert(size_t pos
, wxMenuItem
*item
)
391 wxCHECK_MSG( item
, NULL
, wxT("invalid item in wxMenu::Insert") );
393 if ( pos
== GetMenuItemCount() )
395 return DoAppend(item
);
399 wxCHECK_MSG( pos
< GetMenuItemCount(), NULL
,
400 wxT("invalid index in wxMenu::Insert") );
402 return DoInsert(pos
, item
);
406 wxMenuItem
* wxMenuBase::DoInsert(size_t pos
, wxMenuItem
*item
)
408 wxCHECK_MSG( item
, NULL
, wxT("invalid item in wxMenu::Insert()") );
410 wxMenuItemList::compatibility_iterator node
= m_items
.Item(pos
);
411 wxCHECK_MSG( node
, NULL
, wxT("invalid index in wxMenu::Insert()") );
413 m_items
.Insert(node
, item
);
414 item
->SetMenu((wxMenu
*)this);
415 if ( item
->IsSubMenu() )
417 AddSubMenu(item
->GetSubMenu());
423 wxMenuItem
*wxMenuBase::Remove(wxMenuItem
*item
)
425 wxCHECK_MSG( item
, NULL
, wxT("invalid item in wxMenu::Remove") );
427 return DoRemove(item
);
430 wxMenuItem
*wxMenuBase::DoRemove(wxMenuItem
*item
)
432 wxMenuItemList::compatibility_iterator node
= m_items
.Find(item
);
434 // if we get here, the item is valid or one of Remove() functions is broken
435 wxCHECK_MSG( node
, NULL
, wxT("bug in wxMenu::Remove logic") );
437 // we detach the item, but we do delete the list node (i.e. don't call
438 // DetachNode() here!)
441 // item isn't attached to anything any more
443 wxMenu
*submenu
= item
->GetSubMenu();
446 submenu
->SetParent(NULL
);
447 if ( submenu
->IsAttached() )
454 bool wxMenuBase::Delete(wxMenuItem
*item
)
456 wxCHECK_MSG( item
, false, wxT("invalid item in wxMenu::Delete") );
458 return DoDelete(item
);
461 bool wxMenuBase::DoDelete(wxMenuItem
*item
)
463 wxMenuItem
*item2
= DoRemove(item
);
464 wxCHECK_MSG( item2
, false, wxT("failed to delete menu item") );
466 // don't delete the submenu
467 item2
->SetSubMenu(NULL
);
474 bool wxMenuBase::Destroy(wxMenuItem
*item
)
476 wxCHECK_MSG( item
, false, wxT("invalid item in wxMenu::Destroy") );
478 return DoDestroy(item
);
481 bool wxMenuBase::DoDestroy(wxMenuItem
*item
)
483 wxMenuItem
*item2
= DoRemove(item
);
484 wxCHECK_MSG( item2
, false, wxT("failed to delete menu item") );
491 // ----------------------------------------------------------------------------
492 // wxMenu searching for items
493 // ----------------------------------------------------------------------------
495 // Finds the item id matching the given string, wxNOT_FOUND if not found.
496 int wxMenuBase::FindItem(const wxString
& text
) const
498 wxString label
= wxMenuItem::GetLabelText(text
);
499 for ( wxMenuItemList::compatibility_iterator node
= m_items
.GetFirst();
501 node
= node
->GetNext() )
503 wxMenuItem
*item
= node
->GetData();
504 if ( item
->IsSubMenu() )
506 int rc
= item
->GetSubMenu()->FindItem(label
);
507 if ( rc
!= wxNOT_FOUND
)
511 // we execute this code for submenus as well to alllow finding them by
512 // name just like the ordinary items
513 if ( !item
->IsSeparator() )
515 if ( item
->GetItemLabelText() == label
)
516 return item
->GetId();
523 // recursive search for item by id
524 wxMenuItem
*wxMenuBase::FindItem(int itemId
, wxMenu
**itemMenu
) const
529 wxMenuItem
*item
= NULL
;
530 for ( wxMenuItemList::compatibility_iterator node
= m_items
.GetFirst();
532 node
= node
->GetNext() )
534 item
= node
->GetData();
536 if ( item
->GetId() == itemId
)
539 *itemMenu
= (wxMenu
*)this;
541 else if ( item
->IsSubMenu() )
543 item
= item
->GetSubMenu()->FindItem(itemId
, itemMenu
);
547 // don't exit the loop
555 // non recursive search
556 wxMenuItem
*wxMenuBase::FindChildItem(int itemid
, size_t *ppos
) const
558 wxMenuItem
*item
= NULL
;
559 wxMenuItemList::compatibility_iterator node
= GetMenuItems().GetFirst();
562 for ( pos
= 0; node
; pos
++ )
564 if ( node
->GetData()->GetId() == itemid
)
566 item
= node
->GetData();
571 node
= node
->GetNext();
576 *ppos
= item
? pos
: (size_t)wxNOT_FOUND
;
583 wxMenuItem
* wxMenuBase::FindItemByPosition(size_t position
) const
585 wxCHECK_MSG( position
< m_items
.GetCount(), NULL
,
586 wxT("wxMenu::FindItemByPosition(): invalid menu index") );
588 return m_items
.Item( position
)->GetData();
591 // ----------------------------------------------------------------------------
592 // wxMenu helpers used by derived classes
593 // ----------------------------------------------------------------------------
595 // Update a menu and all submenus recursively. source is the object that has
596 // the update event handlers defined for it. If NULL, the menu or associated
597 // window will be used.
598 void wxMenuBase::UpdateUI(wxEvtHandler
* source
)
600 wxWindow
* const win
= GetWindow();
602 if ( !source
&& win
)
603 source
= win
->GetEventHandler();
605 source
= GetEventHandler();
609 wxMenuItemList::compatibility_iterator node
= GetMenuItems().GetFirst();
612 wxMenuItem
* item
= node
->GetData();
613 if ( !item
->IsSeparator() )
615 wxWindowID itemid
= item
->GetId();
616 wxUpdateUIEvent
event(itemid
);
617 event
.SetEventObject( source
);
619 if ( source
->ProcessEvent(event
) )
621 // if anything changed, update the changed attribute
622 if (event
.GetSetText())
623 SetLabel(itemid
, event
.GetText());
624 if (event
.GetSetChecked())
625 Check(itemid
, event
.GetChecked());
626 if (event
.GetSetEnabled())
627 Enable(itemid
, event
.GetEnabled());
630 // recurse to the submenus
631 if ( item
->GetSubMenu() )
632 item
->GetSubMenu()->UpdateUI(source
);
634 //else: item is a separator (which doesn't process update UI events)
636 node
= node
->GetNext();
640 bool wxMenuBase::SendEvent(int itemid
, int checked
)
642 wxCommandEvent
event(wxEVT_COMMAND_MENU_SELECTED
, itemid
);
643 event
.SetEventObject(this);
644 event
.SetInt(checked
);
646 bool processed
= false;
648 // Try the menu's event handler first
649 wxEvtHandler
*handler
= GetEventHandler();
651 processed
= handler
->SafelyProcessEvent(event
);
653 // Try the window the menu was popped up from or its menu bar belongs to
656 wxWindow
* const win
= GetWindow();
658 processed
= win
->HandleWindowEvent(event
);
664 // ----------------------------------------------------------------------------
665 // wxMenu attaching/detaching to/from menu bar
666 // ----------------------------------------------------------------------------
668 wxMenuBar
* wxMenuBase::GetMenuBar() const
671 return GetParent()->GetMenuBar();
675 void wxMenuBase::Attach(wxMenuBarBase
*menubar
)
677 // use Detach() instead!
678 wxASSERT_MSG( menubar
, wxT("menu can't be attached to NULL menubar") );
680 // use IsAttached() to prevent this from happening
681 wxASSERT_MSG( !m_menuBar
, wxT("attaching menu twice?") );
683 m_menuBar
= (wxMenuBar
*)menubar
;
686 void wxMenuBase::Detach()
688 // use IsAttached() to prevent this from happening
689 wxASSERT_MSG( m_menuBar
, wxT("detaching unattached menu?") );
694 // ----------------------------------------------------------------------------
695 // wxMenu invoking window handling
696 // ----------------------------------------------------------------------------
698 void wxMenuBase::SetInvokingWindow(wxWindow
*win
)
700 wxASSERT_MSG( !GetParent(),
701 "should only be called for top level popup menus" );
702 wxASSERT_MSG( !IsAttached(),
703 "menus attached to menu bar can't have invoking window" );
705 m_invokingWindow
= win
;
708 wxWindow
*wxMenuBase::GetWindow() const
710 // only the top level menus have non-NULL invoking window or a pointer to
711 // the menu bar so recurse upwards until we find it
712 const wxMenuBase
*menu
= this;
713 while ( menu
->GetParent() )
715 menu
= menu
->GetParent();
718 return menu
->GetMenuBar() ? menu
->GetMenuBar()->GetFrame()
719 : menu
->GetInvokingWindow();
722 // ----------------------------------------------------------------------------
723 // wxMenu functions forwarded to wxMenuItem
724 // ----------------------------------------------------------------------------
726 void wxMenuBase::Enable( int itemid
, bool enable
)
728 wxMenuItem
*item
= FindItem(itemid
);
730 wxCHECK_RET( item
, wxT("wxMenu::Enable: no such item") );
732 item
->Enable(enable
);
735 bool wxMenuBase::IsEnabled( int itemid
) const
737 wxMenuItem
*item
= FindItem(itemid
);
739 wxCHECK_MSG( item
, false, wxT("wxMenu::IsEnabled: no such item") );
741 return item
->IsEnabled();
744 void wxMenuBase::Check( int itemid
, bool enable
)
746 wxMenuItem
*item
= FindItem(itemid
);
748 wxCHECK_RET( item
, wxT("wxMenu::Check: no such item") );
753 bool wxMenuBase::IsChecked( int itemid
) const
755 wxMenuItem
*item
= FindItem(itemid
);
757 wxCHECK_MSG( item
, false, wxT("wxMenu::IsChecked: no such item") );
759 return item
->IsChecked();
762 void wxMenuBase::SetLabel( int itemid
, const wxString
&label
)
764 wxMenuItem
*item
= FindItem(itemid
);
766 wxCHECK_RET( item
, wxT("wxMenu::SetLabel: no such item") );
768 item
->SetItemLabel(label
);
771 wxString
wxMenuBase::GetLabel( int itemid
) const
773 wxMenuItem
*item
= FindItem(itemid
);
775 wxCHECK_MSG( item
, wxEmptyString
, wxT("wxMenu::GetLabel: no such item") );
777 return item
->GetItemLabel();
780 void wxMenuBase::SetHelpString( int itemid
, const wxString
& helpString
)
782 wxMenuItem
*item
= FindItem(itemid
);
784 wxCHECK_RET( item
, wxT("wxMenu::SetHelpString: no such item") );
786 item
->SetHelp( helpString
);
789 wxString
wxMenuBase::GetHelpString( int itemid
) const
791 wxMenuItem
*item
= FindItem(itemid
);
793 wxCHECK_MSG( item
, wxEmptyString
, wxT("wxMenu::GetHelpString: no such item") );
795 return item
->GetHelp();
798 // ----------------------------------------------------------------------------
799 // wxMenuBarBase ctor and dtor
800 // ----------------------------------------------------------------------------
802 wxMenuBarBase::wxMenuBarBase()
805 m_menuBarFrame
= NULL
;
808 wxMenuBarBase::~wxMenuBarBase()
810 WX_CLEAR_LIST(wxMenuList
, m_menus
);
813 // ----------------------------------------------------------------------------
814 // wxMenuBar item access: the base class versions manage m_menus list, the
815 // derived class should reflect the changes in the real menubar
816 // ----------------------------------------------------------------------------
818 wxMenu
*wxMenuBarBase::GetMenu(size_t pos
) const
820 wxMenuList::compatibility_iterator node
= m_menus
.Item(pos
);
821 wxCHECK_MSG( node
, NULL
, wxT("bad index in wxMenuBar::GetMenu()") );
823 return node
->GetData();
826 bool wxMenuBarBase::Append(wxMenu
*menu
, const wxString
& title
)
828 wxCHECK_MSG( menu
, false, wxT("can't append NULL menu") );
829 wxCHECK_MSG( !title
.empty(), false, wxT("can't append menu with empty title") );
831 m_menus
.Append(menu
);
837 bool wxMenuBarBase::Insert(size_t pos
, wxMenu
*menu
,
838 const wxString
& title
)
840 if ( pos
== m_menus
.GetCount() )
842 return wxMenuBarBase::Append(menu
, title
);
844 else // not at the end
846 wxCHECK_MSG( menu
, false, wxT("can't insert NULL menu") );
848 wxMenuList::compatibility_iterator node
= m_menus
.Item(pos
);
849 wxCHECK_MSG( node
, false, wxT("bad index in wxMenuBar::Insert()") );
851 m_menus
.Insert(node
, menu
);
858 wxMenu
*wxMenuBarBase::Replace(size_t pos
, wxMenu
*menu
,
859 const wxString
& WXUNUSED(title
))
861 wxCHECK_MSG( menu
, NULL
, wxT("can't insert NULL menu") );
863 wxMenuList::compatibility_iterator node
= m_menus
.Item(pos
);
864 wxCHECK_MSG( node
, NULL
, wxT("bad index in wxMenuBar::Replace()") );
866 wxMenu
*menuOld
= node
->GetData();
875 wxMenu
*wxMenuBarBase::Remove(size_t pos
)
877 wxMenuList::compatibility_iterator node
= m_menus
.Item(pos
);
878 wxCHECK_MSG( node
, NULL
, wxT("bad index in wxMenuBar::Remove()") );
880 wxMenu
*menu
= node
->GetData();
887 int wxMenuBarBase::FindMenu(const wxString
& title
) const
889 wxString label
= wxMenuItem::GetLabelText(title
);
891 size_t count
= GetMenuCount();
892 for ( size_t i
= 0; i
< count
; i
++ )
894 wxString title2
= GetMenuLabel(i
);
895 if ( (title2
== title
) ||
896 (wxMenuItem::GetLabelText(title2
) == label
) )
907 // ----------------------------------------------------------------------------
908 // wxMenuBar attaching/detaching to/from the frame
909 // ----------------------------------------------------------------------------
911 void wxMenuBarBase::Attach(wxFrame
*frame
)
913 wxASSERT_MSG( !IsAttached(), wxT("menubar already attached!") );
915 m_menuBarFrame
= frame
;
918 void wxMenuBarBase::Detach()
920 wxASSERT_MSG( IsAttached(), wxT("detaching unattached menubar") );
922 m_menuBarFrame
= NULL
;
925 // ----------------------------------------------------------------------------
926 // wxMenuBar searching for items
927 // ----------------------------------------------------------------------------
929 wxMenuItem
*wxMenuBarBase::FindItem(int itemid
, wxMenu
**menu
) const
934 wxMenuItem
*item
= NULL
;
935 size_t count
= GetMenuCount(), i
;
936 wxMenuList::const_iterator it
;
937 for ( i
= 0, it
= m_menus
.begin(); !item
&& (i
< count
); i
++, it
++ )
939 item
= (*it
)->FindItem(itemid
, menu
);
945 int wxMenuBarBase::FindMenuItem(const wxString
& menu
, const wxString
& item
) const
947 wxString label
= wxMenuItem::GetLabelText(menu
);
950 wxMenuList::compatibility_iterator node
;
951 for ( node
= m_menus
.GetFirst(); node
; node
= node
->GetNext(), i
++ )
953 if ( label
== wxMenuItem::GetLabelText(GetMenuLabel(i
)) )
954 return node
->GetData()->FindItem(item
);
960 // ---------------------------------------------------------------------------
961 // wxMenuBar functions forwarded to wxMenuItem
962 // ---------------------------------------------------------------------------
964 void wxMenuBarBase::Enable(int itemid
, bool enable
)
966 wxMenuItem
*item
= FindItem(itemid
);
968 wxCHECK_RET( item
, wxT("attempt to enable an item which doesn't exist") );
970 item
->Enable(enable
);
973 void wxMenuBarBase::Check(int itemid
, bool check
)
975 wxMenuItem
*item
= FindItem(itemid
);
977 wxCHECK_RET( item
, wxT("attempt to check an item which doesn't exist") );
978 wxCHECK_RET( item
->IsCheckable(), wxT("attempt to check an uncheckable item") );
983 bool wxMenuBarBase::IsChecked(int itemid
) const
985 wxMenuItem
*item
= FindItem(itemid
);
987 wxCHECK_MSG( item
, false, wxT("wxMenuBar::IsChecked(): no such item") );
989 return item
->IsChecked();
992 bool wxMenuBarBase::IsEnabled(int itemid
) const
994 wxMenuItem
*item
= FindItem(itemid
);
996 wxCHECK_MSG( item
, false, wxT("wxMenuBar::IsEnabled(): no such item") );
998 return item
->IsEnabled();
1001 void wxMenuBarBase::SetLabel(int itemid
, const wxString
& label
)
1003 wxMenuItem
*item
= FindItem(itemid
);
1005 wxCHECK_RET( item
, wxT("wxMenuBar::SetLabel(): no such item") );
1007 item
->SetItemLabel(label
);
1010 wxString
wxMenuBarBase::GetLabel(int itemid
) const
1012 wxMenuItem
*item
= FindItem(itemid
);
1014 wxCHECK_MSG( item
, wxEmptyString
,
1015 wxT("wxMenuBar::GetLabel(): no such item") );
1017 return item
->GetItemLabel();
1020 void wxMenuBarBase::SetHelpString(int itemid
, const wxString
& helpString
)
1022 wxMenuItem
*item
= FindItem(itemid
);
1024 wxCHECK_RET( item
, wxT("wxMenuBar::SetHelpString(): no such item") );
1026 item
->SetHelp(helpString
);
1029 wxString
wxMenuBarBase::GetHelpString(int itemid
) const
1031 wxMenuItem
*item
= FindItem(itemid
);
1033 wxCHECK_MSG( item
, wxEmptyString
,
1034 wxT("wxMenuBar::GetHelpString(): no such item") );
1036 return item
->GetHelp();
1039 void wxMenuBarBase::UpdateMenus()
1041 wxEvtHandler
* source
;
1043 int nCount
= GetMenuCount();
1044 for (int n
= 0; n
< nCount
; n
++)
1046 menu
= GetMenu( n
);
1049 source
= menu
->GetEventHandler();
1051 menu
->UpdateUI( source
);
1056 #if WXWIN_COMPATIBILITY_2_8
1057 // get or change the label of the menu at given position
1058 void wxMenuBarBase::SetLabelTop(size_t pos
, const wxString
& label
)
1060 SetMenuLabel(pos
, label
);
1063 wxString
wxMenuBarBase::GetLabelTop(size_t pos
) const
1065 return GetMenuLabelText(pos
);
1069 #endif // wxUSE_MENUS