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"
27 #include "wx/gtk/private.h"
28 #include "wx/gtk/private/mnemonics.h"
30 // we use normal item but with a special id for the menu title
31 static const int wxGTK_TITLE_ID
= -3;
33 // forward declare it as it's used by wxMenuBar too when using Hildon
36 static void gtk_menu_clicked_callback(GtkWidget
*widget
, wxMenu
*menu
);
40 static void wxGetGtkAccel(const wxMenuItem
*, guint
*, GdkModifierType
*);
43 static void DoCommonMenuCallbackCode(wxMenu
*menu
, wxMenuEvent
& event
)
45 event
.SetEventObject( menu
);
47 wxEvtHandler
* handler
= menu
->GetEventHandler();
48 if (handler
&& handler
->SafelyProcessEvent(event
))
51 wxWindow
*win
= menu
->GetInvokingWindow();
53 win
->HandleWindowEvent( event
);
56 //-----------------------------------------------------------------------------
58 //-----------------------------------------------------------------------------
60 IMPLEMENT_DYNAMIC_CLASS(wxMenuBar
,wxWindow
)
62 void wxMenuBar::Init(size_t n
, wxMenu
*menus
[], const wxString titles
[], long style
)
64 m_invokingWindow
= NULL
;
67 // Hildon window uses a single menu instead of a menu bar, so wxMenuBar is
68 // the same as menu in this case
70 m_menubar
= gtk_menu_new();
71 #else // !wxUSE_LIBHILDON
72 if (!PreCreation( NULL
, wxDefaultPosition
, wxDefaultSize
) ||
73 !CreateBase( NULL
, -1, wxDefaultPosition
, wxDefaultSize
, style
, wxDefaultValidator
, wxT("menubar") ))
75 wxFAIL_MSG( wxT("wxMenuBar creation failed") );
79 m_menubar
= gtk_menu_bar_new();
81 if (style
& wxMB_DOCKABLE
)
83 m_widget
= gtk_handle_box_new();
84 gtk_container_add(GTK_CONTAINER(m_widget
), m_menubar
);
85 gtk_widget_show(m_menubar
);
95 #endif // wxUSE_LIBHILDON/!wxUSE_LIBHILDON
97 for (size_t i
= 0; i
< n
; ++i
)
98 Append(menus
[i
], titles
[i
]);
101 wxMenuBar::wxMenuBar(size_t n
, wxMenu
*menus
[], const wxString titles
[], long style
)
103 Init(n
, menus
, titles
, style
);
106 wxMenuBar::wxMenuBar(long style
)
108 Init(0, NULL
, NULL
, style
);
111 wxMenuBar::wxMenuBar()
113 Init(0, NULL
, NULL
, 0);
116 wxMenuBar::~wxMenuBar()
121 wxMenubarUnsetInvokingWindow(wxMenu
* menu
, wxWindow
* win
, GtkWindow
* tlw
= NULL
)
123 menu
->SetInvokingWindow( (wxWindow
*) NULL
);
125 // support for native hot keys
129 tlw
= GTK_WINDOW(wxGetTopLevelParent(win
)->m_widget
);
130 if (g_slist_find(menu
->m_accel
->acceleratables
, tlw
))
131 gtk_window_remove_accel_group(tlw
, menu
->m_accel
);
134 wxMenuItemList::compatibility_iterator node
= menu
->GetMenuItems().GetFirst();
137 wxMenuItem
*menuitem
= node
->GetData();
138 if (menuitem
->IsSubMenu())
139 wxMenubarUnsetInvokingWindow(menuitem
->GetSubMenu(), win
, tlw
);
140 node
= node
->GetNext();
145 wxMenubarSetInvokingWindow(wxMenu
* menu
, wxWindow
* win
, GtkWindow
* tlw
= NULL
)
147 menu
->SetInvokingWindow( win
);
149 // support for native hot keys
153 tlw
= GTK_WINDOW(wxGetTopLevelParent(win
)->m_widget
);
154 if (!g_slist_find(menu
->m_accel
->acceleratables
, tlw
))
155 gtk_window_add_accel_group(tlw
, menu
->m_accel
);
158 wxMenuItemList::compatibility_iterator node
= menu
->GetMenuItems().GetFirst();
161 wxMenuItem
*menuitem
= node
->GetData();
162 if (menuitem
->IsSubMenu())
163 wxMenubarSetInvokingWindow(menuitem
->GetSubMenu(), win
, tlw
);
164 node
= node
->GetNext();
168 void wxMenuBar::SetInvokingWindow( wxWindow
*win
)
170 m_invokingWindow
= win
;
172 wxMenuList::compatibility_iterator node
= m_menus
.GetFirst();
175 wxMenu
*menu
= node
->GetData();
176 wxMenubarSetInvokingWindow( menu
, win
);
177 node
= node
->GetNext();
181 void wxMenuBar::SetLayoutDirection(wxLayoutDirection dir
)
183 if ( dir
== wxLayout_Default
)
185 const wxWindow
*const frame
= GetFrame();
188 // inherit layout from frame.
189 dir
= frame
->GetLayoutDirection();
191 else // use global layout
193 dir
= wxTheApp
->GetLayoutDirection();
197 if ( dir
== wxLayout_Default
)
200 GTKSetLayout(m_menubar
, dir
);
202 // also set the layout of all menus we already have (new ones will inherit
203 // the current layout)
204 for ( wxMenuList::compatibility_iterator node
= m_menus
.GetFirst();
206 node
= node
->GetNext() )
208 wxMenu
*const menu
= node
->GetData();
209 menu
->SetLayoutDirection(dir
);
213 wxLayoutDirection
wxMenuBar::GetLayoutDirection() const
215 return GTKGetLayout(m_menubar
);
218 void wxMenuBar::Attach(wxFrame
*frame
)
220 wxMenuBarBase::Attach(frame
);
222 SetLayoutDirection(wxLayout_Default
);
225 void wxMenuBar::UnsetInvokingWindow( wxWindow
*win
)
227 m_invokingWindow
= (wxWindow
*) NULL
;
229 wxMenuList::compatibility_iterator node
= m_menus
.GetFirst();
232 wxMenu
*menu
= node
->GetData();
233 wxMenubarUnsetInvokingWindow( menu
, win
);
234 node
= node
->GetNext();
238 bool wxMenuBar::Append( wxMenu
*menu
, const wxString
&title
)
240 if ( !wxMenuBarBase::Append( menu
, title
) )
243 return GtkAppend(menu
, title
);
246 bool wxMenuBar::GtkAppend(wxMenu
*menu
, const wxString
& title
, int pos
)
248 menu
->SetLayoutDirection(GetLayoutDirection());
251 // if the menu has only one item, append it directly to the top level menu
252 // instead of inserting a useless submenu
253 if ( menu
->GetMenuItemCount() == 1 )
255 wxMenuItem
* const item
= menu
->FindItemByPosition(0);
257 // remove both mnemonics and accelerator: neither is useful under Maemo
258 const wxString
str(wxStripMenuCodes(item
->GetItemLabel()));
260 if ( item
->IsSubMenu() )
261 return GtkAppend(item
->GetSubMenu(), str
, pos
);
263 menu
->m_owner
= gtk_menu_item_new_with_mnemonic( wxGTK_CONV( str
) );
265 g_signal_connect(menu
->m_owner
, "activate",
266 G_CALLBACK(gtk_menu_clicked_callback
), menu
);
267 item
->SetMenuItem(menu
->m_owner
);
270 #endif // wxUSE_LIBHILDON/!wxUSE_LIBHILDON
272 const wxString
str(wxConvertMnemonicsToGTK(title
));
274 // This doesn't have much effect right now.
275 menu
->SetTitle( str
);
277 // The "m_owner" is the "menu item"
278 menu
->m_owner
= gtk_menu_item_new_with_mnemonic( wxGTK_CONV( str
) );
280 gtk_menu_item_set_submenu( GTK_MENU_ITEM(menu
->m_owner
), menu
->m_menu
);
283 gtk_widget_show( menu
->m_owner
);
286 gtk_menu_shell_append( GTK_MENU_SHELL(m_menubar
), menu
->m_owner
);
288 gtk_menu_shell_insert( GTK_MENU_SHELL(m_menubar
), menu
->m_owner
, pos
);
290 // m_invokingWindow is set after wxFrame::SetMenuBar(). This call enables
291 // addings menu later on.
292 if (m_invokingWindow
)
293 wxMenubarSetInvokingWindow( menu
, m_invokingWindow
);
298 bool wxMenuBar::Insert(size_t pos
, wxMenu
*menu
, const wxString
& title
)
300 if ( !wxMenuBarBase::Insert(pos
, menu
, title
) )
305 if ( !GtkAppend(menu
, title
, (int)pos
) )
311 wxMenu
*wxMenuBar::Replace(size_t pos
, wxMenu
*menu
, const wxString
& title
)
313 // remove the old item and insert a new one
314 wxMenu
*menuOld
= Remove(pos
);
315 if ( menuOld
&& !Insert(pos
, menu
, title
) )
317 return (wxMenu
*) NULL
;
320 // either Insert() succeeded or Remove() failed and menuOld is NULL
324 wxMenu
*wxMenuBar::Remove(size_t pos
)
326 wxMenu
*menu
= wxMenuBarBase::Remove(pos
);
328 return (wxMenu
*) NULL
;
330 gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu
->m_owner
), NULL
);
331 gtk_container_remove(GTK_CONTAINER(m_menubar
), menu
->m_owner
);
333 gtk_widget_destroy( menu
->m_owner
);
334 menu
->m_owner
= NULL
;
336 if (m_invokingWindow
)
337 wxMenubarUnsetInvokingWindow( menu
, m_invokingWindow
);
342 static int FindMenuItemRecursive( const wxMenu
*menu
, const wxString
&menuString
, const wxString
&itemString
)
344 if (wxMenuItem::GetLabelText(wxConvertMnemonicsFromGTK(menu
->GetTitle())) == wxMenuItem::GetLabelText(menuString
))
346 int res
= menu
->FindItem( itemString
);
347 if (res
!= wxNOT_FOUND
)
351 wxMenuItemList::compatibility_iterator node
= menu
->GetMenuItems().GetFirst();
354 wxMenuItem
*item
= node
->GetData();
355 if (item
->IsSubMenu())
356 return FindMenuItemRecursive(item
->GetSubMenu(), menuString
, itemString
);
358 node
= node
->GetNext();
364 int wxMenuBar::FindMenuItem( const wxString
&menuString
, const wxString
&itemString
) const
366 wxMenuList::compatibility_iterator node
= m_menus
.GetFirst();
369 wxMenu
*menu
= node
->GetData();
370 int res
= FindMenuItemRecursive( menu
, menuString
, itemString
);
373 node
= node
->GetNext();
379 // Find a wxMenuItem using its id. Recurses down into sub-menus
380 static wxMenuItem
* FindMenuItemByIdRecursive(const wxMenu
* menu
, int id
)
382 wxMenuItem
* result
= menu
->FindChildItem(id
);
384 wxMenuItemList::compatibility_iterator node
= menu
->GetMenuItems().GetFirst();
385 while ( node
&& result
== NULL
)
387 wxMenuItem
*item
= node
->GetData();
388 if (item
->IsSubMenu())
390 result
= FindMenuItemByIdRecursive( item
->GetSubMenu(), id
);
392 node
= node
->GetNext();
398 wxMenuItem
* wxMenuBar::FindItem( int id
, wxMenu
**menuForItem
) const
400 wxMenuItem
* result
= 0;
401 wxMenuList::compatibility_iterator node
= m_menus
.GetFirst();
402 while (node
&& result
== 0)
404 wxMenu
*menu
= node
->GetData();
405 result
= FindMenuItemByIdRecursive( menu
, id
);
406 node
= node
->GetNext();
411 *menuForItem
= result
? result
->GetMenu() : (wxMenu
*)NULL
;
417 void wxMenuBar::EnableTop( size_t pos
, bool flag
)
419 wxMenuList::compatibility_iterator node
= m_menus
.Item( pos
);
421 wxCHECK_RET( node
, wxT("menu not found") );
423 wxMenu
* menu
= node
->GetData();
426 gtk_widget_set_sensitive( menu
->m_owner
, flag
);
429 wxString
wxMenuBar::GetMenuLabel( size_t pos
) const
431 wxMenuList::compatibility_iterator node
= m_menus
.Item( pos
);
433 wxCHECK_MSG( node
, wxT("invalid"), wxT("menu not found") );
435 wxMenu
* menu
= node
->GetData();
437 return wxConvertMnemonicsFromGTK(menu
->GetTitle());
440 void wxMenuBar::SetMenuLabel( size_t pos
, const wxString
& label
)
442 wxMenuList::compatibility_iterator node
= m_menus
.Item( pos
);
444 wxCHECK_RET( node
, wxT("menu not found") );
446 wxMenu
* menu
= node
->GetData();
448 const wxString
str(wxConvertMnemonicsToGTK(label
));
450 menu
->SetTitle( str
);
453 gtk_label_set_text_with_mnemonic( GTK_LABEL( GTK_BIN(menu
->m_owner
)->child
), wxGTK_CONV(str
) );
456 //-----------------------------------------------------------------------------
458 //-----------------------------------------------------------------------------
461 static void gtk_menu_clicked_callback( GtkWidget
*widget
, wxMenu
*menu
)
463 int id
= menu
->FindMenuIdByMenuItem(widget
);
465 /* should find it for normal (not popup) menu */
466 wxASSERT_MSG( (id
!= -1) || (menu
->GetInvokingWindow() != NULL
),
467 _T("menu item not found in gtk_menu_clicked_callback") );
469 if (!menu
->IsEnabled(id
))
472 wxMenuItem
* item
= menu
->FindChildItem( id
);
473 wxCHECK_RET( item
, wxT("error in menu item callback") );
475 if ( item
->GetId() == wxGTK_TITLE_ID
)
477 // ignore events from the menu title
481 if (item
->IsCheckable())
483 bool isReallyChecked
= item
->IsChecked(),
484 isInternallyChecked
= item
->wxMenuItemBase::IsChecked();
486 // ensure that the internal state is always consistent with what is
487 // shown on the screen
488 item
->wxMenuItemBase::Check(isReallyChecked
);
490 // we must not report the events for the radio button going up nor the
491 // events resulting from the calls to wxMenuItem::Check()
492 if ( (item
->GetKind() == wxITEM_RADIO
&& !isReallyChecked
) ||
493 (isInternallyChecked
== isReallyChecked
) )
500 // Is this menu on a menubar? (possibly nested)
501 wxFrame
* frame
= NULL
;
502 if(menu
->IsAttached())
503 frame
= menu
->GetMenuBar()->GetFrame();
505 // FIXME: why do we have to call wxFrame::GetEventHandler() directly here?
506 // normally wxMenu::SendEvent() should be enough, if it doesn't work
507 // in wxGTK then we have a bug in wxMenu::GetInvokingWindow() which
508 // should be fixed instead of working around it here...
511 // If it is attached then let the frame send the event.
512 // Don't call frame->ProcessCommand(id) because it toggles
513 // checkable items and we've already done that above.
514 wxCommandEvent
commandEvent(wxEVT_COMMAND_MENU_SELECTED
, id
);
515 commandEvent
.SetEventObject(frame
);
516 if (item
->IsCheckable())
517 commandEvent
.SetInt(item
->IsChecked());
519 frame
->HandleWindowEvent(commandEvent
);
523 // otherwise let the menu have it
524 menu
->SendEvent(id
, item
->IsCheckable() ? item
->IsChecked() : -1);
529 //-----------------------------------------------------------------------------
531 //-----------------------------------------------------------------------------
534 static void gtk_menu_hilight_callback( GtkWidget
*widget
, wxMenu
*menu
)
536 int id
= menu
->FindMenuIdByMenuItem(widget
);
538 wxASSERT( id
!= -1 ); // should find it!
540 if (!menu
->IsEnabled(id
))
543 wxMenuEvent
event( wxEVT_MENU_HIGHLIGHT
, id
);
544 event
.SetEventObject( menu
);
546 wxEvtHandler
* handler
= menu
->GetEventHandler();
547 if (handler
&& handler
->SafelyProcessEvent(event
))
550 wxWindow
*win
= menu
->GetInvokingWindow();
551 if (win
) win
->HandleWindowEvent( event
);
555 //-----------------------------------------------------------------------------
557 //-----------------------------------------------------------------------------
560 static void gtk_menu_nolight_callback( GtkWidget
*widget
, wxMenu
*menu
)
562 int id
= menu
->FindMenuIdByMenuItem(widget
);
564 wxASSERT( id
!= -1 ); // should find it!
566 if (!menu
->IsEnabled(id
))
569 wxMenuEvent
event( wxEVT_MENU_HIGHLIGHT
, -1 );
570 event
.SetEventObject( menu
);
572 wxEvtHandler
* handler
= menu
->GetEventHandler();
573 if (handler
&& handler
->SafelyProcessEvent(event
))
576 wxWindow
*win
= menu
->GetInvokingWindow();
578 win
->HandleWindowEvent( event
);
582 //-----------------------------------------------------------------------------
584 //-----------------------------------------------------------------------------
586 IMPLEMENT_DYNAMIC_CLASS(wxMenuItem
, wxObject
)
588 wxMenuItem
*wxMenuItemBase::New(wxMenu
*parentMenu
,
590 const wxString
& name
,
591 const wxString
& help
,
595 return new wxMenuItem(parentMenu
, id
, name
, help
, kind
, subMenu
);
598 wxMenuItem::wxMenuItem(wxMenu
*parentMenu
,
600 const wxString
& text
,
601 const wxString
& help
,
604 : wxMenuItemBase(parentMenu
, id
, text
, help
, kind
, subMenu
)
609 #if WXWIN_COMPATIBILITY_2_8
610 wxMenuItem::wxMenuItem(wxMenu
*parentMenu
,
612 const wxString
& text
,
613 const wxString
& help
,
616 : wxMenuItemBase(parentMenu
, id
, text
, help
,
617 isCheckable
? wxITEM_CHECK
: wxITEM_NORMAL
, subMenu
)
623 wxMenuItem::~wxMenuItem()
625 // don't delete menu items, the menus take care of that
628 // return the menu item text without any menu accels
631 wxString
wxMenuItemBase::GetLabelText(const wxString
& text
)
633 // The argument to this function will now always be in wxWidgets standard label
634 // format, not GTK+ format, so we do what the other ports do.
636 return wxStripMenuCodes(text
);
639 void wxMenuItem::SetItemLabel( const wxString
& str
)
644 // remove old accelerator
646 GdkModifierType accel_mods
;
647 wxGetGtkAccel(this, &accel_key
, &accel_mods
);
650 gtk_widget_remove_accelerator(
651 m_menuItem
, m_parentMenu
->m_accel
, accel_key
, accel_mods
);
654 #endif // wxUSE_ACCEL
655 wxMenuItemBase::SetItemLabel(str
);
660 void wxMenuItem::SetGtkLabel()
662 const wxString text
= wxConvertMnemonicsToGTK(m_text
.BeforeFirst('\t'));
663 GtkLabel
* label
= GTK_LABEL(GTK_BIN(m_menuItem
)->child
);
664 gtk_label_set_text_with_mnemonic(label
, wxGTK_CONV_SYS(text
));
667 GdkModifierType accel_mods
;
668 wxGetGtkAccel(this, &accel_key
, &accel_mods
);
671 gtk_widget_add_accelerator(
672 m_menuItem
, "activate", m_parentMenu
->m_accel
,
673 accel_key
, accel_mods
, GTK_ACCEL_VISIBLE
);
675 #endif // wxUSE_ACCEL
678 void wxMenuItem::SetBitmap(const wxBitmap
& bitmap
)
680 if (m_kind
== wxITEM_NORMAL
)
683 wxFAIL_MSG("only normal menu items can have bitmaps");
686 void wxMenuItem::Check( bool check
)
688 wxCHECK_RET( m_menuItem
, wxT("invalid menu item") );
690 if (check
== m_isChecked
)
693 wxMenuItemBase::Check( check
);
699 gtk_check_menu_item_set_active( (GtkCheckMenuItem
*)m_menuItem
, (gint
)check
);
703 wxFAIL_MSG( _T("can't check this item") );
707 void wxMenuItem::Enable( bool enable
)
709 wxCHECK_RET( m_menuItem
, wxT("invalid menu item") );
711 gtk_widget_set_sensitive( m_menuItem
, enable
);
712 wxMenuItemBase::Enable( enable
);
715 bool wxMenuItem::IsChecked() const
717 wxCHECK_MSG( m_menuItem
, false, wxT("invalid menu item") );
719 wxCHECK_MSG( IsCheckable(), false,
720 wxT("can't get state of uncheckable item!") );
722 return ((GtkCheckMenuItem
*)m_menuItem
)->active
!= 0;
725 //-----------------------------------------------------------------------------
727 //-----------------------------------------------------------------------------
731 static void menu_map(GtkWidget
*, wxMenu
* menu
)
733 wxMenuEvent
event(wxEVT_MENU_OPEN
, menu
->m_popupShown
? -1 : 0, menu
);
734 DoCommonMenuCallbackCode(menu
, event
);
737 // "hide" from m_menu
738 static void menu_hide(GtkWidget
*, wxMenu
* menu
)
740 wxMenuEvent
event(wxEVT_MENU_CLOSE
, menu
->m_popupShown
? -1 : 0, menu
);
741 menu
->m_popupShown
= false;
742 DoCommonMenuCallbackCode(menu
, event
);
746 IMPLEMENT_DYNAMIC_CLASS(wxMenu
,wxEvtHandler
)
750 m_popupShown
= false;
752 m_accel
= gtk_accel_group_new();
753 m_menu
= gtk_menu_new();
754 // NB: keep reference to the menu so that it is not destroyed behind
755 // our back by GTK+ e.g. when it is removed from menubar:
756 g_object_ref(m_menu
);
757 gtk_object_sink(GTK_OBJECT(m_menu
));
759 m_owner
= (GtkWidget
*) NULL
;
761 // Tearoffs are entries, just like separators. So if we want this
762 // menu to be a tear-off one, we just append a tearoff entry
764 if ( m_style
& wxMENU_TEAROFF
)
766 GtkWidget
*tearoff
= gtk_tearoff_menu_item_new();
768 gtk_menu_shell_append(GTK_MENU_SHELL(m_menu
), tearoff
);
773 // append the title as the very first entry if we have it
774 if ( !m_title
.empty() )
776 Append(wxGTK_TITLE_ID
, m_title
);
780 // "show" occurs for sub-menus which are not showing, so use "map" instead
781 g_signal_connect(m_menu
, "map", G_CALLBACK(menu_map
), this);
782 g_signal_connect(m_menu
, "hide", G_CALLBACK(menu_hide
), this);
788 g_object_unref(m_menu
);
790 // if the menu is inserted in another menu at this time, there was
791 // one more reference to it:
793 gtk_widget_destroy(m_menu
);
795 g_object_unref(m_accel
);
798 void wxMenu::SetLayoutDirection(const wxLayoutDirection dir
)
801 wxWindow::GTKSetLayout(m_owner
, dir
);
802 //else: will be called later by wxMenuBar again
805 wxLayoutDirection
wxMenu::GetLayoutDirection() const
807 return wxWindow::GTKGetLayout(m_owner
);
810 bool wxMenu::GtkAppend(wxMenuItem
*mitem
, int pos
)
813 GtkWidget
* prevRadio
= m_prevRadio
;
815 switch (mitem
->GetKind())
817 case wxITEM_SEPARATOR
:
818 menuItem
= gtk_separator_menu_item_new();
821 menuItem
= gtk_check_menu_item_new_with_label("");
825 GSList
* group
= NULL
;
827 group
= gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(prevRadio
));
828 menuItem
= gtk_radio_menu_item_new_with_label(group
, "");
829 m_prevRadio
= menuItem
;
833 wxFAIL_MSG("unexpected menu item kind");
836 const wxBitmap
& bitmap
= mitem
->GetBitmap();
841 if (bitmap
.HasPixbuf())
842 image
= gtk_image_new_from_pixbuf(bitmap
.GetPixbuf());
845 GdkPixmap
* mask
= NULL
;
846 if (bitmap
.GetMask())
847 mask
= bitmap
.GetMask()->GetBitmap();
848 image
= gtk_image_new_from_pixmap(bitmap
.GetPixmap(), mask
);
850 menuItem
= gtk_image_menu_item_new_with_label("");
851 gtk_widget_show(image
);
852 gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menuItem
), image
);
854 else if ((stockid
= wxGetStockGtkID(mitem
->GetId())) != NULL
)
855 // use stock bitmap for this item if available on the assumption
856 // that it never hurts to follow GTK+ conventions more closely
857 menuItem
= gtk_image_menu_item_new_from_stock(stockid
, NULL
);
859 menuItem
= gtk_menu_item_new_with_label("");
862 mitem
->SetMenuItem(menuItem
);
864 gtk_menu_shell_insert(GTK_MENU_SHELL(m_menu
), menuItem
, pos
);
866 gtk_widget_show( menuItem
);
868 if ( !mitem
->IsSeparator() )
870 mitem
->SetGtkLabel();
871 g_signal_connect (menuItem
, "select",
872 G_CALLBACK (gtk_menu_hilight_callback
), this);
873 g_signal_connect (menuItem
, "deselect",
874 G_CALLBACK (gtk_menu_nolight_callback
), this);
876 if ( mitem
->IsSubMenu() && mitem
->GetKind() != wxITEM_RADIO
&& mitem
->GetKind() != wxITEM_CHECK
)
878 gtk_menu_item_set_submenu( GTK_MENU_ITEM(menuItem
), mitem
->GetSubMenu()->m_menu
);
880 gtk_widget_show( mitem
->GetSubMenu()->m_menu
);
882 // if adding a submenu to a menu already existing in the menu bar, we
883 // must set invoking window to allow processing events from this
885 if ( m_invokingWindow
)
886 wxMenubarSetInvokingWindow(mitem
->GetSubMenu(), m_invokingWindow
);
890 g_signal_connect (menuItem
, "activate",
891 G_CALLBACK (gtk_menu_clicked_callback
),
899 wxMenuItem
* wxMenu::DoAppend(wxMenuItem
*mitem
)
901 if (!GtkAppend(mitem
))
904 return wxMenuBase::DoAppend(mitem
);
907 wxMenuItem
* wxMenu::DoInsert(size_t pos
, wxMenuItem
*item
)
909 if ( !wxMenuBase::DoInsert(pos
, item
) )
913 if ( !GtkAppend(item
, (int)pos
) )
919 wxMenuItem
*wxMenu::DoRemove(wxMenuItem
*item
)
921 if ( !wxMenuBase::DoRemove(item
) )
924 GtkWidget
* const mitem
= item
->GetMenuItem();
925 if ( m_prevRadio
== mitem
)
927 // deleting an item starts a new radio group (has to as we shouldn't
928 // keep a deleted pointer anyhow)
932 gtk_menu_item_set_submenu(GTK_MENU_ITEM(mitem
), NULL
);
933 gtk_widget_destroy(mitem
);
934 item
->SetMenuItem(NULL
);
939 int wxMenu::FindMenuIdByMenuItem( GtkWidget
*menuItem
) const
941 wxMenuItemList::compatibility_iterator node
= m_items
.GetFirst();
944 wxMenuItem
*item
= node
->GetData();
945 if (item
->GetMenuItem() == menuItem
)
946 return item
->GetId();
947 node
= node
->GetNext();
953 void wxMenu::Attach(wxMenuBarBase
*menubar
)
955 wxMenuBase::Attach(menubar
);
957 // inherit layout direction from menubar.
958 SetLayoutDirection(menubar
->GetLayoutDirection());
961 // ----------------------------------------------------------------------------
963 // ----------------------------------------------------------------------------
967 static wxString
GetGtkHotKey( const wxMenuItem
& item
)
971 wxAcceleratorEntry
*accel
= item
.GetAccel();
974 int flags
= accel
->GetFlags();
975 if ( flags
& wxACCEL_ALT
)
976 hotkey
+= wxT("<alt>");
977 if ( flags
& wxACCEL_CTRL
)
978 hotkey
+= wxT("<control>");
979 if ( flags
& wxACCEL_SHIFT
)
980 hotkey
+= wxT("<shift>");
982 int code
= accel
->GetKeyCode();
1009 hotkey
+= wxString::Format(wxT("F%d"), code
- WXK_F1
+ 1);
1012 // TODO: we should use gdk_keyval_name() (a.k.a.
1013 // XKeysymToString) here as well as hardcoding the keysym
1014 // names this might be not portable
1016 hotkey
<< wxT("Insert" );
1019 hotkey
<< wxT("Delete" );
1022 hotkey
<< wxT("Up" );
1025 hotkey
<< wxT("Down" );
1028 hotkey
<< wxT("Page_Up" );
1031 hotkey
<< wxT("Page_Down" );
1034 hotkey
<< wxT("Left" );
1037 hotkey
<< wxT("Right" );
1040 hotkey
<< wxT("Home" );
1043 hotkey
<< wxT("End" );
1046 hotkey
<< wxT("Return" );
1049 hotkey
<< wxT("BackSpace" );
1052 hotkey
<< wxT("Tab" );
1055 hotkey
<< wxT("Esc" );
1058 hotkey
<< wxT("space" );
1061 hotkey
<< wxT("Multiply" );
1064 hotkey
<< wxT("Add" );
1067 hotkey
<< wxT("Separator" );
1070 hotkey
<< wxT("Subtract" );
1073 hotkey
<< wxT("Decimal" );
1076 hotkey
<< wxT("Divide" );
1079 hotkey
<< wxT("Cancel" );
1082 hotkey
<< wxT("Clear" );
1085 hotkey
<< wxT("Menu" );
1088 hotkey
<< wxT("Pause" );
1091 hotkey
<< wxT("Capital" );
1094 hotkey
<< wxT("Select" );
1097 hotkey
<< wxT("Print" );
1100 hotkey
<< wxT("Execute" );
1103 hotkey
<< wxT("Snapshot" );
1106 hotkey
<< wxT("Help" );
1109 hotkey
<< wxT("Num_Lock" );
1112 hotkey
<< wxT("Scroll_Lock" );
1114 case WXK_NUMPAD_INSERT
:
1115 hotkey
<< wxT("KP_Insert" );
1117 case WXK_NUMPAD_DELETE
:
1118 hotkey
<< wxT("KP_Delete" );
1120 case WXK_NUMPAD_SPACE
:
1121 hotkey
<< wxT("KP_Space" );
1123 case WXK_NUMPAD_TAB
:
1124 hotkey
<< wxT("KP_Tab" );
1126 case WXK_NUMPAD_ENTER
:
1127 hotkey
<< wxT("KP_Enter" );
1129 case WXK_NUMPAD_F1
: case WXK_NUMPAD_F2
: case WXK_NUMPAD_F3
:
1131 hotkey
+= wxString::Format(wxT("KP_F%d"), code
- WXK_NUMPAD_F1
+ 1);
1133 case WXK_NUMPAD_HOME
:
1134 hotkey
<< wxT("KP_Home" );
1136 case WXK_NUMPAD_LEFT
:
1137 hotkey
<< wxT("KP_Left" );
1140 hotkey
<< wxT("KP_Up" );
1142 case WXK_NUMPAD_RIGHT
:
1143 hotkey
<< wxT("KP_Right" );
1145 case WXK_NUMPAD_DOWN
:
1146 hotkey
<< wxT("KP_Down" );
1148 case WXK_NUMPAD_PAGEUP
:
1149 hotkey
<< wxT("KP_Page_Up" );
1151 case WXK_NUMPAD_PAGEDOWN
:
1152 hotkey
<< wxT("KP_Page_Down" );
1154 case WXK_NUMPAD_END
:
1155 hotkey
<< wxT("KP_End" );
1157 case WXK_NUMPAD_BEGIN
:
1158 hotkey
<< wxT("KP_Begin" );
1160 case WXK_NUMPAD_EQUAL
:
1161 hotkey
<< wxT("KP_Equal" );
1163 case WXK_NUMPAD_MULTIPLY
:
1164 hotkey
<< wxT("KP_Multiply" );
1166 case WXK_NUMPAD_ADD
:
1167 hotkey
<< wxT("KP_Add" );
1169 case WXK_NUMPAD_SEPARATOR
:
1170 hotkey
<< wxT("KP_Separator" );
1172 case WXK_NUMPAD_SUBTRACT
:
1173 hotkey
<< wxT("KP_Subtract" );
1175 case WXK_NUMPAD_DECIMAL
:
1176 hotkey
<< wxT("KP_Decimal" );
1178 case WXK_NUMPAD_DIVIDE
:
1179 hotkey
<< wxT("KP_Divide" );
1181 case WXK_NUMPAD0
: case WXK_NUMPAD1
: case WXK_NUMPAD2
:
1182 case WXK_NUMPAD3
: case WXK_NUMPAD4
: case WXK_NUMPAD5
:
1183 case WXK_NUMPAD6
: case WXK_NUMPAD7
: case WXK_NUMPAD8
: case WXK_NUMPAD9
:
1184 hotkey
+= wxString::Format(wxT("KP_%d"), code
- WXK_NUMPAD0
);
1186 case WXK_WINDOWS_LEFT
:
1187 hotkey
<< wxT("Super_L" );
1189 case WXK_WINDOWS_RIGHT
:
1190 hotkey
<< wxT("Super_R" );
1192 case WXK_WINDOWS_MENU
:
1193 hotkey
<< wxT("Menu" );
1196 hotkey
<< wxT("Command" );
1198 /* These probably wouldn't work as there is no SpecialX in gdk/keynames.txt
1199 case WXK_SPECIAL1: case WXK_SPECIAL2: case WXK_SPECIAL3: case WXK_SPECIAL4:
1200 case WXK_SPECIAL5: case WXK_SPECIAL6: case WXK_SPECIAL7: case WXK_SPECIAL8:
1201 case WXK_SPECIAL9: case WXK_SPECIAL10: case WXK_SPECIAL11: case WXK_SPECIAL12:
1202 case WXK_SPECIAL13: case WXK_SPECIAL14: case WXK_SPECIAL15: case WXK_SPECIAL16:
1203 case WXK_SPECIAL17: case WXK_SPECIAL18: case WXK_SPECIAL19: case WXK_SPECIAL20:
1204 hotkey += wxString::Format(wxT("Special%d"), code - WXK_SPECIAL1 + 1);
1207 // if there are any other keys wxAcceleratorEntry::Create() may
1208 // return, we should process them here
1214 name
= wxGTK_CONV_BACK_SYS(gdk_keyval_name((guint
)code
));
1215 if ( !name
.empty() )
1222 wxFAIL_MSG( wxT("unknown keyboard accel") );
1232 wxGetGtkAccel(const wxMenuItem
* item
, guint
* accel_key
, GdkModifierType
* accel_mods
)
1235 const wxString string
= GetGtkHotKey(*item
);
1236 if (!string
.empty())
1237 gtk_accelerator_parse(wxGTK_CONV_SYS(string
), accel_key
, accel_mods
);
1240 GtkStockItem stock_item
;
1241 const char* stockid
= wxGetStockGtkID(item
->GetId());
1242 if (stockid
&& gtk_stock_lookup(stockid
, &stock_item
))
1244 *accel_key
= stock_item
.keyval
;
1245 *accel_mods
= stock_item
.modifier
;
1249 #endif // wxUSE_ACCEL
1251 const char *wxGetStockGtkID(wxWindowID id
)
1253 #define STOCKITEM(wx,gtk) \
1257 #if GTK_CHECK_VERSION(2,6,0)
1258 #define STOCKITEM_26(wx,gtk) STOCKITEM(wx,gtk)
1260 #define STOCKITEM_26(wx,gtk)
1263 #if GTK_CHECK_VERSION(2,10,0)
1264 #define STOCKITEM_210(wx,gtk) STOCKITEM(wx,gtk)
1266 #define STOCKITEM_210(wx,gtk)
1272 STOCKITEM_26(wxID_ABOUT
, GTK_STOCK_ABOUT
)
1273 STOCKITEM(wxID_ADD
, GTK_STOCK_ADD
)
1274 STOCKITEM(wxID_APPLY
, GTK_STOCK_APPLY
)
1275 STOCKITEM(wxID_BOLD
, GTK_STOCK_BOLD
)
1276 STOCKITEM(wxID_CANCEL
, GTK_STOCK_CANCEL
)
1277 STOCKITEM(wxID_CLEAR
, GTK_STOCK_CLEAR
)
1278 STOCKITEM(wxID_CLOSE
, GTK_STOCK_CLOSE
)
1279 STOCKITEM(wxID_COPY
, GTK_STOCK_COPY
)
1280 STOCKITEM(wxID_CUT
, GTK_STOCK_CUT
)
1281 STOCKITEM(wxID_DELETE
, GTK_STOCK_DELETE
)
1282 STOCKITEM_26(wxID_EDIT
, GTK_STOCK_EDIT
)
1283 STOCKITEM(wxID_FIND
, GTK_STOCK_FIND
)
1284 STOCKITEM_26(wxID_FILE
, GTK_STOCK_FILE
)
1285 STOCKITEM(wxID_REPLACE
, GTK_STOCK_FIND_AND_REPLACE
)
1286 STOCKITEM(wxID_BACKWARD
, GTK_STOCK_GO_BACK
)
1287 STOCKITEM(wxID_DOWN
, GTK_STOCK_GO_DOWN
)
1288 STOCKITEM(wxID_FORWARD
, GTK_STOCK_GO_FORWARD
)
1289 STOCKITEM(wxID_UP
, GTK_STOCK_GO_UP
)
1290 STOCKITEM(wxID_HELP
, GTK_STOCK_HELP
)
1291 STOCKITEM(wxID_HOME
, GTK_STOCK_HOME
)
1292 STOCKITEM(wxID_INDENT
, GTK_STOCK_INDENT
)
1293 STOCKITEM(wxID_INDEX
, GTK_STOCK_INDEX
)
1294 STOCKITEM(wxID_ITALIC
, GTK_STOCK_ITALIC
)
1295 STOCKITEM(wxID_JUSTIFY_CENTER
, GTK_STOCK_JUSTIFY_CENTER
)
1296 STOCKITEM(wxID_JUSTIFY_FILL
, GTK_STOCK_JUSTIFY_FILL
)
1297 STOCKITEM(wxID_JUSTIFY_LEFT
, GTK_STOCK_JUSTIFY_LEFT
)
1298 STOCKITEM(wxID_JUSTIFY_RIGHT
, GTK_STOCK_JUSTIFY_RIGHT
)
1299 STOCKITEM(wxID_NEW
, GTK_STOCK_NEW
)
1300 STOCKITEM(wxID_NO
, GTK_STOCK_NO
)
1301 STOCKITEM(wxID_OK
, GTK_STOCK_OK
)
1302 STOCKITEM(wxID_OPEN
, GTK_STOCK_OPEN
)
1303 STOCKITEM(wxID_PASTE
, GTK_STOCK_PASTE
)
1304 STOCKITEM(wxID_PREFERENCES
, GTK_STOCK_PREFERENCES
)
1305 STOCKITEM(wxID_PRINT
, GTK_STOCK_PRINT
)
1306 STOCKITEM(wxID_PREVIEW
, GTK_STOCK_PRINT_PREVIEW
)
1307 STOCKITEM(wxID_PROPERTIES
, GTK_STOCK_PROPERTIES
)
1308 STOCKITEM(wxID_EXIT
, GTK_STOCK_QUIT
)
1309 STOCKITEM(wxID_REDO
, GTK_STOCK_REDO
)
1310 STOCKITEM(wxID_REFRESH
, GTK_STOCK_REFRESH
)
1311 STOCKITEM(wxID_REMOVE
, GTK_STOCK_REMOVE
)
1312 STOCKITEM(wxID_REVERT_TO_SAVED
, GTK_STOCK_REVERT_TO_SAVED
)
1313 STOCKITEM(wxID_SAVE
, GTK_STOCK_SAVE
)
1314 STOCKITEM(wxID_SAVEAS
, GTK_STOCK_SAVE_AS
)
1315 STOCKITEM_210(wxID_SELECTALL
, GTK_STOCK_SELECT_ALL
)
1316 STOCKITEM(wxID_STOP
, GTK_STOCK_STOP
)
1317 STOCKITEM(wxID_UNDELETE
, GTK_STOCK_UNDELETE
)
1318 STOCKITEM(wxID_UNDERLINE
, GTK_STOCK_UNDERLINE
)
1319 STOCKITEM(wxID_UNDO
, GTK_STOCK_UNDO
)
1320 STOCKITEM(wxID_UNINDENT
, GTK_STOCK_UNINDENT
)
1321 STOCKITEM(wxID_YES
, GTK_STOCK_YES
)
1322 STOCKITEM(wxID_ZOOM_100
, GTK_STOCK_ZOOM_100
)
1323 STOCKITEM(wxID_ZOOM_FIT
, GTK_STOCK_ZOOM_FIT
)
1324 STOCKITEM(wxID_ZOOM_IN
, GTK_STOCK_ZOOM_IN
)
1325 STOCKITEM(wxID_ZOOM_OUT
, GTK_STOCK_ZOOM_OUT
)
1336 #endif // wxUSE_MENUS