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 bool wxGetStockGtkAccelerator(const char *id
, GdkModifierType
*mod
, guint
*key
);
41 static wxString
GetGtkHotKey( const wxMenuItem
& item
);
44 static void DoCommonMenuCallbackCode(wxMenu
*menu
, wxMenuEvent
& event
)
46 event
.SetEventObject( menu
);
48 wxEvtHandler
* handler
= menu
->GetEventHandler();
49 if (handler
&& handler
->SafelyProcessEvent(event
))
52 wxWindow
*win
= menu
->GetInvokingWindow();
54 win
->HandleWindowEvent( event
);
57 //-----------------------------------------------------------------------------
59 //-----------------------------------------------------------------------------
61 IMPLEMENT_DYNAMIC_CLASS(wxMenuBar
,wxWindow
)
63 void wxMenuBar::Init(size_t n
, wxMenu
*menus
[], const wxString titles
[], long style
)
65 m_invokingWindow
= NULL
;
68 // Hildon window uses a single menu instead of a menu bar, so wxMenuBar is
69 // the same as menu in this case
71 m_menubar
= gtk_menu_new();
72 #else // !wxUSE_LIBHILDON
73 if (!PreCreation( NULL
, wxDefaultPosition
, wxDefaultSize
) ||
74 !CreateBase( NULL
, -1, wxDefaultPosition
, wxDefaultSize
, style
, wxDefaultValidator
, wxT("menubar") ))
76 wxFAIL_MSG( wxT("wxMenuBar creation failed") );
80 m_menubar
= gtk_menu_bar_new();
82 if (style
& wxMB_DOCKABLE
)
84 m_widget
= gtk_handle_box_new();
85 gtk_container_add(GTK_CONTAINER(m_widget
), m_menubar
);
86 gtk_widget_show(m_menubar
);
96 #endif // wxUSE_LIBHILDON/!wxUSE_LIBHILDON
98 for (size_t i
= 0; i
< n
; ++i
)
99 Append(menus
[i
], titles
[i
]);
102 wxMenuBar::wxMenuBar(size_t n
, wxMenu
*menus
[], const wxString titles
[], long style
)
104 Init(n
, menus
, titles
, style
);
107 wxMenuBar::wxMenuBar(long style
)
109 Init(0, NULL
, NULL
, style
);
112 wxMenuBar::wxMenuBar()
114 Init(0, NULL
, NULL
, 0);
117 wxMenuBar::~wxMenuBar()
122 wxMenubarUnsetInvokingWindow(wxMenu
* menu
, wxWindow
* win
, GtkWindow
* tlw
= NULL
)
124 menu
->SetInvokingWindow( (wxWindow
*) NULL
);
126 // support for native hot keys
130 tlw
= GTK_WINDOW(wxGetTopLevelParent(win
)->m_widget
);
131 if (g_slist_find(menu
->m_accel
->acceleratables
, tlw
))
132 gtk_window_remove_accel_group(tlw
, menu
->m_accel
);
135 wxMenuItemList::compatibility_iterator node
= menu
->GetMenuItems().GetFirst();
138 wxMenuItem
*menuitem
= node
->GetData();
139 if (menuitem
->IsSubMenu())
140 wxMenubarUnsetInvokingWindow(menuitem
->GetSubMenu(), win
, tlw
);
141 node
= node
->GetNext();
146 wxMenubarSetInvokingWindow(wxMenu
* menu
, wxWindow
* win
, GtkWindow
* tlw
= NULL
)
148 menu
->SetInvokingWindow( win
);
150 // support for native hot keys
154 tlw
= GTK_WINDOW(wxGetTopLevelParent(win
)->m_widget
);
155 if (!g_slist_find(menu
->m_accel
->acceleratables
, tlw
))
156 gtk_window_add_accel_group(tlw
, menu
->m_accel
);
159 wxMenuItemList::compatibility_iterator node
= menu
->GetMenuItems().GetFirst();
162 wxMenuItem
*menuitem
= node
->GetData();
163 if (menuitem
->IsSubMenu())
164 wxMenubarSetInvokingWindow(menuitem
->GetSubMenu(), win
, tlw
);
165 node
= node
->GetNext();
169 void wxMenuBar::SetInvokingWindow( wxWindow
*win
)
171 m_invokingWindow
= win
;
173 wxMenuList::compatibility_iterator node
= m_menus
.GetFirst();
176 wxMenu
*menu
= node
->GetData();
177 wxMenubarSetInvokingWindow( menu
, win
);
178 node
= node
->GetNext();
182 void wxMenuBar::SetLayoutDirection(wxLayoutDirection dir
)
184 if ( dir
== wxLayout_Default
)
186 const wxWindow
*const frame
= GetFrame();
189 // inherit layout from frame.
190 dir
= frame
->GetLayoutDirection();
192 else // use global layout
194 dir
= wxTheApp
->GetLayoutDirection();
198 if ( dir
== wxLayout_Default
)
201 GTKSetLayout(m_menubar
, dir
);
203 // also set the layout of all menus we already have (new ones will inherit
204 // the current layout)
205 for ( wxMenuList::compatibility_iterator node
= m_menus
.GetFirst();
207 node
= node
->GetNext() )
209 wxMenu
*const menu
= node
->GetData();
210 menu
->SetLayoutDirection(dir
);
214 wxLayoutDirection
wxMenuBar::GetLayoutDirection() const
216 return GTKGetLayout(m_menubar
);
219 void wxMenuBar::Attach(wxFrame
*frame
)
221 wxMenuBarBase::Attach(frame
);
223 SetLayoutDirection(wxLayout_Default
);
226 void wxMenuBar::UnsetInvokingWindow( wxWindow
*win
)
228 m_invokingWindow
= (wxWindow
*) NULL
;
230 wxMenuList::compatibility_iterator node
= m_menus
.GetFirst();
233 wxMenu
*menu
= node
->GetData();
234 wxMenubarUnsetInvokingWindow( menu
, win
);
235 node
= node
->GetNext();
239 bool wxMenuBar::Append( wxMenu
*menu
, const wxString
&title
)
241 if ( !wxMenuBarBase::Append( menu
, title
) )
244 return GtkAppend(menu
, title
);
247 bool wxMenuBar::GtkAppend(wxMenu
*menu
, const wxString
& title
, int pos
)
249 menu
->SetLayoutDirection(GetLayoutDirection());
252 // if the menu has only one item, append it directly to the top level menu
253 // instead of inserting a useless submenu
254 if ( menu
->GetMenuItemCount() == 1 )
256 wxMenuItem
* const item
= menu
->FindItemByPosition(0);
258 // remove both mnemonics and accelerator: neither is useful under Maemo
259 const wxString
str(wxStripMenuCodes(item
->GetItemLabel()));
261 if ( item
->IsSubMenu() )
262 return GtkAppend(item
->GetSubMenu(), str
, pos
);
264 menu
->m_owner
= gtk_menu_item_new_with_mnemonic( wxGTK_CONV( str
) );
266 g_signal_connect(menu
->m_owner
, "activate",
267 G_CALLBACK(gtk_menu_clicked_callback
), menu
);
268 item
->SetMenuItem(menu
->m_owner
);
271 #endif // wxUSE_LIBHILDON/!wxUSE_LIBHILDON
273 const wxString
str(wxConvertMnemonicsToGTK(title
));
275 // This doesn't have much effect right now.
276 menu
->SetTitle( str
);
278 // The "m_owner" is the "menu item"
279 menu
->m_owner
= gtk_menu_item_new_with_mnemonic( wxGTK_CONV( str
) );
281 gtk_menu_item_set_submenu( GTK_MENU_ITEM(menu
->m_owner
), menu
->m_menu
);
284 gtk_widget_show( menu
->m_owner
);
287 gtk_menu_shell_append( GTK_MENU_SHELL(m_menubar
), menu
->m_owner
);
289 gtk_menu_shell_insert( GTK_MENU_SHELL(m_menubar
), menu
->m_owner
, pos
);
291 // m_invokingWindow is set after wxFrame::SetMenuBar(). This call enables
292 // addings menu later on.
293 if (m_invokingWindow
)
294 wxMenubarSetInvokingWindow( menu
, m_invokingWindow
);
299 bool wxMenuBar::Insert(size_t pos
, wxMenu
*menu
, const wxString
& title
)
301 if ( !wxMenuBarBase::Insert(pos
, menu
, title
) )
306 if ( !GtkAppend(menu
, title
, (int)pos
) )
312 wxMenu
*wxMenuBar::Replace(size_t pos
, wxMenu
*menu
, const wxString
& title
)
314 // remove the old item and insert a new one
315 wxMenu
*menuOld
= Remove(pos
);
316 if ( menuOld
&& !Insert(pos
, menu
, title
) )
318 return (wxMenu
*) NULL
;
321 // either Insert() succeeded or Remove() failed and menuOld is NULL
325 wxMenu
*wxMenuBar::Remove(size_t pos
)
327 wxMenu
*menu
= wxMenuBarBase::Remove(pos
);
329 return (wxMenu
*) NULL
;
331 gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu
->m_owner
), NULL
);
332 gtk_container_remove(GTK_CONTAINER(m_menubar
), menu
->m_owner
);
334 gtk_widget_destroy( menu
->m_owner
);
335 menu
->m_owner
= NULL
;
337 if (m_invokingWindow
)
338 wxMenubarUnsetInvokingWindow( menu
, m_invokingWindow
);
343 static int FindMenuItemRecursive( const wxMenu
*menu
, const wxString
&menuString
, const wxString
&itemString
)
345 if (wxMenuItem::GetLabelText(wxConvertMnemonicsFromGTK(menu
->GetTitle())) == wxMenuItem::GetLabelText(menuString
))
347 int res
= menu
->FindItem( itemString
);
348 if (res
!= wxNOT_FOUND
)
352 wxMenuItemList::compatibility_iterator node
= menu
->GetMenuItems().GetFirst();
355 wxMenuItem
*item
= node
->GetData();
356 if (item
->IsSubMenu())
357 return FindMenuItemRecursive(item
->GetSubMenu(), menuString
, itemString
);
359 node
= node
->GetNext();
365 int wxMenuBar::FindMenuItem( const wxString
&menuString
, const wxString
&itemString
) const
367 wxMenuList::compatibility_iterator node
= m_menus
.GetFirst();
370 wxMenu
*menu
= node
->GetData();
371 int res
= FindMenuItemRecursive( menu
, menuString
, itemString
);
374 node
= node
->GetNext();
380 // Find a wxMenuItem using its id. Recurses down into sub-menus
381 static wxMenuItem
* FindMenuItemByIdRecursive(const wxMenu
* menu
, int id
)
383 wxMenuItem
* result
= menu
->FindChildItem(id
);
385 wxMenuItemList::compatibility_iterator node
= menu
->GetMenuItems().GetFirst();
386 while ( node
&& result
== NULL
)
388 wxMenuItem
*item
= node
->GetData();
389 if (item
->IsSubMenu())
391 result
= FindMenuItemByIdRecursive( item
->GetSubMenu(), id
);
393 node
= node
->GetNext();
399 wxMenuItem
* wxMenuBar::FindItem( int id
, wxMenu
**menuForItem
) const
401 wxMenuItem
* result
= 0;
402 wxMenuList::compatibility_iterator node
= m_menus
.GetFirst();
403 while (node
&& result
== 0)
405 wxMenu
*menu
= node
->GetData();
406 result
= FindMenuItemByIdRecursive( menu
, id
);
407 node
= node
->GetNext();
412 *menuForItem
= result
? result
->GetMenu() : (wxMenu
*)NULL
;
418 void wxMenuBar::EnableTop( size_t pos
, bool flag
)
420 wxMenuList::compatibility_iterator node
= m_menus
.Item( pos
);
422 wxCHECK_RET( node
, wxT("menu not found") );
424 wxMenu
* menu
= node
->GetData();
427 gtk_widget_set_sensitive( menu
->m_owner
, flag
);
430 wxString
wxMenuBar::GetMenuLabel( size_t pos
) const
432 wxMenuList::compatibility_iterator node
= m_menus
.Item( pos
);
434 wxCHECK_MSG( node
, wxT("invalid"), wxT("menu not found") );
436 wxMenu
* menu
= node
->GetData();
438 return wxConvertMnemonicsFromGTK(menu
->GetTitle());
441 void wxMenuBar::SetMenuLabel( size_t pos
, const wxString
& label
)
443 wxMenuList::compatibility_iterator node
= m_menus
.Item( pos
);
445 wxCHECK_RET( node
, wxT("menu not found") );
447 wxMenu
* menu
= node
->GetData();
449 const wxString
str(wxConvertMnemonicsToGTK(label
));
451 menu
->SetTitle( str
);
454 gtk_label_set_text_with_mnemonic( GTK_LABEL( GTK_BIN(menu
->m_owner
)->child
), wxGTK_CONV(str
) );
457 //-----------------------------------------------------------------------------
459 //-----------------------------------------------------------------------------
462 static void gtk_menu_clicked_callback( GtkWidget
*widget
, wxMenu
*menu
)
464 int id
= menu
->FindMenuIdByMenuItem(widget
);
466 /* should find it for normal (not popup) menu */
467 wxASSERT_MSG( (id
!= -1) || (menu
->GetInvokingWindow() != NULL
),
468 _T("menu item not found in gtk_menu_clicked_callback") );
470 if (!menu
->IsEnabled(id
))
473 wxMenuItem
* item
= menu
->FindChildItem( id
);
474 wxCHECK_RET( item
, wxT("error in menu item callback") );
476 if ( item
->GetId() == wxGTK_TITLE_ID
)
478 // ignore events from the menu title
482 if (item
->IsCheckable())
484 bool isReallyChecked
= item
->IsChecked(),
485 isInternallyChecked
= item
->wxMenuItemBase::IsChecked();
487 // ensure that the internal state is always consistent with what is
488 // shown on the screen
489 item
->wxMenuItemBase::Check(isReallyChecked
);
491 // we must not report the events for the radio button going up nor the
492 // events resulting from the calls to wxMenuItem::Check()
493 if ( (item
->GetKind() == wxITEM_RADIO
&& !isReallyChecked
) ||
494 (isInternallyChecked
== isReallyChecked
) )
501 // Is this menu on a menubar? (possibly nested)
502 wxFrame
* frame
= NULL
;
503 if(menu
->IsAttached())
504 frame
= menu
->GetMenuBar()->GetFrame();
506 // FIXME: why do we have to call wxFrame::GetEventHandler() directly here?
507 // normally wxMenu::SendEvent() should be enough, if it doesn't work
508 // in wxGTK then we have a bug in wxMenu::GetInvokingWindow() which
509 // should be fixed instead of working around it here...
512 // If it is attached then let the frame send the event.
513 // Don't call frame->ProcessCommand(id) because it toggles
514 // checkable items and we've already done that above.
515 wxCommandEvent
commandEvent(wxEVT_COMMAND_MENU_SELECTED
, id
);
516 commandEvent
.SetEventObject(frame
);
517 if (item
->IsCheckable())
518 commandEvent
.SetInt(item
->IsChecked());
520 frame
->HandleWindowEvent(commandEvent
);
524 // otherwise let the menu have it
525 menu
->SendEvent(id
, item
->IsCheckable() ? item
->IsChecked() : -1);
530 //-----------------------------------------------------------------------------
532 //-----------------------------------------------------------------------------
535 static void gtk_menu_hilight_callback( GtkWidget
*widget
, wxMenu
*menu
)
537 int id
= menu
->FindMenuIdByMenuItem(widget
);
539 wxASSERT( id
!= -1 ); // should find it!
541 if (!menu
->IsEnabled(id
))
544 wxMenuEvent
event( wxEVT_MENU_HIGHLIGHT
, id
);
545 event
.SetEventObject( menu
);
547 wxEvtHandler
* handler
= menu
->GetEventHandler();
548 if (handler
&& handler
->SafelyProcessEvent(event
))
551 wxWindow
*win
= menu
->GetInvokingWindow();
552 if (win
) win
->HandleWindowEvent( event
);
556 //-----------------------------------------------------------------------------
558 //-----------------------------------------------------------------------------
561 static void gtk_menu_nolight_callback( GtkWidget
*widget
, wxMenu
*menu
)
563 int id
= menu
->FindMenuIdByMenuItem(widget
);
565 wxASSERT( id
!= -1 ); // should find it!
567 if (!menu
->IsEnabled(id
))
570 wxMenuEvent
event( wxEVT_MENU_HIGHLIGHT
, -1 );
571 event
.SetEventObject( menu
);
573 wxEvtHandler
* handler
= menu
->GetEventHandler();
574 if (handler
&& handler
->SafelyProcessEvent(event
))
577 wxWindow
*win
= menu
->GetInvokingWindow();
579 win
->HandleWindowEvent( event
);
583 //-----------------------------------------------------------------------------
585 //-----------------------------------------------------------------------------
587 IMPLEMENT_DYNAMIC_CLASS(wxMenuItem
, wxObject
)
589 wxMenuItem
*wxMenuItemBase::New(wxMenu
*parentMenu
,
591 const wxString
& name
,
592 const wxString
& help
,
596 return new wxMenuItem(parentMenu
, id
, name
, help
, kind
, subMenu
);
599 wxMenuItem::wxMenuItem(wxMenu
*parentMenu
,
601 const wxString
& text
,
602 const wxString
& help
,
605 : wxMenuItemBase(parentMenu
, id
, text
, help
, kind
, subMenu
)
610 #if WXWIN_COMPATIBILITY_2_8
611 wxMenuItem::wxMenuItem(wxMenu
*parentMenu
,
613 const wxString
& text
,
614 const wxString
& help
,
617 : wxMenuItemBase(parentMenu
, id
, text
, help
,
618 isCheckable
? wxITEM_CHECK
: wxITEM_NORMAL
, subMenu
)
624 void wxMenuItem::Init(const wxString
& text
)
626 m_menuItem
= (GtkWidget
*) NULL
;
631 wxMenuItem::~wxMenuItem()
633 // don't delete menu items, the menus take care of that
636 // return the menu item text without any menu accels
639 wxString
wxMenuItemBase::GetLabelText(const wxString
& text
)
641 // The argument to this function will now always be in wxWidgets standard label
642 // format, not GTK+ format, so we do what the other ports do.
644 return wxStripMenuCodes(text
);
647 void wxMenuItem::SetItemLabel( const wxString
& str
)
649 // cache some data which must be used later
650 bool isstock
= wxIsStockID(GetId());
651 const char *stockid
= NULL
;
653 stockid
= wxGetStockGtkID(GetId());
655 // Some optimization to avoid flicker
656 wxString oldLabel
= m_text
;
657 oldLabel
= wxStripMenuCodes(oldLabel
);
658 wxString label1
= wxStripMenuCodes(str
);
660 wxString oldhotkey
= m_hotKey
; // Store the old hotkey in Ctrl-foo format
661 wxCharBuffer oldbuf
= wxGTK_CONV_SYS( GetGtkHotKey(*this) ); // and as <control>foo
662 #endif // wxUSE_ACCEL
667 if (oldLabel
== label1
&&
668 oldhotkey
== m_hotKey
) // Make sure we can change a hotkey even if the label is unaltered
673 // stock menu items can have empty labels:
674 wxString text
= m_gtkText
;
675 if (text
.IsEmpty() && !IsSeparator())
677 wxASSERT_MSG(isstock
, wxT("A non-stock menu item with an empty label?"));
678 text
= wxGetStockLabel(GetId());
680 // need & => _ conversion
681 text
= GTKProcessMenuItemLabel(text
, NULL
);
684 GtkLabel
* label
= GTK_LABEL(GTK_BIN(m_menuItem
)->child
);
685 gtk_label_set_text_with_mnemonic(label
, wxGTK_CONV_SYS(text
));
688 // remove old accelerator from our parent's accelerator group, if present
690 GdkModifierType accel_mods
;
691 if (oldbuf
[(size_t)0] != '\0')
693 gtk_accelerator_parse( (const char*) oldbuf
, &accel_key
, &accel_mods
);
696 gtk_widget_remove_accelerator(m_menuItem
,
697 m_parentMenu
->m_accel
,
704 // if the accelerator was taken from a stock ID, just get it back from GTK+ stock
705 if (wxGetStockGtkAccelerator(stockid
, &accel_mods
, &accel_key
))
706 gtk_widget_remove_accelerator( m_menuItem
,
707 m_parentMenu
->m_accel
,
712 // add new accelerator to our parent's accelerator group
713 wxCharBuffer buf
= wxGTK_CONV_SYS( GetGtkHotKey(*this) );
714 if (buf
[(size_t)0] != '\0')
716 gtk_accelerator_parse( (const char*) buf
, &accel_key
, &accel_mods
);
719 gtk_widget_add_accelerator( m_menuItem
,
721 m_parentMenu
->m_accel
,
729 // if the accelerator was taken from a stock ID, just get it back from GTK+ stock
730 if (wxGetStockGtkAccelerator(stockid
, &accel_mods
, &accel_key
))
731 gtk_widget_remove_accelerator( m_menuItem
,
732 m_parentMenu
->m_accel
,
736 #endif // wxUSE_ACCEL
739 // NOTE: this function is different from the similar functions GTKProcessMnemonics()
740 // implemented in control.cpp and from wxMenuItemBase::GetLabelText...
741 // so there's no real code duplication
742 wxString
wxMenuItem::GTKProcessMenuItemLabel(const wxString
& str
, wxString
*hotKey
)
746 // '\t' is the deliminator indicating a hot key
747 wxString::const_iterator pc
= str
.begin();
748 while ( pc
!= str
.end() && *pc
!= wxT('\t') )
752 wxString::const_iterator next
= pc
+ 1;
753 if (next
!= str
.end() && *next
== wxT('&'))
755 // "&" is doubled to indicate "&" instead of accelerator
764 else if ( *pc
== wxT('_') ) // escape underscores
781 hotKey
->assign(pc
, str
.end());
788 // it's valid for this function to be called even if m_menuItem == NULL
789 void wxMenuItem::DoSetText( const wxString
& str
)
792 m_gtkText
= GTKProcessMenuItemLabel(str
, &m_hotKey
);
797 wxAcceleratorEntry
*wxMenuItem::GetAccel() const
799 if (m_hotKey
.empty())
805 // accelerator parsing code looks for them after a TAB, so insert a dummy
808 label
<< wxT('\t') << m_hotKey
;
810 return wxAcceleratorEntry::Create(label
);
813 #endif // wxUSE_ACCEL
815 void wxMenuItem::Check( bool check
)
817 wxCHECK_RET( m_menuItem
, wxT("invalid menu item") );
819 if (check
== m_isChecked
)
822 wxMenuItemBase::Check( check
);
828 gtk_check_menu_item_set_active( (GtkCheckMenuItem
*)m_menuItem
, (gint
)check
);
832 wxFAIL_MSG( _T("can't check this item") );
836 void wxMenuItem::Enable( bool enable
)
838 wxCHECK_RET( m_menuItem
, wxT("invalid menu item") );
840 gtk_widget_set_sensitive( m_menuItem
, enable
);
841 wxMenuItemBase::Enable( enable
);
844 bool wxMenuItem::IsChecked() const
846 wxCHECK_MSG( m_menuItem
, false, wxT("invalid menu item") );
848 wxCHECK_MSG( IsCheckable(), false,
849 wxT("can't get state of uncheckable item!") );
851 return ((GtkCheckMenuItem
*)m_menuItem
)->active
!= 0;
854 //-----------------------------------------------------------------------------
856 //-----------------------------------------------------------------------------
860 static void menu_map(GtkWidget
*, wxMenu
* menu
)
862 wxMenuEvent
event(wxEVT_MENU_OPEN
, menu
->m_popupShown
? -1 : 0, menu
);
863 DoCommonMenuCallbackCode(menu
, event
);
866 // "hide" from m_menu
867 static void menu_hide(GtkWidget
*, wxMenu
* menu
)
869 wxMenuEvent
event(wxEVT_MENU_CLOSE
, menu
->m_popupShown
? -1 : 0, menu
);
870 menu
->m_popupShown
= false;
871 DoCommonMenuCallbackCode(menu
, event
);
875 IMPLEMENT_DYNAMIC_CLASS(wxMenu
,wxEvtHandler
)
879 m_popupShown
= false;
881 m_accel
= gtk_accel_group_new();
882 m_menu
= gtk_menu_new();
883 // NB: keep reference to the menu so that it is not destroyed behind
884 // our back by GTK+ e.g. when it is removed from menubar:
885 g_object_ref(m_menu
);
886 gtk_object_sink(GTK_OBJECT(m_menu
));
888 m_owner
= (GtkWidget
*) NULL
;
890 // Tearoffs are entries, just like separators. So if we want this
891 // menu to be a tear-off one, we just append a tearoff entry
893 if ( m_style
& wxMENU_TEAROFF
)
895 GtkWidget
*tearoff
= gtk_tearoff_menu_item_new();
897 gtk_menu_shell_append(GTK_MENU_SHELL(m_menu
), tearoff
);
902 // append the title as the very first entry if we have it
903 if ( !m_title
.empty() )
905 Append(wxGTK_TITLE_ID
, m_title
);
909 // "show" occurs for sub-menus which are not showing, so use "map" instead
910 g_signal_connect(m_menu
, "map", G_CALLBACK(menu_map
), this);
911 g_signal_connect(m_menu
, "hide", G_CALLBACK(menu_hide
), this);
917 g_object_unref(m_menu
);
919 // if the menu is inserted in another menu at this time, there was
920 // one more reference to it:
922 gtk_widget_destroy(m_menu
);
924 g_object_unref(m_accel
);
927 void wxMenu::SetLayoutDirection(const wxLayoutDirection dir
)
930 wxWindow::GTKSetLayout(m_owner
, dir
);
931 //else: will be called later by wxMenuBar again
934 wxLayoutDirection
wxMenu::GetLayoutDirection() const
936 return wxWindow::GTKGetLayout(m_owner
);
939 bool wxMenu::GtkAppend(wxMenuItem
*mitem
, int pos
)
943 // cache some data used later
944 wxString text
= mitem
->GetGtkItemLabel();
945 int id
= mitem
->GetId();
946 bool isstock
= wxIsStockID(id
);
947 const char *stockid
= NULL
;
949 stockid
= wxGetStockGtkID(mitem
->GetId());
951 // stock menu items can have an empty label
952 if (text
.IsEmpty() && !mitem
->IsSeparator())
954 wxASSERT_MSG(isstock
, wxT("A non-stock menu item with an empty label?"));
955 text
= wxGetStockLabel(id
);
957 // need & => _ conversion
958 text
= wxMenuItem::GTKProcessMenuItemLabel(text
, NULL
);
961 if ( mitem
->IsSeparator() )
963 menuItem
= gtk_separator_menu_item_new();
966 else if ( mitem
->GetBitmap().IsOk() ||
967 (mitem
->GetKind() == wxITEM_NORMAL
&& isstock
) )
969 wxBitmap
bitmap(mitem
->GetBitmap());
971 menuItem
= gtk_image_menu_item_new_with_mnemonic( wxGTK_CONV_SYS( text
) );
976 // use stock bitmap for this item if available on the assumption
977 // that it never hurts to follow GTK+ conventions more closely
978 image
= stockid
? gtk_image_new_from_stock(stockid
, GTK_ICON_SIZE_MENU
)
981 else // we have a custom bitmap
983 wxASSERT_MSG( mitem
->GetKind() == wxITEM_NORMAL
,
984 _T("only normal menu items can have bitmaps") );
986 if ( bitmap
.HasPixbuf() )
988 image
= gtk_image_new_from_pixbuf(bitmap
.GetPixbuf());
992 GdkPixmap
*gdk_pixmap
= bitmap
.GetPixmap();
993 GdkBitmap
*gdk_bitmap
= bitmap
.GetMask() ?
994 bitmap
.GetMask()->GetBitmap() :
996 image
= gtk_image_new_from_pixmap( gdk_pixmap
, gdk_bitmap
);
1002 gtk_widget_show(image
);
1004 gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(menuItem
), image
);
1009 else // a normal item
1011 // NB: 'text' variable has "_" instead of "&" after mitem->SetItemLabel()
1014 switch ( mitem
->GetKind() )
1018 menuItem
= gtk_check_menu_item_new_with_mnemonic( wxGTK_CONV_SYS( text
) );
1025 GSList
*group
= NULL
;
1026 if ( m_prevRadio
== NULL
)
1028 // start of a new radio group
1029 m_prevRadio
= menuItem
=
1030 gtk_radio_menu_item_new_with_mnemonic( group
, wxGTK_CONV_SYS( text
) );
1032 else // continue the radio group
1034 group
= gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (m_prevRadio
));
1035 m_prevRadio
= menuItem
=
1036 gtk_radio_menu_item_new_with_mnemonic( group
, wxGTK_CONV_SYS( text
) );
1042 wxFAIL_MSG( _T("unexpected menu item kind") );
1047 menuItem
= gtk_menu_item_new_with_mnemonic( wxGTK_CONV_SYS( text
) );
1057 GdkModifierType accel_mods
;
1058 wxCharBuffer buf
= wxGTK_CONV_SYS( GetGtkHotKey(*mitem
) );
1060 if (buf
[(size_t)0] != '\0')
1062 gtk_accelerator_parse( (const char*) buf
, &accel_key
, &accel_mods
);
1065 gtk_widget_add_accelerator (menuItem
,
1075 // if the accelerator was taken from a stock ID, just get it back from GTK+ stock
1076 if (wxGetStockGtkAccelerator(stockid
, &accel_mods
, &accel_key
))
1077 gtk_widget_add_accelerator( menuItem
,
1084 #endif // wxUSE_ACCEL
1087 gtk_menu_shell_append(GTK_MENU_SHELL(m_menu
), menuItem
);
1089 gtk_menu_shell_insert(GTK_MENU_SHELL(m_menu
), menuItem
, pos
);
1091 gtk_widget_show( menuItem
);
1093 if ( !mitem
->IsSeparator() )
1095 wxASSERT_MSG( menuItem
, wxT("invalid menuitem") );
1097 g_signal_connect (menuItem
, "select",
1098 G_CALLBACK (gtk_menu_hilight_callback
), this);
1099 g_signal_connect (menuItem
, "deselect",
1100 G_CALLBACK (gtk_menu_nolight_callback
), this);
1102 if ( mitem
->IsSubMenu() && mitem
->GetKind() != wxITEM_RADIO
&& mitem
->GetKind() != wxITEM_CHECK
)
1104 gtk_menu_item_set_submenu( GTK_MENU_ITEM(menuItem
), mitem
->GetSubMenu()->m_menu
);
1106 gtk_widget_show( mitem
->GetSubMenu()->m_menu
);
1108 // if adding a submenu to a menu already existing in the menu bar, we
1109 // must set invoking window to allow processing events from this
1111 if ( m_invokingWindow
)
1112 wxMenubarSetInvokingWindow(mitem
->GetSubMenu(), m_invokingWindow
);
1116 g_signal_connect (menuItem
, "activate",
1117 G_CALLBACK (gtk_menu_clicked_callback
),
1122 mitem
->SetMenuItem(menuItem
);
1126 // This doesn't even exist!
1127 // gtk_widget_lock_accelerators(mitem->GetMenuItem());
1133 wxMenuItem
* wxMenu::DoAppend(wxMenuItem
*mitem
)
1135 if (!GtkAppend(mitem
))
1138 return wxMenuBase::DoAppend(mitem
);
1141 wxMenuItem
* wxMenu::DoInsert(size_t pos
, wxMenuItem
*item
)
1143 if ( !wxMenuBase::DoInsert(pos
, item
) )
1147 if ( !GtkAppend(item
, (int)pos
) )
1153 wxMenuItem
*wxMenu::DoRemove(wxMenuItem
*item
)
1155 if ( !wxMenuBase::DoRemove(item
) )
1158 GtkWidget
* const mitem
= item
->GetMenuItem();
1159 if ( m_prevRadio
== mitem
)
1161 // deleting an item starts a new radio group (has to as we shouldn't
1162 // keep a deleted pointer anyhow)
1166 gtk_menu_item_set_submenu(GTK_MENU_ITEM(mitem
), NULL
);
1167 gtk_widget_destroy(mitem
);
1168 item
->SetMenuItem(NULL
);
1173 int wxMenu::FindMenuIdByMenuItem( GtkWidget
*menuItem
) const
1175 wxMenuItemList::compatibility_iterator node
= m_items
.GetFirst();
1178 wxMenuItem
*item
= node
->GetData();
1179 if (item
->GetMenuItem() == menuItem
)
1180 return item
->GetId();
1181 node
= node
->GetNext();
1187 void wxMenu::Attach(wxMenuBarBase
*menubar
)
1189 wxMenuBase::Attach(menubar
);
1191 // inherit layout direction from menubar.
1192 SetLayoutDirection(menubar
->GetLayoutDirection());
1195 // ----------------------------------------------------------------------------
1197 // ----------------------------------------------------------------------------
1201 static wxString
GetGtkHotKey( const wxMenuItem
& item
)
1205 wxAcceleratorEntry
*accel
= item
.GetAccel();
1208 int flags
= accel
->GetFlags();
1209 if ( flags
& wxACCEL_ALT
)
1210 hotkey
+= wxT("<alt>");
1211 if ( flags
& wxACCEL_CTRL
)
1212 hotkey
+= wxT("<control>");
1213 if ( flags
& wxACCEL_SHIFT
)
1214 hotkey
+= wxT("<shift>");
1216 int code
= accel
->GetKeyCode();
1243 hotkey
+= wxString::Format(wxT("F%d"), code
- WXK_F1
+ 1);
1246 // TODO: we should use gdk_keyval_name() (a.k.a.
1247 // XKeysymToString) here as well as hardcoding the keysym
1248 // names this might be not portable
1250 hotkey
<< wxT("Insert" );
1253 hotkey
<< wxT("Delete" );
1256 hotkey
<< wxT("Up" );
1259 hotkey
<< wxT("Down" );
1262 hotkey
<< wxT("Page_Up" );
1265 hotkey
<< wxT("Page_Down" );
1268 hotkey
<< wxT("Left" );
1271 hotkey
<< wxT("Right" );
1274 hotkey
<< wxT("Home" );
1277 hotkey
<< wxT("End" );
1280 hotkey
<< wxT("Return" );
1283 hotkey
<< wxT("BackSpace" );
1286 hotkey
<< wxT("Tab" );
1289 hotkey
<< wxT("Esc" );
1292 hotkey
<< wxT("space" );
1295 hotkey
<< wxT("Multiply" );
1298 hotkey
<< wxT("Add" );
1301 hotkey
<< wxT("Separator" );
1304 hotkey
<< wxT("Subtract" );
1307 hotkey
<< wxT("Decimal" );
1310 hotkey
<< wxT("Divide" );
1313 hotkey
<< wxT("Cancel" );
1316 hotkey
<< wxT("Clear" );
1319 hotkey
<< wxT("Menu" );
1322 hotkey
<< wxT("Pause" );
1325 hotkey
<< wxT("Capital" );
1328 hotkey
<< wxT("Select" );
1331 hotkey
<< wxT("Print" );
1334 hotkey
<< wxT("Execute" );
1337 hotkey
<< wxT("Snapshot" );
1340 hotkey
<< wxT("Help" );
1343 hotkey
<< wxT("Num_Lock" );
1346 hotkey
<< wxT("Scroll_Lock" );
1348 case WXK_NUMPAD_INSERT
:
1349 hotkey
<< wxT("KP_Insert" );
1351 case WXK_NUMPAD_DELETE
:
1352 hotkey
<< wxT("KP_Delete" );
1354 case WXK_NUMPAD_SPACE
:
1355 hotkey
<< wxT("KP_Space" );
1357 case WXK_NUMPAD_TAB
:
1358 hotkey
<< wxT("KP_Tab" );
1360 case WXK_NUMPAD_ENTER
:
1361 hotkey
<< wxT("KP_Enter" );
1363 case WXK_NUMPAD_F1
: case WXK_NUMPAD_F2
: case WXK_NUMPAD_F3
:
1365 hotkey
+= wxString::Format(wxT("KP_F%d"), code
- WXK_NUMPAD_F1
+ 1);
1367 case WXK_NUMPAD_HOME
:
1368 hotkey
<< wxT("KP_Home" );
1370 case WXK_NUMPAD_LEFT
:
1371 hotkey
<< wxT("KP_Left" );
1374 hotkey
<< wxT("KP_Up" );
1376 case WXK_NUMPAD_RIGHT
:
1377 hotkey
<< wxT("KP_Right" );
1379 case WXK_NUMPAD_DOWN
:
1380 hotkey
<< wxT("KP_Down" );
1382 case WXK_NUMPAD_PAGEUP
:
1383 hotkey
<< wxT("KP_Page_Up" );
1385 case WXK_NUMPAD_PAGEDOWN
:
1386 hotkey
<< wxT("KP_Page_Down" );
1388 case WXK_NUMPAD_END
:
1389 hotkey
<< wxT("KP_End" );
1391 case WXK_NUMPAD_BEGIN
:
1392 hotkey
<< wxT("KP_Begin" );
1394 case WXK_NUMPAD_EQUAL
:
1395 hotkey
<< wxT("KP_Equal" );
1397 case WXK_NUMPAD_MULTIPLY
:
1398 hotkey
<< wxT("KP_Multiply" );
1400 case WXK_NUMPAD_ADD
:
1401 hotkey
<< wxT("KP_Add" );
1403 case WXK_NUMPAD_SEPARATOR
:
1404 hotkey
<< wxT("KP_Separator" );
1406 case WXK_NUMPAD_SUBTRACT
:
1407 hotkey
<< wxT("KP_Subtract" );
1409 case WXK_NUMPAD_DECIMAL
:
1410 hotkey
<< wxT("KP_Decimal" );
1412 case WXK_NUMPAD_DIVIDE
:
1413 hotkey
<< wxT("KP_Divide" );
1415 case WXK_NUMPAD0
: case WXK_NUMPAD1
: case WXK_NUMPAD2
:
1416 case WXK_NUMPAD3
: case WXK_NUMPAD4
: case WXK_NUMPAD5
:
1417 case WXK_NUMPAD6
: case WXK_NUMPAD7
: case WXK_NUMPAD8
: case WXK_NUMPAD9
:
1418 hotkey
+= wxString::Format(wxT("KP_%d"), code
- WXK_NUMPAD0
);
1420 case WXK_WINDOWS_LEFT
:
1421 hotkey
<< wxT("Super_L" );
1423 case WXK_WINDOWS_RIGHT
:
1424 hotkey
<< wxT("Super_R" );
1426 case WXK_WINDOWS_MENU
:
1427 hotkey
<< wxT("Menu" );
1430 hotkey
<< wxT("Command" );
1432 /* These probably wouldn't work as there is no SpecialX in gdk/keynames.txt
1433 case WXK_SPECIAL1: case WXK_SPECIAL2: case WXK_SPECIAL3: case WXK_SPECIAL4:
1434 case WXK_SPECIAL5: case WXK_SPECIAL6: case WXK_SPECIAL7: case WXK_SPECIAL8:
1435 case WXK_SPECIAL9: case WXK_SPECIAL10: case WXK_SPECIAL11: case WXK_SPECIAL12:
1436 case WXK_SPECIAL13: case WXK_SPECIAL14: case WXK_SPECIAL15: case WXK_SPECIAL16:
1437 case WXK_SPECIAL17: case WXK_SPECIAL18: case WXK_SPECIAL19: case WXK_SPECIAL20:
1438 hotkey += wxString::Format(wxT("Special%d"), code - WXK_SPECIAL1 + 1);
1441 // if there are any other keys wxAcceleratorEntry::Create() may
1442 // return, we should process them here
1448 name
= wxGTK_CONV_BACK_SYS(gdk_keyval_name((guint
)code
));
1449 if ( !name
.empty() )
1456 wxFAIL_MSG( wxT("unknown keyboard accel") );
1465 #endif // wxUSE_ACCEL
1467 const char *wxGetStockGtkID(wxWindowID id
)
1469 #define STOCKITEM(wx,gtk) \
1473 #define STOCKITEM_MISSING(wx) \
1477 #if GTK_CHECK_VERSION(2,4,0)
1478 #define STOCKITEM_24(wx,gtk) STOCKITEM(wx,gtk)
1480 #define STOCKITEM_24(wx,gtk) STOCKITEM_MISSING(wx)
1483 #if GTK_CHECK_VERSION(2,6,0)
1484 #define STOCKITEM_26(wx,gtk) STOCKITEM(wx,gtk)
1486 #define STOCKITEM_26(wx,gtk) STOCKITEM_MISSING(wx)
1489 #if GTK_CHECK_VERSION(2,10,0)
1490 #define STOCKITEM_210(wx,gtk) STOCKITEM(wx,gtk)
1492 #define STOCKITEM_210(wx,gtk) STOCKITEM_MISSING(wx)
1498 STOCKITEM_26(wxID_ABOUT
, GTK_STOCK_ABOUT
)
1499 STOCKITEM(wxID_ADD
, GTK_STOCK_ADD
)
1500 STOCKITEM(wxID_APPLY
, GTK_STOCK_APPLY
)
1501 STOCKITEM(wxID_BOLD
, GTK_STOCK_BOLD
)
1502 STOCKITEM(wxID_CANCEL
, GTK_STOCK_CANCEL
)
1503 STOCKITEM(wxID_CLEAR
, GTK_STOCK_CLEAR
)
1504 STOCKITEM(wxID_CLOSE
, GTK_STOCK_CLOSE
)
1505 STOCKITEM(wxID_COPY
, GTK_STOCK_COPY
)
1506 STOCKITEM(wxID_CUT
, GTK_STOCK_CUT
)
1507 STOCKITEM(wxID_DELETE
, GTK_STOCK_DELETE
)
1508 STOCKITEM_26(wxID_EDIT
, GTK_STOCK_EDIT
)
1509 STOCKITEM(wxID_FIND
, GTK_STOCK_FIND
)
1510 STOCKITEM_26(wxID_FILE
, GTK_STOCK_FILE
)
1511 STOCKITEM(wxID_REPLACE
, GTK_STOCK_FIND_AND_REPLACE
)
1512 STOCKITEM(wxID_BACKWARD
, GTK_STOCK_GO_BACK
)
1513 STOCKITEM(wxID_DOWN
, GTK_STOCK_GO_DOWN
)
1514 STOCKITEM(wxID_FORWARD
, GTK_STOCK_GO_FORWARD
)
1515 STOCKITEM(wxID_UP
, GTK_STOCK_GO_UP
)
1516 STOCKITEM(wxID_HELP
, GTK_STOCK_HELP
)
1517 STOCKITEM(wxID_HOME
, GTK_STOCK_HOME
)
1518 STOCKITEM_24(wxID_INDENT
, GTK_STOCK_INDENT
)
1519 STOCKITEM(wxID_INDEX
, GTK_STOCK_INDEX
)
1520 STOCKITEM(wxID_ITALIC
, GTK_STOCK_ITALIC
)
1521 STOCKITEM(wxID_JUSTIFY_CENTER
, GTK_STOCK_JUSTIFY_CENTER
)
1522 STOCKITEM(wxID_JUSTIFY_FILL
, GTK_STOCK_JUSTIFY_FILL
)
1523 STOCKITEM(wxID_JUSTIFY_LEFT
, GTK_STOCK_JUSTIFY_LEFT
)
1524 STOCKITEM(wxID_JUSTIFY_RIGHT
, GTK_STOCK_JUSTIFY_RIGHT
)
1525 STOCKITEM(wxID_NEW
, GTK_STOCK_NEW
)
1526 STOCKITEM(wxID_NO
, GTK_STOCK_NO
)
1527 STOCKITEM(wxID_OK
, GTK_STOCK_OK
)
1528 STOCKITEM(wxID_OPEN
, GTK_STOCK_OPEN
)
1529 STOCKITEM(wxID_PASTE
, GTK_STOCK_PASTE
)
1530 STOCKITEM(wxID_PREFERENCES
, GTK_STOCK_PREFERENCES
)
1531 STOCKITEM(wxID_PRINT
, GTK_STOCK_PRINT
)
1532 STOCKITEM(wxID_PREVIEW
, GTK_STOCK_PRINT_PREVIEW
)
1533 STOCKITEM(wxID_PROPERTIES
, GTK_STOCK_PROPERTIES
)
1534 STOCKITEM(wxID_EXIT
, GTK_STOCK_QUIT
)
1535 STOCKITEM(wxID_REDO
, GTK_STOCK_REDO
)
1536 STOCKITEM(wxID_REFRESH
, GTK_STOCK_REFRESH
)
1537 STOCKITEM(wxID_REMOVE
, GTK_STOCK_REMOVE
)
1538 STOCKITEM(wxID_REVERT_TO_SAVED
, GTK_STOCK_REVERT_TO_SAVED
)
1539 STOCKITEM(wxID_SAVE
, GTK_STOCK_SAVE
)
1540 STOCKITEM(wxID_SAVEAS
, GTK_STOCK_SAVE_AS
)
1541 STOCKITEM_210(wxID_SELECTALL
, GTK_STOCK_SELECT_ALL
)
1542 STOCKITEM(wxID_STOP
, GTK_STOCK_STOP
)
1543 STOCKITEM(wxID_UNDELETE
, GTK_STOCK_UNDELETE
)
1544 STOCKITEM(wxID_UNDERLINE
, GTK_STOCK_UNDERLINE
)
1545 STOCKITEM(wxID_UNDO
, GTK_STOCK_UNDO
)
1546 STOCKITEM_24(wxID_UNINDENT
, GTK_STOCK_UNINDENT
)
1547 STOCKITEM(wxID_YES
, GTK_STOCK_YES
)
1548 STOCKITEM(wxID_ZOOM_100
, GTK_STOCK_ZOOM_100
)
1549 STOCKITEM(wxID_ZOOM_FIT
, GTK_STOCK_ZOOM_FIT
)
1550 STOCKITEM(wxID_ZOOM_IN
, GTK_STOCK_ZOOM_IN
)
1551 STOCKITEM(wxID_ZOOM_OUT
, GTK_STOCK_ZOOM_OUT
)
1554 wxFAIL_MSG( _T("invalid stock item ID") );
1565 bool wxGetStockGtkAccelerator(const char *id
, GdkModifierType
*mod
, guint
*key
)
1570 GtkStockItem stock_item
;
1571 if (gtk_stock_lookup (id
, &stock_item
))
1573 if (key
) *key
= stock_item
.keyval
;
1574 if (mod
) *mod
= stock_item
.modifier
;
1576 // some GTK stock items have zero values for the keyval;
1577 // it means that they do not have an accelerator...
1578 if (stock_item
.keyval
)
1584 #endif // wxUSE_ACCEL
1586 #endif // wxUSE_MENUS