1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/gtk/menu.cpp
3 // Purpose: implementation of wxMenuBar and wxMenu classes for wxGTK
4 // Author: Robert Roebling
6 // Copyright: (c) 1998 Robert Roebling
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
10 // For compilers that support precompilation, includes "wx.h".
11 #include "wx/wxprec.h"
21 #include "wx/bitmap.h"
26 #include "wx/stockitem.h"
29 #include "wx/gtk/private.h"
30 #include "wx/gtk/private/gtk2-compat.h"
31 #include "wx/gtk/private/mnemonics.h"
33 // Number of currently open modal dialogs, defined in src/gtk/toplevel.cpp.
34 extern int wxOpenModalDialogsCount
;
36 // we use normal item but with a special id for the menu title
37 static const int wxGTK_TITLE_ID
= -3;
39 // forward declare it as it's used by wxMenuBar too when using Hildon
42 static void menuitem_activate(GtkWidget
*, wxMenuItem
* item
);
46 static void wxGetGtkAccel(const wxMenuItem
*, guint
*, GdkModifierType
*);
49 static void DoCommonMenuCallbackCode(wxMenu
*menu
, wxMenuEvent
& event
)
51 // See the comment about Ubuntu Unity in menuitem_activate().
52 if ( wxOpenModalDialogsCount
)
55 event
.SetEventObject( menu
);
57 wxEvtHandler
* handler
= menu
->GetEventHandler();
58 if (handler
&& handler
->SafelyProcessEvent(event
))
61 wxWindow
*win
= menu
->GetWindow();
62 wxCHECK_RET( win
, "event for a menu without associated window?" );
64 win
->HandleWindowEvent( event
);
67 //-----------------------------------------------------------------------------
69 //-----------------------------------------------------------------------------
71 wxMenuBar
::~wxMenuBar()
75 void wxMenuBar
::Init(size_t n
, wxMenu
*menus
[], const wxString titles
[], long style
)
77 #if wxUSE_LIBHILDON || wxUSE_LIBHILDON2
78 // Hildon window uses a single menu instead of a menu bar, so wxMenuBar is
79 // the same as menu in this case
81 m_menubar
= gtk_menu_new();
82 #else // !wxUSE_LIBHILDON && !wxUSE_LIBHILDON2
83 if (!PreCreation( NULL
, wxDefaultPosition
, wxDefaultSize
) ||
84 !CreateBase( NULL
, -1, wxDefaultPosition
, wxDefaultSize
, style
, wxDefaultValidator
, wxT("menubar") ))
86 wxFAIL_MSG( wxT("wxMenuBar creation failed") );
90 m_menubar
= gtk_menu_bar_new();
92 if (style
& wxMB_DOCKABLE
)
94 m_widget
= gtk_handle_box_new();
95 gtk_container_add(GTK_CONTAINER(m_widget
), m_menubar
);
96 gtk_widget_show(m_menubar
);
100 m_widget
= m_menubar
;
104 #endif // wxUSE_LIBHILDON || wxUSE_LIBHILDON2/!wxUSE_LIBHILDON && !wxUSE_LIBHILDON2
106 g_object_ref_sink(m_widget
);
108 for (size_t i
= 0; i
< n
; ++i
)
109 Append(menus
[i
], titles
[i
]);
112 wxMenuBar
::wxMenuBar(size_t n
, wxMenu
*menus
[], const wxString titles
[], long style
)
114 Init(n
, menus
, titles
, style
);
117 wxMenuBar
::wxMenuBar(long style
)
119 Init(0, NULL
, NULL
, style
);
122 wxMenuBar
::wxMenuBar()
124 Init(0, NULL
, NULL
, 0);
127 // recursive helpers for wxMenuBar::Attach() and Detach(): they are called to
128 // associate the menus with the frame they belong to or dissociate them from it
133 DetachFromFrame(wxMenu
* menu
, wxFrame
* frame
)
135 // support for native hot keys
138 // Note that wxGetTopLevelParent() is really needed because this frame
139 // can be an MDI child frame which is a fake frame and not a TLW at all
140 GtkWindow
* const tlw
= GTK_WINDOW(wxGetTopLevelParent(frame
)->m_widget
);
141 if (g_slist_find(gtk_accel_groups_from_object(G_OBJECT(tlw
)), menu
->m_accel
))
142 gtk_window_remove_accel_group(tlw
, menu
->m_accel
);
145 wxMenuItemList
::compatibility_iterator node
= menu
->GetMenuItems().GetFirst();
148 wxMenuItem
*menuitem
= node
->GetData();
149 if (menuitem
->IsSubMenu())
150 DetachFromFrame(menuitem
->GetSubMenu(), frame
);
151 node
= node
->GetNext();
156 AttachToFrame(wxMenu
* menu
, wxFrame
* frame
)
158 // support for native hot keys
161 GtkWindow
* const tlw
= GTK_WINDOW(wxGetTopLevelParent(frame
)->m_widget
);
162 if (!g_slist_find(gtk_accel_groups_from_object(G_OBJECT(tlw
)), menu
->m_accel
))
163 gtk_window_add_accel_group(tlw
, menu
->m_accel
);
166 wxMenuItemList
::compatibility_iterator node
= menu
->GetMenuItems().GetFirst();
169 wxMenuItem
*menuitem
= node
->GetData();
170 if (menuitem
->IsSubMenu())
171 AttachToFrame(menuitem
->GetSubMenu(), frame
);
172 node
= node
->GetNext();
176 } // anonymous namespace
178 void wxMenuBar
::SetLayoutDirection(wxLayoutDirection dir
)
180 if ( dir
== wxLayout_Default
)
182 const wxWindow
*const frame
= GetFrame();
185 // inherit layout from frame.
186 dir
= frame
->GetLayoutDirection();
188 else // use global layout
190 dir
= wxTheApp
->GetLayoutDirection();
194 if ( dir
== wxLayout_Default
)
197 GTKSetLayout(m_menubar
, dir
);
199 // also set the layout of all menus we already have (new ones will inherit
200 // the current layout)
201 for ( wxMenuList
::compatibility_iterator node
= m_menus
.GetFirst();
203 node
= node
->GetNext() )
205 wxMenu
*const menu
= node
->GetData();
206 menu
->SetLayoutDirection(dir
);
210 wxLayoutDirection wxMenuBar
::GetLayoutDirection() const
212 return GTKGetLayout(m_menubar
);
215 void wxMenuBar
::Attach(wxFrame
*frame
)
217 wxMenuBarBase
::Attach(frame
);
219 wxMenuList
::compatibility_iterator node
= m_menus
.GetFirst();
222 wxMenu
*menu
= node
->GetData();
223 AttachToFrame( menu
, frame
);
224 node
= node
->GetNext();
227 SetLayoutDirection(wxLayout_Default
);
230 void wxMenuBar
::Detach()
232 wxMenuList
::compatibility_iterator node
= m_menus
.GetFirst();
235 wxMenu
*menu
= node
->GetData();
236 DetachFromFrame( menu
, m_menuBarFrame
);
237 node
= node
->GetNext();
240 wxMenuBarBase
::Detach();
243 bool wxMenuBar
::Append( wxMenu
*menu
, const wxString
&title
)
245 if (wxMenuBarBase
::Append(menu
, title
))
247 GtkAppend(menu
, title
);
253 void wxMenuBar
::GtkAppend(wxMenu
* menu
, const wxString
& title
, int pos
)
255 menu
->SetLayoutDirection(GetLayoutDirection());
257 #if wxUSE_LIBHILDON || wxUSE_LIBHILDON2
258 // if the menu has only one item, append it directly to the top level menu
259 // instead of inserting a useless submenu
260 if ( menu
->GetMenuItemCount() == 1 )
262 wxMenuItem
* const item
= menu
->FindItemByPosition(0);
264 // remove both mnemonics and accelerator: neither is useful under Maemo
265 const wxString
str(wxStripMenuCodes(item
->GetItemLabel()));
267 if ( item
->IsSubMenu() )
269 GtkAppend(item
->GetSubMenu(), str
, pos
);
273 menu
->m_owner
= gtk_menu_item_new_with_mnemonic( wxGTK_CONV( str
) );
275 g_signal_connect(menu
->m_owner
, "activate",
276 G_CALLBACK(menuitem_activate
), item
);
277 item
->SetMenuItem(menu
->m_owner
);
280 #endif // wxUSE_LIBHILDON || wxUSE_LIBHILDON2 /!wxUSE_LIBHILDON && !wxUSE_LIBHILDON2
282 const wxString
str(wxConvertMnemonicsToGTK(title
));
284 // This doesn't have much effect right now.
285 menu
->SetTitle( str
);
287 // The "m_owner" is the "menu item"
288 menu
->m_owner
= gtk_menu_item_new_with_mnemonic( wxGTK_CONV( str
) );
290 gtk_menu_item_set_submenu( GTK_MENU_ITEM(menu
->m_owner
), menu
->m_menu
);
292 g_object_ref(menu
->m_owner
);
294 gtk_widget_show( menu
->m_owner
);
297 gtk_menu_shell_append( GTK_MENU_SHELL(m_menubar
), menu
->m_owner
);
299 gtk_menu_shell_insert( GTK_MENU_SHELL(m_menubar
), menu
->m_owner
, pos
);
301 if ( m_menuBarFrame
)
302 AttachToFrame( menu
, m_menuBarFrame
);
305 bool wxMenuBar
::Insert(size_t pos
, wxMenu
*menu
, const wxString
& title
)
307 if (wxMenuBarBase
::Insert(pos
, menu
, title
))
309 GtkAppend(menu
, title
, int(pos
));
315 wxMenu
*wxMenuBar
::Replace(size_t pos
, wxMenu
*menu
, const wxString
& title
)
317 // remove the old item and insert a new one
318 wxMenu
*menuOld
= Remove(pos
);
319 if ( menuOld
&& !Insert(pos
, menu
, title
) )
324 // either Insert() succeeded or Remove() failed and menuOld is NULL
328 wxMenu
*wxMenuBar
::Remove(size_t pos
)
330 wxMenu
*menu
= wxMenuBarBase
::Remove(pos
);
334 // remove item from menubar before destroying item to avoid spurious
335 // warnings from Ubuntu libdbusmenu
336 gtk_container_remove(GTK_CONTAINER(m_menubar
), menu
->m_owner
);
337 // remove submenu to avoid destroying it when item is destroyed
339 gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu
->m_owner
), NULL
);
341 gtk_menu_item_remove_submenu(GTK_MENU_ITEM(menu
->m_owner
));
344 gtk_widget_destroy( menu
->m_owner
);
345 g_object_unref(menu
->m_owner
);
346 menu
->m_owner
= NULL
;
348 if ( m_menuBarFrame
)
349 DetachFromFrame( menu
, m_menuBarFrame
);
354 static int FindMenuItemRecursive( const wxMenu
*menu
, const wxString
&menuString
, const wxString
&itemString
)
356 if (wxMenuItem
::GetLabelText(menu
->GetTitle()) == wxMenuItem
::GetLabelText(menuString
))
358 int res
= menu
->FindItem( itemString
);
359 if (res
!= wxNOT_FOUND
)
363 wxMenuItemList
::compatibility_iterator node
= menu
->GetMenuItems().GetFirst();
366 wxMenuItem
*item
= node
->GetData();
367 if (item
->IsSubMenu())
368 return FindMenuItemRecursive(item
->GetSubMenu(), menuString
, itemString
);
370 node
= node
->GetNext();
376 int wxMenuBar
::FindMenuItem( const wxString
&menuString
, const wxString
&itemString
) const
378 wxMenuList
::compatibility_iterator node
= m_menus
.GetFirst();
381 wxMenu
*menu
= node
->GetData();
382 int res
= FindMenuItemRecursive( menu
, menuString
, itemString
);
385 node
= node
->GetNext();
391 // Find a wxMenuItem using its id. Recurses down into sub-menus
392 static wxMenuItem
* FindMenuItemByIdRecursive(const wxMenu
* menu
, int id
)
394 wxMenuItem
* result
= menu
->FindChildItem(id
);
396 wxMenuItemList
::compatibility_iterator node
= menu
->GetMenuItems().GetFirst();
397 while ( node
&& result
== NULL
)
399 wxMenuItem
*item
= node
->GetData();
400 if (item
->IsSubMenu())
402 result
= FindMenuItemByIdRecursive( item
->GetSubMenu(), id
);
404 node
= node
->GetNext();
410 wxMenuItem
* wxMenuBar
::FindItem( int id
, wxMenu
**menuForItem
) const
412 wxMenuItem
* result
= 0;
413 wxMenuList
::compatibility_iterator node
= m_menus
.GetFirst();
414 while (node
&& result
== 0)
416 wxMenu
*menu
= node
->GetData();
417 result
= FindMenuItemByIdRecursive( menu
, id
);
418 node
= node
->GetNext();
423 *menuForItem
= result ? result
->GetMenu() : NULL
;
429 void wxMenuBar
::EnableTop( size_t pos
, bool flag
)
431 wxMenuList
::compatibility_iterator node
= m_menus
.Item( pos
);
433 wxCHECK_RET( node
, wxT("menu not found") );
435 wxMenu
* menu
= node
->GetData();
438 gtk_widget_set_sensitive( menu
->m_owner
, flag
);
441 bool wxMenuBar
::IsEnabledTop(size_t pos
) const
443 wxMenuList
::compatibility_iterator node
= m_menus
.Item( pos
);
444 wxCHECK_MSG( node
, false, wxS("invalid index in IsEnabledTop") );
445 wxMenu
* const menu
= node
->GetData();
446 wxCHECK_MSG( menu
->m_owner
, true, wxS("no menu owner?") );
447 return gtk_widget_get_sensitive( menu
->m_owner
) != 0;
450 wxString wxMenuBar
::GetMenuLabel( size_t pos
) const
452 wxMenuList
::compatibility_iterator node
= m_menus
.Item( pos
);
454 wxCHECK_MSG( node
, wxT("invalid"), wxT("menu not found") );
456 wxMenu
* menu
= node
->GetData();
458 return menu
->GetTitle();
461 void wxMenuBar
::SetMenuLabel( size_t pos
, const wxString
& label
)
463 wxMenuList
::compatibility_iterator node
= m_menus
.Item( pos
);
465 wxCHECK_RET( node
, wxT("menu not found") );
467 wxMenu
* menu
= node
->GetData();
469 const wxString
str(wxConvertMnemonicsToGTK(label
));
471 menu
->SetTitle( str
);
474 gtk_label_set_text_with_mnemonic(GTK_LABEL(gtk_bin_get_child(GTK_BIN(menu
->m_owner
))), wxGTK_CONV(str
));
477 //-----------------------------------------------------------------------------
479 //-----------------------------------------------------------------------------
482 static void menuitem_activate(GtkWidget
*, wxMenuItem
* item
)
484 if (!item
->IsEnabled())
487 // Unity hack: under Ubuntu Unity the global menu bar is not affected by a
488 // modal dialog being shown, so the user can select a menu item before
489 // hiding the dialog and, in particular, a new instance of the same dialog
490 // can be shown again, breaking a lot of programs not expecting this.
492 // So explicitly ignore any menu events generated while any modal dialogs
494 if ( wxOpenModalDialogsCount
)
497 int id
= item
->GetId();
498 if (id
== wxGTK_TITLE_ID
)
500 // ignore events from the menu title
504 if (item
->IsCheckable())
506 bool isReallyChecked
= item
->IsChecked(),
507 isInternallyChecked
= item
->wxMenuItemBase
::IsChecked();
509 // ensure that the internal state is always consistent with what is
510 // shown on the screen
511 item
->wxMenuItemBase
::Check(isReallyChecked
);
513 // we must not report the events for the radio button going up nor the
514 // events resulting from the calls to wxMenuItem::Check()
515 if ( (item
->GetKind() == wxITEM_RADIO
&& !isReallyChecked
) ||
516 (isInternallyChecked
== isReallyChecked
) )
522 wxMenu
* menu
= item
->GetMenu();
523 menu
->SendEvent(id
, item
->IsCheckable() ? item
->IsChecked() : -1);
527 //-----------------------------------------------------------------------------
529 //-----------------------------------------------------------------------------
532 static void menuitem_select(GtkWidget
*, wxMenuItem
* item
)
534 if (!item
->IsEnabled())
537 wxMenuEvent
event(wxEVT_MENU_HIGHLIGHT
, item
->GetId());
538 DoCommonMenuCallbackCode(item
->GetMenu(), event
);
542 //-----------------------------------------------------------------------------
544 //-----------------------------------------------------------------------------
547 static void menuitem_deselect(GtkWidget
*, wxMenuItem
* item
)
549 if (!item
->IsEnabled())
552 wxMenuEvent
event( wxEVT_MENU_HIGHLIGHT
, -1 );
553 DoCommonMenuCallbackCode(item
->GetMenu(), event
);
557 //-----------------------------------------------------------------------------
559 //-----------------------------------------------------------------------------
561 wxMenuItem
*wxMenuItemBase
::New(wxMenu
*parentMenu
,
563 const wxString
& name
,
564 const wxString
& help
,
568 return new wxMenuItem(parentMenu
, id
, name
, help
, kind
, subMenu
);
571 wxMenuItem
::wxMenuItem(wxMenu
*parentMenu
,
573 const wxString
& text
,
574 const wxString
& help
,
577 : wxMenuItemBase(parentMenu
, id
, text
, help
, kind
, subMenu
)
582 #if WXWIN_COMPATIBILITY_2_8
583 wxMenuItem
::wxMenuItem(wxMenu
*parentMenu
,
585 const wxString
& text
,
586 const wxString
& help
,
589 : wxMenuItemBase(parentMenu
, id
, text
, help
,
590 isCheckable ? wxITEM_CHECK
: wxITEM_NORMAL
, subMenu
)
596 wxMenuItem
::~wxMenuItem()
599 g_object_unref(m_menuItem
);
600 // don't delete menu items, the menus take care of that
603 void wxMenuItem
::SetMenuItem(GtkWidget
* menuItem
)
606 g_object_unref(m_menuItem
);
607 m_menuItem
= menuItem
;
609 g_object_ref(menuItem
);
612 void wxMenuItem
::SetItemLabel( const wxString
& str
)
617 // remove old accelerator
619 GdkModifierType accel_mods
;
620 wxGetGtkAccel(this, &accel_key
, &accel_mods
);
623 gtk_widget_remove_accelerator(
624 m_menuItem
, m_parentMenu
->m_accel
, accel_key
, accel_mods
);
627 #endif // wxUSE_ACCEL
628 wxMenuItemBase
::SetItemLabel(str
);
633 void wxMenuItem
::SetGtkLabel()
635 const wxString text
= wxConvertMnemonicsToGTK(m_text
.BeforeFirst('\t'));
636 GtkLabel
* label
= GTK_LABEL(gtk_bin_get_child(GTK_BIN(m_menuItem
)));
637 gtk_label_set_text_with_mnemonic(label
, wxGTK_CONV_SYS(text
));
640 GdkModifierType accel_mods
;
641 wxGetGtkAccel(this, &accel_key
, &accel_mods
);
644 gtk_widget_add_accelerator(
645 m_menuItem
, "activate", m_parentMenu
->m_accel
,
646 accel_key
, accel_mods
, GTK_ACCEL_VISIBLE
);
648 #endif // wxUSE_ACCEL
651 void wxMenuItem
::SetBitmap(const wxBitmap
& bitmap
)
653 if (m_kind
== wxITEM_NORMAL
)
657 wxFAIL_MSG("only normal menu items can have bitmaps");
661 void wxMenuItem
::Check( bool check
)
663 wxCHECK_RET( m_menuItem
, wxT("invalid menu item") );
665 if (check
== m_isChecked
)
668 wxMenuItemBase
::Check( check
);
674 gtk_check_menu_item_set_active( (GtkCheckMenuItem
*)m_menuItem
, (gint
)check
);
678 wxFAIL_MSG( wxT("can't check this item") );
682 void wxMenuItem
::Enable( bool enable
)
684 wxCHECK_RET( m_menuItem
, wxT("invalid menu item") );
686 gtk_widget_set_sensitive( m_menuItem
, enable
);
687 wxMenuItemBase
::Enable( enable
);
690 bool wxMenuItem
::IsChecked() const
692 wxCHECK_MSG( m_menuItem
, false, wxT("invalid menu item") );
694 wxCHECK_MSG( IsCheckable(), false,
695 wxT("can't get state of uncheckable item!") );
697 return gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(m_menuItem
)) != 0;
700 //-----------------------------------------------------------------------------
702 //-----------------------------------------------------------------------------
706 static void menu_map(GtkWidget
*, wxMenu
* menu
)
708 wxMenuEvent
event(wxEVT_MENU_OPEN
, menu
->m_popupShown ?
-1 : 0, menu
);
709 DoCommonMenuCallbackCode(menu
, event
);
712 // "hide" from m_menu
713 static void menu_hide(GtkWidget
*, wxMenu
* menu
)
715 // When using Ubuntu Unity desktop environment we get "hide" signal even
716 // when the window is not shown yet because Unity hides all the menus to
717 // show them only in the global menu bar. Just ignore this even instead of
718 // crashing in DoCommonMenuCallbackCode().
719 if ( !menu
->GetWindow() )
722 wxMenuEvent
event(wxEVT_MENU_CLOSE
, menu
->m_popupShown ?
-1 : 0, menu
);
723 menu
->m_popupShown
= false;
724 DoCommonMenuCallbackCode(menu
, event
);
728 // "can_activate_accel" from menu item
730 static gboolean
can_activate_accel(GtkWidget
*, guint
, wxMenu
* menu
)
733 // always allow our "activate" handler to be called
740 m_popupShown
= false;
742 m_accel
= gtk_accel_group_new();
743 m_menu
= gtk_menu_new();
744 g_object_ref_sink(m_menu
);
748 // Tearoffs are entries, just like separators. So if we want this
749 // menu to be a tear-off one, we just append a tearoff entry
751 if ( m_style
& wxMENU_TEAROFF
)
753 GtkWidget
*tearoff
= gtk_tearoff_menu_item_new();
755 gtk_menu_shell_append(GTK_MENU_SHELL(m_menu
), tearoff
);
758 // append the title as the very first entry if we have it
759 if ( !m_title
.empty() )
761 Append(wxGTK_TITLE_ID
, m_title
);
765 // "show" occurs for sub-menus which are not showing, so use "map" instead
766 g_signal_connect(m_menu
, "map", G_CALLBACK(menu_map
), this);
767 g_signal_connect(m_menu
, "hide", G_CALLBACK(menu_hide
), this);
772 // Destroying a menu generates a "hide" signal even if it's not shown
773 // currently, so disconnect it to avoid dummy wxEVT_MENU_CLOSE events
775 g_signal_handlers_disconnect_matched(m_menu
,
776 GSignalMatchType(G_SIGNAL_MATCH_DATA
), 0, 0, NULL
, NULL
, this);
780 gtk_widget_destroy(m_owner
);
781 g_object_unref(m_owner
);
784 gtk_widget_destroy(m_menu
);
786 g_object_unref(m_menu
);
787 g_object_unref(m_accel
);
790 void wxMenu
::SetLayoutDirection(const wxLayoutDirection dir
)
793 wxWindow
::GTKSetLayout(m_owner
, dir
);
794 //else: will be called later by wxMenuBar again
797 wxLayoutDirection wxMenu
::GetLayoutDirection() const
799 return wxWindow
::GTKGetLayout(m_owner
);
802 wxString wxMenu
::GetTitle() const
804 return wxConvertMnemonicsFromGTK(wxMenuBase
::GetTitle());
807 void wxMenu
::GtkAppend(wxMenuItem
* mitem
, int pos
)
810 switch (mitem
->GetKind())
812 case wxITEM_SEPARATOR
:
813 menuItem
= gtk_separator_menu_item_new();
816 menuItem
= gtk_check_menu_item_new_with_label("");
820 // See if we need to create a new radio group for this item or
821 // add it to an existing one.
822 wxMenuItem
* radioGroupItem
= NULL
;
824 const size_t numItems
= GetMenuItemCount();
825 const size_t n
= pos
== -1 ? numItems
- 1 : size_t(pos
);
829 wxMenuItem
* const itemPrev
= FindItemByPosition(n
- 1);
830 if ( itemPrev
->GetKind() == wxITEM_RADIO
)
832 // Appending an item after an existing radio item puts
833 // it into the same radio group.
834 radioGroupItem
= itemPrev
;
838 if (radioGroupItem
== NULL
&& n
!= numItems
- 1)
840 wxMenuItem
* const itemNext
= FindItemByPosition(n
+ 1);
841 if ( itemNext
->GetKind() == wxITEM_RADIO
)
843 // Inserting an item before an existing radio item
844 // also puts it into the existing radio group.
845 radioGroupItem
= itemNext
;
849 GSList
* group
= NULL
;
850 if ( radioGroupItem
)
852 group
= gtk_radio_menu_item_get_group(
853 GTK_RADIO_MENU_ITEM(radioGroupItem
->GetMenuItem())
857 menuItem
= gtk_radio_menu_item_new_with_label(group
, "");
861 wxFAIL_MSG("unexpected menu item kind");
864 const wxBitmap
& bitmap
= mitem
->GetBitmap();
868 // always use pixbuf, because pixmap mask does not
869 // work with disabled images in some themes
870 GtkWidget
* image
= gtk_image_new_from_pixbuf(bitmap
.GetPixbuf());
871 menuItem
= gtk_image_menu_item_new_with_label("");
872 gtk_widget_show(image
);
873 gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menuItem
), image
);
875 else if ((stockid
= wxGetStockGtkID(mitem
->GetId())) != NULL
)
876 // use stock bitmap for this item if available on the assumption
877 // that it never hurts to follow GTK+ conventions more closely
878 menuItem
= gtk_image_menu_item_new_from_stock(stockid
, NULL
);
880 menuItem
= gtk_menu_item_new_with_label("");
883 mitem
->SetMenuItem(menuItem
);
885 gtk_menu_shell_insert(GTK_MENU_SHELL(m_menu
), menuItem
, pos
);
887 gtk_widget_show( menuItem
);
889 if ( !mitem
->IsSeparator() )
891 mitem
->SetGtkLabel();
892 g_signal_connect (menuItem
, "select",
893 G_CALLBACK(menuitem_select
), mitem
);
894 g_signal_connect (menuItem
, "deselect",
895 G_CALLBACK(menuitem_deselect
), mitem
);
897 if ( mitem
->IsSubMenu() && mitem
->GetKind() != wxITEM_RADIO
&& mitem
->GetKind() != wxITEM_CHECK
)
899 gtk_menu_item_set_submenu( GTK_MENU_ITEM(menuItem
), mitem
->GetSubMenu()->m_menu
);
901 gtk_widget_show( mitem
->GetSubMenu()->m_menu
);
905 g_signal_connect(menuItem
, "can_activate_accel",
906 G_CALLBACK(can_activate_accel
), this);
907 g_signal_connect (menuItem
, "activate",
908 G_CALLBACK(menuitem_activate
),
914 wxMenuItem
* wxMenu
::DoAppend(wxMenuItem
*mitem
)
916 if (wxMenuBase
::DoAppend(mitem
))
924 wxMenuItem
* wxMenu
::DoInsert(size_t pos
, wxMenuItem
*item
)
926 if (wxMenuBase
::DoInsert(pos
, item
))
928 GtkAppend(item
, int(pos
));
934 wxMenuItem
*wxMenu
::DoRemove(wxMenuItem
*item
)
936 if ( !wxMenuBase
::DoRemove(item
) )
939 GtkWidget
* const mitem
= item
->GetMenuItem();
941 g_signal_handlers_disconnect_matched(mitem
,
942 GSignalMatchType(G_SIGNAL_MATCH_DATA
), 0, 0, NULL
, NULL
, item
);
945 gtk_menu_item_set_submenu(GTK_MENU_ITEM(mitem
), NULL
);
947 gtk_menu_item_remove_submenu(GTK_MENU_ITEM(mitem
));
950 gtk_widget_destroy(mitem
);
951 item
->SetMenuItem(NULL
);
956 void wxMenu
::Attach(wxMenuBarBase
*menubar
)
958 wxMenuBase
::Attach(menubar
);
960 // inherit layout direction from menubar.
961 SetLayoutDirection(menubar
->GetLayoutDirection());
964 // ----------------------------------------------------------------------------
966 // ----------------------------------------------------------------------------
970 static wxString
GetGtkHotKey( const wxMenuItem
& item
)
974 wxAcceleratorEntry
*accel
= item
.GetAccel();
977 int flags
= accel
->GetFlags();
978 if ( flags
& wxACCEL_ALT
)
979 hotkey
+= wxT("<alt>");
980 if ( flags
& wxACCEL_CTRL
)
981 hotkey
+= wxT("<control>");
982 if ( flags
& wxACCEL_SHIFT
)
983 hotkey
+= wxT("<shift>");
985 int code
= accel
->GetKeyCode();
1012 hotkey
+= wxString
::Format(wxT("F%d"), code
- WXK_F1
+ 1);
1015 // TODO: we should use gdk_keyval_name() (a.k.a.
1016 // XKeysymToString) here as well as hardcoding the keysym
1017 // names this might be not portable
1019 hotkey
<< wxT("Insert" );
1022 hotkey
<< wxT("Delete" );
1025 hotkey
<< wxT("Up" );
1028 hotkey
<< wxT("Down" );
1031 hotkey
<< wxT("Page_Up" );
1034 hotkey
<< wxT("Page_Down" );
1037 hotkey
<< wxT("Left" );
1040 hotkey
<< wxT("Right" );
1043 hotkey
<< wxT("Home" );
1046 hotkey
<< wxT("End" );
1049 hotkey
<< wxT("Return" );
1052 hotkey
<< wxT("BackSpace" );
1055 hotkey
<< wxT("Tab" );
1058 hotkey
<< wxT("Esc" );
1061 hotkey
<< wxT("space" );
1064 hotkey
<< wxT("Multiply" );
1067 hotkey
<< wxT("Add" );
1070 hotkey
<< wxT("Separator" );
1073 hotkey
<< wxT("Subtract" );
1076 hotkey
<< wxT("Decimal" );
1079 hotkey
<< wxT("Divide" );
1082 hotkey
<< wxT("Cancel" );
1085 hotkey
<< wxT("Clear" );
1088 hotkey
<< wxT("Menu" );
1091 hotkey
<< wxT("Pause" );
1094 hotkey
<< wxT("Capital" );
1097 hotkey
<< wxT("Select" );
1100 hotkey
<< wxT("Print" );
1103 hotkey
<< wxT("Execute" );
1106 hotkey
<< wxT("Snapshot" );
1109 hotkey
<< wxT("Help" );
1112 hotkey
<< wxT("Num_Lock" );
1115 hotkey
<< wxT("Scroll_Lock" );
1117 case WXK_NUMPAD_INSERT
:
1118 hotkey
<< wxT("KP_Insert" );
1120 case WXK_NUMPAD_DELETE
:
1121 hotkey
<< wxT("KP_Delete" );
1123 case WXK_NUMPAD_SPACE
:
1124 hotkey
<< wxT("KP_Space" );
1126 case WXK_NUMPAD_TAB
:
1127 hotkey
<< wxT("KP_Tab" );
1129 case WXK_NUMPAD_ENTER
:
1130 hotkey
<< wxT("KP_Enter" );
1132 case WXK_NUMPAD_F1
: case WXK_NUMPAD_F2
: case WXK_NUMPAD_F3
:
1134 hotkey
+= wxString
::Format(wxT("KP_F%d"), code
- WXK_NUMPAD_F1
+ 1);
1136 case WXK_NUMPAD_HOME
:
1137 hotkey
<< wxT("KP_Home" );
1139 case WXK_NUMPAD_LEFT
:
1140 hotkey
<< wxT("KP_Left" );
1143 hotkey
<< wxT("KP_Up" );
1145 case WXK_NUMPAD_RIGHT
:
1146 hotkey
<< wxT("KP_Right" );
1148 case WXK_NUMPAD_DOWN
:
1149 hotkey
<< wxT("KP_Down" );
1151 case WXK_NUMPAD_PAGEUP
:
1152 hotkey
<< wxT("KP_Page_Up" );
1154 case WXK_NUMPAD_PAGEDOWN
:
1155 hotkey
<< wxT("KP_Page_Down" );
1157 case WXK_NUMPAD_END
:
1158 hotkey
<< wxT("KP_End" );
1160 case WXK_NUMPAD_BEGIN
:
1161 hotkey
<< wxT("KP_Begin" );
1163 case WXK_NUMPAD_EQUAL
:
1164 hotkey
<< wxT("KP_Equal" );
1166 case WXK_NUMPAD_MULTIPLY
:
1167 hotkey
<< wxT("KP_Multiply" );
1169 case WXK_NUMPAD_ADD
:
1170 hotkey
<< wxT("KP_Add" );
1172 case WXK_NUMPAD_SEPARATOR
:
1173 hotkey
<< wxT("KP_Separator" );
1175 case WXK_NUMPAD_SUBTRACT
:
1176 hotkey
<< wxT("KP_Subtract" );
1178 case WXK_NUMPAD_DECIMAL
:
1179 hotkey
<< wxT("KP_Decimal" );
1181 case WXK_NUMPAD_DIVIDE
:
1182 hotkey
<< wxT("KP_Divide" );
1184 case WXK_NUMPAD0
: case WXK_NUMPAD1
: case WXK_NUMPAD2
:
1185 case WXK_NUMPAD3
: case WXK_NUMPAD4
: case WXK_NUMPAD5
:
1186 case WXK_NUMPAD6
: case WXK_NUMPAD7
: case WXK_NUMPAD8
: case WXK_NUMPAD9
:
1187 hotkey
+= wxString
::Format(wxT("KP_%d"), code
- WXK_NUMPAD0
);
1189 case WXK_WINDOWS_LEFT
:
1190 hotkey
<< wxT("Super_L" );
1192 case WXK_WINDOWS_RIGHT
:
1193 hotkey
<< wxT("Super_R" );
1195 case WXK_WINDOWS_MENU
:
1196 hotkey
<< wxT("Menu" );
1199 hotkey
<< wxT("Command" );
1201 /* These probably wouldn't work as there is no SpecialX in gdk/keynames.txt
1202 case WXK_SPECIAL1: case WXK_SPECIAL2: case WXK_SPECIAL3: case WXK_SPECIAL4:
1203 case WXK_SPECIAL5: case WXK_SPECIAL6: case WXK_SPECIAL7: case WXK_SPECIAL8:
1204 case WXK_SPECIAL9: case WXK_SPECIAL10: case WXK_SPECIAL11: case WXK_SPECIAL12:
1205 case WXK_SPECIAL13: case WXK_SPECIAL14: case WXK_SPECIAL15: case WXK_SPECIAL16:
1206 case WXK_SPECIAL17: case WXK_SPECIAL18: case WXK_SPECIAL19: case WXK_SPECIAL20:
1207 hotkey += wxString::Format(wxT("Special%d"), code - WXK_SPECIAL1 + 1);
1210 // if there are any other keys wxAcceleratorEntry::Create() may
1211 // return, we should process them here
1217 name
= wxGTK_CONV_BACK_SYS(gdk_keyval_name((guint
)code
));
1218 if ( !name
.empty() )
1225 wxFAIL_MSG( wxT("unknown keyboard accel") );
1235 wxGetGtkAccel(const wxMenuItem
* item
, guint
* accel_key
, GdkModifierType
* accel_mods
)
1238 const wxString string
= GetGtkHotKey(*item
);
1239 if (!string
.empty())
1240 gtk_accelerator_parse(wxGTK_CONV_SYS(string
), accel_key
, accel_mods
);
1243 GtkStockItem stock_item
;
1244 const char* stockid
= wxGetStockGtkID(item
->GetId());
1245 if (stockid
&& gtk_stock_lookup(stockid
, &stock_item
))
1247 *accel_key
= stock_item
.keyval
;
1248 *accel_mods
= stock_item
.modifier
;
1252 #endif // wxUSE_ACCEL
1254 const char *wxGetStockGtkID(wxWindowID id
)
1256 #define STOCKITEM(wx,gtk) \
1260 #if GTK_CHECK_VERSION(2,8,0)
1261 #define STOCKITEM_28(wx,gtk) STOCKITEM(wx,gtk)
1263 #define STOCKITEM_28(wx,gtk)
1266 #if GTK_CHECK_VERSION(2,10,0)
1267 #define STOCKITEM_210(wx,gtk) STOCKITEM(wx,gtk)
1269 #define STOCKITEM_210(wx,gtk)
1275 STOCKITEM(wxID_ABOUT
, GTK_STOCK_ABOUT
)
1276 STOCKITEM(wxID_ADD
, GTK_STOCK_ADD
)
1277 STOCKITEM(wxID_APPLY
, GTK_STOCK_APPLY
)
1278 STOCKITEM(wxID_BACKWARD
, GTK_STOCK_GO_BACK
)
1279 STOCKITEM(wxID_BOLD
, GTK_STOCK_BOLD
)
1280 STOCKITEM(wxID_BOTTOM
, GTK_STOCK_GOTO_BOTTOM
)
1281 STOCKITEM(wxID_CANCEL
, GTK_STOCK_CANCEL
)
1282 STOCKITEM(wxID_CDROM
, GTK_STOCK_CDROM
)
1283 STOCKITEM(wxID_CLEAR
, GTK_STOCK_CLEAR
)
1284 STOCKITEM(wxID_CLOSE
, GTK_STOCK_CLOSE
)
1285 STOCKITEM(wxID_CONVERT
, GTK_STOCK_CONVERT
)
1286 STOCKITEM(wxID_COPY
, GTK_STOCK_COPY
)
1287 STOCKITEM(wxID_CUT
, GTK_STOCK_CUT
)
1288 STOCKITEM(wxID_DELETE
, GTK_STOCK_DELETE
)
1289 STOCKITEM(wxID_DOWN
, GTK_STOCK_GO_DOWN
)
1290 STOCKITEM(wxID_EDIT
, GTK_STOCK_EDIT
)
1291 STOCKITEM(wxID_EXECUTE
, GTK_STOCK_EXECUTE
)
1292 STOCKITEM(wxID_EXIT
, GTK_STOCK_QUIT
)
1293 STOCKITEM(wxID_FILE
, GTK_STOCK_FILE
)
1294 STOCKITEM(wxID_FIND
, GTK_STOCK_FIND
)
1295 STOCKITEM(wxID_FIRST
, GTK_STOCK_GOTO_FIRST
)
1296 STOCKITEM(wxID_FLOPPY
, GTK_STOCK_FLOPPY
)
1297 STOCKITEM(wxID_FORWARD
, GTK_STOCK_GO_FORWARD
)
1298 STOCKITEM(wxID_HARDDISK
, GTK_STOCK_HARDDISK
)
1299 STOCKITEM(wxID_HELP
, GTK_STOCK_HELP
)
1300 STOCKITEM(wxID_HOME
, GTK_STOCK_HOME
)
1301 STOCKITEM(wxID_INDENT
, GTK_STOCK_INDENT
)
1302 STOCKITEM(wxID_INDEX
, GTK_STOCK_INDEX
)
1303 STOCKITEM_28(wxID_INFO
, GTK_STOCK_INFO
)
1304 STOCKITEM(wxID_ITALIC
, GTK_STOCK_ITALIC
)
1305 STOCKITEM(wxID_JUMP_TO
, GTK_STOCK_JUMP_TO
)
1306 STOCKITEM(wxID_JUSTIFY_CENTER
, GTK_STOCK_JUSTIFY_CENTER
)
1307 STOCKITEM(wxID_JUSTIFY_FILL
, GTK_STOCK_JUSTIFY_FILL
)
1308 STOCKITEM(wxID_JUSTIFY_LEFT
, GTK_STOCK_JUSTIFY_LEFT
)
1309 STOCKITEM(wxID_JUSTIFY_RIGHT
, GTK_STOCK_JUSTIFY_RIGHT
)
1310 STOCKITEM(wxID_LAST
, GTK_STOCK_GOTO_LAST
)
1311 STOCKITEM(wxID_NETWORK
, GTK_STOCK_NETWORK
)
1312 STOCKITEM(wxID_NEW
, GTK_STOCK_NEW
)
1313 STOCKITEM(wxID_NO
, GTK_STOCK_NO
)
1314 STOCKITEM(wxID_OK
, GTK_STOCK_OK
)
1315 STOCKITEM(wxID_OPEN
, GTK_STOCK_OPEN
)
1316 STOCKITEM(wxID_PASTE
, GTK_STOCK_PASTE
)
1317 STOCKITEM(wxID_PREFERENCES
, GTK_STOCK_PREFERENCES
)
1318 STOCKITEM(wxID_PREVIEW
, GTK_STOCK_PRINT_PREVIEW
)
1319 STOCKITEM(wxID_PRINT
, GTK_STOCK_PRINT
)
1320 STOCKITEM(wxID_PROPERTIES
, GTK_STOCK_PROPERTIES
)
1321 STOCKITEM(wxID_REDO
, GTK_STOCK_REDO
)
1322 STOCKITEM(wxID_REFRESH
, GTK_STOCK_REFRESH
)
1323 STOCKITEM(wxID_REMOVE
, GTK_STOCK_REMOVE
)
1324 STOCKITEM(wxID_REPLACE
, GTK_STOCK_FIND_AND_REPLACE
)
1325 STOCKITEM(wxID_REVERT_TO_SAVED
, GTK_STOCK_REVERT_TO_SAVED
)
1326 STOCKITEM(wxID_SAVE
, GTK_STOCK_SAVE
)
1327 STOCKITEM(wxID_SAVEAS
, GTK_STOCK_SAVE_AS
)
1328 STOCKITEM_210(wxID_SELECTALL
, GTK_STOCK_SELECT_ALL
)
1329 STOCKITEM(wxID_SELECT_COLOR
, GTK_STOCK_SELECT_COLOR
)
1330 STOCKITEM(wxID_SELECT_FONT
, GTK_STOCK_SELECT_FONT
)
1331 STOCKITEM(wxID_SORT_ASCENDING
, GTK_STOCK_SORT_ASCENDING
)
1332 STOCKITEM(wxID_SORT_DESCENDING
, GTK_STOCK_SORT_DESCENDING
)
1333 STOCKITEM(wxID_SPELL_CHECK
, GTK_STOCK_SPELL_CHECK
)
1334 STOCKITEM(wxID_STOP
, GTK_STOCK_STOP
)
1335 STOCKITEM(wxID_STRIKETHROUGH
, GTK_STOCK_STRIKETHROUGH
)
1336 STOCKITEM(wxID_TOP
, GTK_STOCK_GOTO_TOP
)
1337 STOCKITEM(wxID_UNDELETE
, GTK_STOCK_UNDELETE
)
1338 STOCKITEM(wxID_UNDERLINE
, GTK_STOCK_UNDERLINE
)
1339 STOCKITEM(wxID_UNDO
, GTK_STOCK_UNDO
)
1340 STOCKITEM(wxID_UNINDENT
, GTK_STOCK_UNINDENT
)
1341 STOCKITEM(wxID_UP
, GTK_STOCK_GO_UP
)
1342 STOCKITEM(wxID_YES
, GTK_STOCK_YES
)
1343 STOCKITEM(wxID_ZOOM_100
, GTK_STOCK_ZOOM_100
)
1344 STOCKITEM(wxID_ZOOM_FIT
, GTK_STOCK_ZOOM_FIT
)
1345 STOCKITEM(wxID_ZOOM_IN
, GTK_STOCK_ZOOM_IN
)
1346 STOCKITEM(wxID_ZOOM_OUT
, GTK_STOCK_ZOOM_OUT
)
1357 #endif // wxUSE_MENUS