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"
30 #include <gdk/gdktypes.h>
33 // FIXME: is this right? somehow I don't think so (VZ)
35 #define gtk_accel_group_attach(g, o) gtk_window_add_accel_group((o), (g))
36 #define gtk_accel_group_detach(g, o) gtk_window_remove_accel_group((o), (g))
37 //#define gtk_menu_ensure_uline_accel_group(m) gtk_menu_get_accel_group(m)
39 #define ACCEL_OBJECT GtkWindow
40 #define ACCEL_OBJECTS(a) (a)->acceleratables
41 #define ACCEL_OBJ_CAST(obj) ((GtkWindow*) obj)
43 // we use normal item but with a special id for the menu title
44 static const int wxGTK_TITLE_ID
= -3;
46 //-----------------------------------------------------------------------------
48 //-----------------------------------------------------------------------------
51 static wxString
GetGtkHotKey( const wxMenuItem
& item
);
54 //-----------------------------------------------------------------------------
56 //-----------------------------------------------------------------------------
58 static wxString
wxReplaceUnderscore( const wxString
& title
)
60 // GTK 1.2 wants to have "_" instead of "&" for accelerators
63 for ( wxString::const_iterator pc
= title
.begin(); pc
!= title
.end(); ++pc
)
65 if ((*pc
== wxT('&')) && (pc
+1 != title
.end()) && (*(pc
+1) == wxT('&')))
67 // "&" is doubled to indicate "&" instead of accelerator
71 else if (*pc
== wxT('&'))
77 if ( *pc
== wxT('_') )
79 // underscores must be doubled to prevent them from being
80 // interpreted as accelerator character prefix by GTK
88 // wxPrintf( wxT("before %s after %s\n"), title.c_str(), str.c_str() );
93 static wxString
wxConvertFromGTKToWXLabel(const wxString
& gtkLabel
)
96 for ( const wxChar
*pc
= gtkLabel
.c_str(); *pc
; pc
++ )
98 // '_' is the escape character for GTK+.
100 if ( *pc
== wxT('_') && *(pc
+1) == wxT('_'))
102 // An underscore was escaped.
106 else if ( *pc
== wxT('_') )
108 // Convert GTK+ hotkey symbol to wxWidgets/Windows standard
111 else if ( *pc
== wxT('&') )
113 // Double the ampersand to escape it as far as wxWidgets is concerned
118 // don't remove ampersands '&' since if we have them in the menu title
119 // it means that they were doubled to indicate "&" instead of accelerator
127 //-----------------------------------------------------------------------------
128 // activate message from GTK
129 //-----------------------------------------------------------------------------
131 static void DoCommonMenuCallbackCode(wxMenu
*menu
, wxMenuEvent
& event
)
133 event
.SetEventObject( menu
);
135 wxEvtHandler
* handler
= menu
->GetEventHandler();
136 if (handler
&& handler
->ProcessEvent(event
))
139 wxWindow
*win
= menu
->GetInvokingWindow();
141 win
->GetEventHandler()->ProcessEvent( event
);
147 gtk_menu_open_callback(GtkWidget
* WXUNUSED(widget
), wxMenu
*menu
)
149 wxMenuEvent
event(wxEVT_MENU_OPEN
, -1, menu
);
151 DoCommonMenuCallbackCode(menu
, event
);
155 gtk_menu_close_callback(GtkWidget
* WXUNUSED(widget
), wxMenuBar
*menubar
)
157 if ( !menubar
->GetMenuCount() )
159 // if menubar is empty we can't call GetMenu(0) below
163 wxMenuEvent
event( wxEVT_MENU_CLOSE
, -1, NULL
);
165 DoCommonMenuCallbackCode(menubar
->GetMenu(0), event
);
170 //-----------------------------------------------------------------------------
172 //-----------------------------------------------------------------------------
174 IMPLEMENT_DYNAMIC_CLASS(wxMenuBar
,wxWindow
)
176 void wxMenuBar::Init(size_t n
, wxMenu
*menus
[], const wxString titles
[], long style
)
179 m_invokingWindow
= NULL
;
181 if (!PreCreation( NULL
, wxDefaultPosition
, wxDefaultSize
) ||
182 !CreateBase( NULL
, -1, wxDefaultPosition
, wxDefaultSize
, style
, wxDefaultValidator
, wxT("menubar") ))
184 wxFAIL_MSG( wxT("wxMenuBar creation failed") );
188 m_menubar
= gtk_menu_bar_new();
190 if (style
& wxMB_DOCKABLE
)
192 m_widget
= gtk_handle_box_new();
193 gtk_container_add(GTK_CONTAINER(m_widget
), m_menubar
);
194 gtk_widget_show(m_menubar
);
198 m_widget
= m_menubar
;
205 for (size_t i
= 0; i
< n
; ++i
)
206 Append(menus
[i
], titles
[i
]);
208 // VZ: for some reason connecting to menus "deactivate" doesn't work (we
209 // don't get it when the menu is dismissed by clicking outside the
210 // toolbar) so we connect to the global one, even if it means that we
211 // can't pass the menu which was closed in wxMenuEvent object
212 g_signal_connect (m_menubar
, "deactivate",
213 G_CALLBACK (gtk_menu_close_callback
), this);
217 wxMenuBar::wxMenuBar(size_t n
, wxMenu
*menus
[], const wxString titles
[], long style
)
219 Init(n
, menus
, titles
, style
);
222 wxMenuBar::wxMenuBar(long style
)
224 Init(0, NULL
, NULL
, style
);
227 wxMenuBar::wxMenuBar()
229 Init(0, NULL
, NULL
, 0);
232 wxMenuBar::~wxMenuBar()
236 static void wxMenubarUnsetInvokingWindow( wxMenu
*menu
, wxWindow
*win
)
238 menu
->SetInvokingWindow( (wxWindow
*) NULL
);
240 wxWindow
*top_frame
= win
;
241 while (top_frame
->GetParent() && !(top_frame
->IsTopLevel()))
242 top_frame
= top_frame
->GetParent();
244 // support for native hot keys
245 ACCEL_OBJECT
*obj
= ACCEL_OBJ_CAST(top_frame
->m_widget
);
246 if ( menu
->m_accel
&& g_slist_find( ACCEL_OBJECTS(menu
->m_accel
), obj
) )
247 gtk_accel_group_detach( menu
->m_accel
, obj
);
249 wxMenuItemList::compatibility_iterator node
= menu
->GetMenuItems().GetFirst();
252 wxMenuItem
*menuitem
= node
->GetData();
253 if (menuitem
->IsSubMenu())
254 wxMenubarUnsetInvokingWindow( menuitem
->GetSubMenu(), win
);
255 node
= node
->GetNext();
259 static void wxMenubarSetInvokingWindow( wxMenu
*menu
, wxWindow
*win
)
261 menu
->SetInvokingWindow( win
);
263 wxWindow
*top_frame
= win
;
264 while (top_frame
->GetParent() && !(top_frame
->IsTopLevel()))
265 top_frame
= top_frame
->GetParent();
267 // support for native hot keys
268 ACCEL_OBJECT
*obj
= ACCEL_OBJ_CAST(top_frame
->m_widget
);
269 if ( !g_slist_find( ACCEL_OBJECTS(menu
->m_accel
), obj
) )
270 gtk_accel_group_attach( menu
->m_accel
, obj
);
272 wxMenuItemList::compatibility_iterator node
= menu
->GetMenuItems().GetFirst();
275 wxMenuItem
*menuitem
= node
->GetData();
276 if (menuitem
->IsSubMenu())
277 wxMenubarSetInvokingWindow( menuitem
->GetSubMenu(), win
);
278 node
= node
->GetNext();
282 void wxMenuBar::SetInvokingWindow( wxWindow
*win
)
284 m_invokingWindow
= win
;
285 wxWindow
*top_frame
= win
;
286 while (top_frame
->GetParent() && !(top_frame
->IsTopLevel()))
287 top_frame
= top_frame
->GetParent();
289 wxMenuList::compatibility_iterator node
= m_menus
.GetFirst();
292 wxMenu
*menu
= node
->GetData();
293 wxMenubarSetInvokingWindow( menu
, win
);
294 node
= node
->GetNext();
298 void wxMenuBar::SetLayoutDirection(wxLayoutDirection dir
)
300 if ( dir
== wxLayout_Default
)
302 const wxWindow
*const frame
= GetFrame();
305 // inherit layout from frame.
306 dir
= frame
->GetLayoutDirection();
308 else // use global layout
310 dir
= wxTheApp
->GetLayoutDirection();
314 if ( dir
== wxLayout_Default
)
317 GTKSetLayout(m_menubar
, dir
);
319 // also set the layout of all menus we already have (new ones will inherit
320 // the current layout)
321 for ( wxMenuList::compatibility_iterator node
= m_menus
.GetFirst();
323 node
= node
->GetNext() )
325 wxMenu
*const menu
= node
->GetData();
326 menu
->SetLayoutDirection(dir
);
330 wxLayoutDirection
wxMenuBar::GetLayoutDirection() const
332 return GTKGetLayout(m_menubar
);
335 void wxMenuBar::Attach(wxFrame
*frame
)
337 wxMenuBarBase::Attach(frame
);
339 SetLayoutDirection(wxLayout_Default
);
342 void wxMenuBar::UnsetInvokingWindow( wxWindow
*win
)
344 m_invokingWindow
= (wxWindow
*) NULL
;
345 wxWindow
*top_frame
= win
;
346 while (top_frame
->GetParent() && !(top_frame
->IsTopLevel()))
347 top_frame
= top_frame
->GetParent();
349 wxMenuList::compatibility_iterator node
= m_menus
.GetFirst();
352 wxMenu
*menu
= node
->GetData();
353 wxMenubarUnsetInvokingWindow( menu
, win
);
354 node
= node
->GetNext();
358 bool wxMenuBar::Append( wxMenu
*menu
, const wxString
&title
)
360 if ( !wxMenuBarBase::Append( menu
, title
) )
363 return GtkAppend(menu
, title
);
366 bool wxMenuBar::GtkAppend(wxMenu
*menu
, const wxString
& title
, int pos
)
368 wxString
str( wxReplaceUnderscore( title
) );
370 // This doesn't have much effect right now.
371 menu
->SetTitle( str
);
373 // The "m_owner" is the "menu item"
374 menu
->m_owner
= gtk_menu_item_new_with_mnemonic( wxGTK_CONV( str
) );
375 menu
->SetLayoutDirection(GetLayoutDirection());
377 gtk_widget_show( menu
->m_owner
);
379 gtk_menu_item_set_submenu( GTK_MENU_ITEM(menu
->m_owner
), menu
->m_menu
);
382 gtk_menu_shell_append( GTK_MENU_SHELL(m_menubar
), menu
->m_owner
);
384 gtk_menu_shell_insert( GTK_MENU_SHELL(m_menubar
), menu
->m_owner
, pos
);
386 g_signal_connect (menu
->m_owner
, "activate",
387 G_CALLBACK (gtk_menu_open_callback
),
390 // m_invokingWindow is set after wxFrame::SetMenuBar(). This call enables
391 // addings menu later on.
392 if (m_invokingWindow
)
394 wxMenubarSetInvokingWindow( menu
, m_invokingWindow
);
396 // OPTIMISE ME: we should probably cache this, or pass it
397 // directly, but for now this is a minimal
398 // change to validate the new dynamic sizing.
399 // see (and refactor :) similar code in Remove
402 wxFrame
*frame
= wxDynamicCast( m_invokingWindow
, wxFrame
);
405 frame
->UpdateMenuBarSize();
411 bool wxMenuBar::Insert(size_t pos
, wxMenu
*menu
, const wxString
& title
)
413 if ( !wxMenuBarBase::Insert(pos
, menu
, title
) )
418 if ( !GtkAppend(menu
, title
, (int)pos
) )
424 wxMenu
*wxMenuBar::Replace(size_t pos
, wxMenu
*menu
, const wxString
& title
)
426 // remove the old item and insert a new one
427 wxMenu
*menuOld
= Remove(pos
);
428 if ( menuOld
&& !Insert(pos
, menu
, title
) )
430 return (wxMenu
*) NULL
;
433 // either Insert() succeeded or Remove() failed and menuOld is NULL
437 wxMenu
*wxMenuBar::Remove(size_t pos
)
439 wxMenu
*menu
= wxMenuBarBase::Remove(pos
);
441 return (wxMenu
*) NULL
;
443 gtk_menu_item_remove_submenu( GTK_MENU_ITEM(menu
->m_owner
) );
444 gtk_container_remove(GTK_CONTAINER(m_menubar
), menu
->m_owner
);
446 gtk_widget_destroy( menu
->m_owner
);
447 menu
->m_owner
= NULL
;
449 if (m_invokingWindow
)
451 // OPTIMISE ME: see comment in GtkAppend
452 wxFrame
*frame
= wxDynamicCast( m_invokingWindow
, wxFrame
);
455 frame
->UpdateMenuBarSize();
457 wxMenubarUnsetInvokingWindow( menu
, m_invokingWindow
);
464 static int FindMenuItemRecursive( const wxMenu
*menu
, const wxString
&menuString
, const wxString
&itemString
)
466 if (wxMenuItem::GetLabelText(wxConvertFromGTKToWXLabel(menu
->GetTitle())) == wxMenuItem::GetLabelText(menuString
))
468 int res
= menu
->FindItem( itemString
);
469 if (res
!= wxNOT_FOUND
)
473 wxMenuItemList::compatibility_iterator node
= menu
->GetMenuItems().GetFirst();
476 wxMenuItem
*item
= node
->GetData();
477 if (item
->IsSubMenu())
478 return FindMenuItemRecursive(item
->GetSubMenu(), menuString
, itemString
);
480 node
= node
->GetNext();
486 int wxMenuBar::FindMenuItem( const wxString
&menuString
, const wxString
&itemString
) const
488 wxMenuList::compatibility_iterator node
= m_menus
.GetFirst();
491 wxMenu
*menu
= node
->GetData();
492 int res
= FindMenuItemRecursive( menu
, menuString
, itemString
);
495 node
= node
->GetNext();
501 // Find a wxMenuItem using its id. Recurses down into sub-menus
502 static wxMenuItem
* FindMenuItemByIdRecursive(const wxMenu
* menu
, int id
)
504 wxMenuItem
* result
= menu
->FindChildItem(id
);
506 wxMenuItemList::compatibility_iterator node
= menu
->GetMenuItems().GetFirst();
507 while ( node
&& result
== NULL
)
509 wxMenuItem
*item
= node
->GetData();
510 if (item
->IsSubMenu())
512 result
= FindMenuItemByIdRecursive( item
->GetSubMenu(), id
);
514 node
= node
->GetNext();
520 wxMenuItem
* wxMenuBar::FindItem( int id
, wxMenu
**menuForItem
) const
522 wxMenuItem
* result
= 0;
523 wxMenuList::compatibility_iterator node
= m_menus
.GetFirst();
524 while (node
&& result
== 0)
526 wxMenu
*menu
= node
->GetData();
527 result
= FindMenuItemByIdRecursive( menu
, id
);
528 node
= node
->GetNext();
533 *menuForItem
= result
? result
->GetMenu() : (wxMenu
*)NULL
;
539 void wxMenuBar::EnableTop( size_t pos
, bool flag
)
541 wxMenuList::compatibility_iterator node
= m_menus
.Item( pos
);
543 wxCHECK_RET( node
, wxT("menu not found") );
545 wxMenu
* menu
= node
->GetData();
548 gtk_widget_set_sensitive( menu
->m_owner
, flag
);
551 wxString
wxMenuBar::GetMenuLabel( size_t pos
) const
553 wxMenuList::compatibility_iterator node
= m_menus
.Item( pos
);
555 wxCHECK_MSG( node
, wxT("invalid"), wxT("menu not found") );
557 wxMenu
* menu
= node
->GetData();
559 return wxConvertFromGTKToWXLabel(menu
->GetTitle());
562 void wxMenuBar::SetMenuLabel( size_t pos
, const wxString
& label
)
564 wxMenuList::compatibility_iterator node
= m_menus
.Item( pos
);
566 wxCHECK_RET( node
, wxT("menu not found") );
568 wxMenu
* menu
= node
->GetData();
570 const wxString
str( wxReplaceUnderscore( label
) );
572 menu
->SetTitle( str
);
575 gtk_label_set_text_with_mnemonic( GTK_LABEL( GTK_BIN(menu
->m_owner
)->child
), wxGTK_CONV(str
) );
578 //-----------------------------------------------------------------------------
580 //-----------------------------------------------------------------------------
583 static void gtk_menu_clicked_callback( GtkWidget
*widget
, wxMenu
*menu
)
585 int id
= menu
->FindMenuIdByMenuItem(widget
);
587 /* should find it for normal (not popup) menu */
588 wxASSERT_MSG( (id
!= -1) || (menu
->GetInvokingWindow() != NULL
),
589 _T("menu item not found in gtk_menu_clicked_callback") );
591 if (!menu
->IsEnabled(id
))
594 wxMenuItem
* item
= menu
->FindChildItem( id
);
595 wxCHECK_RET( item
, wxT("error in menu item callback") );
597 if ( item
->GetId() == wxGTK_TITLE_ID
)
599 // ignore events from the menu title
603 if (item
->IsCheckable())
605 bool isReallyChecked
= item
->IsChecked(),
606 isInternallyChecked
= item
->wxMenuItemBase::IsChecked();
608 // ensure that the internal state is always consistent with what is
609 // shown on the screen
610 item
->wxMenuItemBase::Check(isReallyChecked
);
612 // we must not report the events for the radio button going up nor the
613 // events resulting from the calls to wxMenuItem::Check()
614 if ( (item
->GetKind() == wxITEM_RADIO
&& !isReallyChecked
) ||
615 (isInternallyChecked
== isReallyChecked
) )
622 // Is this menu on a menubar? (possibly nested)
623 wxFrame
* frame
= NULL
;
624 if(menu
->IsAttached())
625 frame
= menu
->GetMenuBar()->GetFrame();
627 // FIXME: why do we have to call wxFrame::GetEventHandler() directly here?
628 // normally wxMenu::SendEvent() should be enough, if it doesn't work
629 // in wxGTK then we have a bug in wxMenu::GetInvokingWindow() which
630 // should be fixed instead of working around it here...
633 // If it is attached then let the frame send the event.
634 // Don't call frame->ProcessCommand(id) because it toggles
635 // checkable items and we've already done that above.
636 wxCommandEvent
commandEvent(wxEVT_COMMAND_MENU_SELECTED
, id
);
637 commandEvent
.SetEventObject(frame
);
638 if (item
->IsCheckable())
639 commandEvent
.SetInt(item
->IsChecked());
640 commandEvent
.SetEventObject(menu
);
642 frame
->GetEventHandler()->ProcessEvent(commandEvent
);
646 // otherwise let the menu have it
647 menu
->SendEvent(id
, item
->IsCheckable() ? item
->IsChecked() : -1);
652 //-----------------------------------------------------------------------------
654 //-----------------------------------------------------------------------------
657 static void gtk_menu_hilight_callback( GtkWidget
*widget
, wxMenu
*menu
)
659 int id
= menu
->FindMenuIdByMenuItem(widget
);
661 wxASSERT( id
!= -1 ); // should find it!
663 if (!menu
->IsEnabled(id
))
666 wxMenuEvent
event( wxEVT_MENU_HIGHLIGHT
, id
);
667 event
.SetEventObject( menu
);
669 wxEvtHandler
* handler
= menu
->GetEventHandler();
670 if (handler
&& handler
->ProcessEvent(event
))
673 wxWindow
*win
= menu
->GetInvokingWindow();
674 if (win
) win
->GetEventHandler()->ProcessEvent( event
);
678 //-----------------------------------------------------------------------------
680 //-----------------------------------------------------------------------------
683 static void gtk_menu_nolight_callback( GtkWidget
*widget
, wxMenu
*menu
)
685 int id
= menu
->FindMenuIdByMenuItem(widget
);
687 wxASSERT( id
!= -1 ); // should find it!
689 if (!menu
->IsEnabled(id
))
692 wxMenuEvent
event( wxEVT_MENU_HIGHLIGHT
, -1 );
693 event
.SetEventObject( menu
);
695 wxEvtHandler
* handler
= menu
->GetEventHandler();
696 if (handler
&& handler
->ProcessEvent(event
))
699 wxWindow
*win
= menu
->GetInvokingWindow();
701 win
->GetEventHandler()->ProcessEvent( event
);
705 //-----------------------------------------------------------------------------
707 //-----------------------------------------------------------------------------
709 IMPLEMENT_DYNAMIC_CLASS(wxMenuItem
, wxObject
)
711 wxMenuItem
*wxMenuItemBase::New(wxMenu
*parentMenu
,
713 const wxString
& name
,
714 const wxString
& help
,
718 return new wxMenuItem(parentMenu
, id
, name
, help
, kind
, subMenu
);
721 wxMenuItem::wxMenuItem(wxMenu
*parentMenu
,
723 const wxString
& text
,
724 const wxString
& help
,
727 : wxMenuItemBase(parentMenu
, id
, text
, help
, kind
, subMenu
)
732 wxMenuItem::wxMenuItem(wxMenu
*parentMenu
,
734 const wxString
& text
,
735 const wxString
& help
,
738 : wxMenuItemBase(parentMenu
, id
, text
, help
,
739 isCheckable
? wxITEM_CHECK
: wxITEM_NORMAL
, subMenu
)
744 void wxMenuItem::Init(const wxString
& text
)
746 m_labelWidget
= (GtkWidget
*) NULL
;
747 m_menuItem
= (GtkWidget
*) NULL
;
752 wxMenuItem::~wxMenuItem()
754 // don't delete menu items, the menus take care of that
757 // return the menu item text without any menu accels
760 wxString
wxMenuItemBase::GetLabelText(const wxString
& text
)
762 // The argument to this function will now always be in wxWidgets standard label
763 // format, not GTK+ format, so we do what the other ports do.
765 return wxStripMenuCodes(text
);
770 for ( const wxChar
*pc
= text
.c_str(); *pc
; pc
++ )
772 if ( *pc
== wxT('\t'))
775 if ( *pc
== wxT('_') )
777 // GTK 1.2 escapes "xxx_xxx" to "xxx__xxx"
783 if ( *pc
== wxT('\\') )
785 // GTK 2.0 escapes "xxx/xxx" to "xxx\/xxx"
791 if ( (*pc
== wxT('&')) && (*(pc
+1) != wxT('&')) )
794 // "&" is doubled to indicate "&" instead of accelerator
801 // wxPrintf( wxT("GetLabelText(): text %s label %s\n"), text.c_str(), label.c_str() );
807 wxString
wxMenuItem::GetItemLabel() const
809 wxString label
= wxConvertFromGTKToWXLabel(m_text
);
810 if (!m_hotKey
.IsEmpty())
811 label
= label
+ wxT("\t") + m_hotKey
;
815 void wxMenuItem::SetItemLabel( const wxString
& str
)
817 // cache some data which must be used later
818 bool isstock
= wxIsStockID(GetId());
819 const char *stockid
= NULL
;
821 stockid
= wxGetStockGtkID(GetId());
823 // Some optimization to avoid flicker
824 wxString oldLabel
= m_text
;
825 oldLabel
= wxStripMenuCodes(oldLabel
);
826 oldLabel
.Replace(wxT("_"), wxT(""));
827 wxString label1
= wxStripMenuCodes(str
);
828 wxString oldhotkey
= GetHotKey(); // Store the old hotkey in Ctrl-foo format
829 wxCharBuffer oldbuf
= wxGTK_CONV_SYS( GetGtkHotKey(*this) ); // and as <control>foo
833 if (oldLabel
== label1
&&
834 oldhotkey
== GetHotKey()) // Make sure we can change a hotkey even if the label is unaltered
841 label
= (GtkLabel
*) m_labelWidget
;
843 label
= GTK_LABEL( GTK_BIN(m_menuItem
)->child
);
845 // stock menu items can have empty labels:
846 wxString text
= m_text
;
847 if (text
.IsEmpty() && !IsSeparator())
849 wxASSERT_MSG(isstock
, wxT("A non-stock menu item with an empty label?"));
850 text
= wxGetStockLabel(GetId());
852 // need & => _ conversion
853 text
= GTKProcessMenuItemLabel(text
, NULL
);
856 gtk_label_set_text_with_mnemonic( GTK_LABEL(label
), wxGTK_CONV_SYS(text
) );
859 // remove old accelerator from our parent's accelerator group, if present
861 GdkModifierType accel_mods
;
862 if (oldbuf
[(size_t)0] != '\0')
864 gtk_accelerator_parse( (const char*) oldbuf
, &accel_key
, &accel_mods
);
867 gtk_widget_remove_accelerator(m_menuItem
,
868 m_parentMenu
->m_accel
,
875 // if the accelerator was taken from a stock ID, just get it back from GTK+ stock
876 if (wxGetStockGtkAccelerator(stockid
, &accel_mods
, &accel_key
))
877 gtk_widget_remove_accelerator( m_menuItem
,
878 m_parentMenu
->m_accel
,
883 // add new accelerator to our parent's accelerator group
884 wxCharBuffer buf
= wxGTK_CONV_SYS( GetGtkHotKey(*this) );
885 if (buf
[(size_t)0] != '\0')
887 gtk_accelerator_parse( (const char*) buf
, &accel_key
, &accel_mods
);
890 gtk_widget_add_accelerator( m_menuItem
,
892 m_parentMenu
->m_accel
,
900 // if the accelerator was taken from a stock ID, just get it back from GTK+ stock
901 if (wxGetStockGtkAccelerator(stockid
, &accel_mods
, &accel_key
))
902 gtk_widget_remove_accelerator( m_menuItem
,
903 m_parentMenu
->m_accel
,
909 // NOTE: this function is different from the similar functions GTKProcessMnemonics()
910 // implemented in control.cpp and from wxMenuItemBase::GetLabelText...
911 // so there's no real code duplication
912 wxString
wxMenuItem::GTKProcessMenuItemLabel(const wxString
& str
, wxString
*hotKey
)
916 // '\t' is the deliminator indicating a hot key
917 wxString::const_iterator pc
= str
.begin();
918 while ( pc
!= str
.end() && *pc
!= wxT('\t') )
922 wxString::const_iterator next
= pc
+ 1;
923 if (next
!= str
.end() && *next
== wxT('&'))
925 // "&" is doubled to indicate "&" instead of accelerator
934 else if ( *pc
== wxT('_') ) // escape underscores
951 hotKey
->assign(pc
, str
.end());
958 // it's valid for this function to be called even if m_menuItem == NULL
959 void wxMenuItem::DoSetText( const wxString
& str
)
962 m_text
= GTKProcessMenuItemLabel(str
, &m_hotKey
);
967 wxAcceleratorEntry
*wxMenuItem::GetAccel() const
975 // accelerator parsing code looks for them after a TAB, so insert a dummy
978 label
<< wxT('\t') << GetHotKey();
980 return wxAcceleratorEntry::Create(label
);
983 #endif // wxUSE_ACCEL
985 void wxMenuItem::Check( bool check
)
987 wxCHECK_RET( m_menuItem
, wxT("invalid menu item") );
989 if (check
== m_isChecked
)
992 wxMenuItemBase::Check( check
);
998 gtk_check_menu_item_set_active( (GtkCheckMenuItem
*)m_menuItem
, (gint
)check
);
1002 wxFAIL_MSG( _T("can't check this item") );
1006 void wxMenuItem::Enable( bool enable
)
1008 wxCHECK_RET( m_menuItem
, wxT("invalid menu item") );
1010 gtk_widget_set_sensitive( m_menuItem
, enable
);
1011 wxMenuItemBase::Enable( enable
);
1014 bool wxMenuItem::IsChecked() const
1016 wxCHECK_MSG( m_menuItem
, false, wxT("invalid menu item") );
1018 wxCHECK_MSG( IsCheckable(), false,
1019 wxT("can't get state of uncheckable item!") );
1021 return ((GtkCheckMenuItem
*)m_menuItem
)->active
!= 0;
1024 //-----------------------------------------------------------------------------
1026 //-----------------------------------------------------------------------------
1028 IMPLEMENT_DYNAMIC_CLASS(wxMenu
,wxEvtHandler
)
1032 m_accel
= gtk_accel_group_new();
1033 m_menu
= gtk_menu_new();
1034 // NB: keep reference to the menu so that it is not destroyed behind
1035 // our back by GTK+ e.g. when it is removed from menubar:
1036 gtk_widget_ref(m_menu
);
1038 m_owner
= (GtkWidget
*) NULL
;
1040 // Tearoffs are entries, just like separators. So if we want this
1041 // menu to be a tear-off one, we just append a tearoff entry
1043 if ( m_style
& wxMENU_TEAROFF
)
1045 GtkWidget
*tearoff
= gtk_tearoff_menu_item_new();
1047 gtk_menu_shell_append(GTK_MENU_SHELL(m_menu
), tearoff
);
1052 // append the title as the very first entry if we have it
1053 if ( !m_title
.empty() )
1055 Append(wxGTK_TITLE_ID
, m_title
);
1062 if ( GTK_IS_WIDGET( m_menu
))
1065 gtk_widget_unref( m_menu
);
1066 g_object_unref( m_accel
);
1068 // if the menu is inserted in another menu at this time, there was
1069 // one more reference to it:
1071 gtk_widget_destroy( m_menu
);
1074 // This must come after we release GTK resources above. Otherwise, GTK will
1075 // give warnings/errors when attempting to free accelerator resources from
1076 // child items that just were destroyed (the m_menu widget can contain
1077 // references to accelerators in child items. Problem detected when removing
1078 // a menu from a wxMenuBar, and the removed menu had submenus with accelerators.)
1079 WX_CLEAR_LIST(wxMenuItemList
, m_items
);
1082 void wxMenu::SetLayoutDirection(const wxLayoutDirection dir
)
1085 wxWindow::GTKSetLayout(m_owner
, dir
);
1086 //else: will be called later by wxMenuBar again
1089 wxLayoutDirection
wxMenu::GetLayoutDirection() const
1091 return wxWindow::GTKGetLayout(m_owner
);
1094 bool wxMenu::GtkAppend(wxMenuItem
*mitem
, int pos
)
1096 GtkWidget
*menuItem
;
1098 // cache some data used later
1099 wxString text
= mitem
->wxMenuItemBase::GetItemLabel();
1100 int id
= mitem
->GetId();
1101 bool isstock
= wxIsStockID(id
);
1102 const char *stockid
= NULL
;
1104 stockid
= wxGetStockGtkID(mitem
->GetId());
1106 // stock menu items can have an empty label
1107 if (text
.IsEmpty() && !mitem
->IsSeparator())
1109 wxASSERT_MSG(isstock
, wxT("A non-stock menu item with an empty label?"));
1110 text
= wxGetStockLabel(id
);
1112 // need & => _ conversion
1113 text
= wxMenuItem::GTKProcessMenuItemLabel(text
, NULL
);
1116 if ( mitem
->IsSeparator() )
1118 menuItem
= gtk_separator_menu_item_new();
1120 else if ( mitem
->GetBitmap().Ok() ||
1121 (mitem
->GetKind() == wxITEM_NORMAL
&& isstock
) )
1123 wxBitmap
bitmap(mitem
->GetBitmap());
1125 menuItem
= gtk_image_menu_item_new_with_mnemonic( wxGTK_CONV_SYS( text
) );
1130 // use stock bitmap for this item if available on the assumption
1131 // that it never hurts to follow GTK+ conventions more closely
1132 image
= stockid
? gtk_image_new_from_stock(stockid
, GTK_ICON_SIZE_MENU
)
1135 else // we have a custom bitmap
1137 wxASSERT_MSG( mitem
->GetKind() == wxITEM_NORMAL
,
1138 _T("only normal menu items can have bitmaps") );
1140 if ( bitmap
.HasPixbuf() )
1142 image
= gtk_image_new_from_pixbuf(bitmap
.GetPixbuf());
1146 GdkPixmap
*gdk_pixmap
= bitmap
.GetPixmap();
1147 GdkBitmap
*gdk_bitmap
= bitmap
.GetMask() ?
1148 bitmap
.GetMask()->GetBitmap() :
1150 image
= gtk_image_new_from_pixmap( gdk_pixmap
, gdk_bitmap
);
1156 gtk_widget_show(image
);
1158 gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(menuItem
), image
);
1163 else // a normal item
1165 // NB: 'text' variable has "_" instead of "&" after mitem->SetItemLabel()
1168 switch ( mitem
->GetKind() )
1172 menuItem
= gtk_check_menu_item_new_with_mnemonic( wxGTK_CONV_SYS( text
) );
1179 GSList
*group
= NULL
;
1180 if ( m_prevRadio
== NULL
)
1182 // start of a new radio group
1183 m_prevRadio
= menuItem
=
1184 gtk_radio_menu_item_new_with_mnemonic( group
, wxGTK_CONV_SYS( text
) );
1186 else // continue the radio group
1188 group
= gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (m_prevRadio
));
1189 m_prevRadio
= menuItem
=
1190 gtk_radio_menu_item_new_with_mnemonic( group
, wxGTK_CONV_SYS( text
) );
1196 wxFAIL_MSG( _T("unexpected menu item kind") );
1201 menuItem
= gtk_menu_item_new_with_mnemonic( wxGTK_CONV_SYS( text
) );
1210 GdkModifierType accel_mods
;
1211 wxCharBuffer buf
= wxGTK_CONV_SYS( GetGtkHotKey(*mitem
) );
1213 // wxPrintf( wxT("item: %s hotkey %s\n"), mitem->GetItemLabel().c_str(), GetGtkHotKey(*mitem).c_str() );
1214 if (buf
[(size_t)0] != '\0')
1216 gtk_accelerator_parse( (const char*) buf
, &accel_key
, &accel_mods
);
1219 gtk_widget_add_accelerator (menuItem
,
1229 // if the accelerator was taken from a stock ID, just get it back from GTK+ stock
1230 if (wxGetStockGtkAccelerator(stockid
, &accel_mods
, &accel_key
))
1231 gtk_widget_add_accelerator( menuItem
,
1240 gtk_menu_shell_append(GTK_MENU_SHELL(m_menu
), menuItem
);
1242 gtk_menu_shell_insert(GTK_MENU_SHELL(m_menu
), menuItem
, pos
);
1244 gtk_widget_show( menuItem
);
1246 if ( !mitem
->IsSeparator() )
1248 wxASSERT_MSG( menuItem
, wxT("invalid menuitem") );
1250 g_signal_connect (menuItem
, "select",
1251 G_CALLBACK (gtk_menu_hilight_callback
), this);
1252 g_signal_connect (menuItem
, "deselect",
1253 G_CALLBACK (gtk_menu_nolight_callback
), this);
1255 if ( mitem
->IsSubMenu() && mitem
->GetKind() != wxITEM_RADIO
&& mitem
->GetKind() != wxITEM_CHECK
)
1257 gtk_menu_item_set_submenu( GTK_MENU_ITEM(menuItem
), mitem
->GetSubMenu()->m_menu
);
1259 gtk_widget_show( mitem
->GetSubMenu()->m_menu
);
1261 // if adding a submenu to a menu already existing in the menu bar, we
1262 // must set invoking window to allow processing events from this
1264 if ( m_invokingWindow
)
1265 wxMenubarSetInvokingWindow(mitem
->GetSubMenu(), m_invokingWindow
);
1269 g_signal_connect (menuItem
, "activate",
1270 G_CALLBACK (gtk_menu_clicked_callback
),
1275 mitem
->SetMenuItem(menuItem
);
1279 // This doesn't even exist!
1280 // gtk_widget_lock_accelerators(mitem->GetMenuItem());
1286 wxMenuItem
* wxMenu::DoAppend(wxMenuItem
*mitem
)
1288 if (!GtkAppend(mitem
))
1291 return wxMenuBase::DoAppend(mitem
);
1294 wxMenuItem
* wxMenu::DoInsert(size_t pos
, wxMenuItem
*item
)
1296 if ( !wxMenuBase::DoInsert(pos
, item
) )
1300 if ( !GtkAppend(item
, (int)pos
) )
1306 wxMenuItem
*wxMenu::DoRemove(wxMenuItem
*item
)
1308 if ( !wxMenuBase::DoRemove(item
) )
1309 return (wxMenuItem
*)NULL
;
1311 // TODO: this code doesn't delete the item factory item and this seems
1312 // impossible as of GTK 1.2.6.
1313 gtk_widget_destroy( item
->GetMenuItem() );
1318 int wxMenu::FindMenuIdByMenuItem( GtkWidget
*menuItem
) const
1320 wxMenuItemList::compatibility_iterator node
= m_items
.GetFirst();
1323 wxMenuItem
*item
= node
->GetData();
1324 if (item
->GetMenuItem() == menuItem
)
1325 return item
->GetId();
1326 node
= node
->GetNext();
1332 void wxMenu::Attach(wxMenuBarBase
*menubar
)
1334 wxMenuBase::Attach(menubar
);
1336 // inherit layout direction from menubar.
1337 SetLayoutDirection(menubar
->GetLayoutDirection());
1340 // ----------------------------------------------------------------------------
1342 // ----------------------------------------------------------------------------
1346 static wxString
GetGtkHotKey( const wxMenuItem
& item
)
1350 wxAcceleratorEntry
*accel
= item
.GetAccel();
1353 int flags
= accel
->GetFlags();
1354 if ( flags
& wxACCEL_ALT
)
1355 hotkey
+= wxT("<alt>");
1356 if ( flags
& wxACCEL_CTRL
)
1357 hotkey
+= wxT("<control>");
1358 if ( flags
& wxACCEL_SHIFT
)
1359 hotkey
+= wxT("<shift>");
1361 int code
= accel
->GetKeyCode();
1388 hotkey
+= wxString::Format(wxT("F%d"), code
- WXK_F1
+ 1);
1391 // TODO: we should use gdk_keyval_name() (a.k.a.
1392 // XKeysymToString) here as well as hardcoding the keysym
1393 // names this might be not portable
1395 hotkey
<< wxT("Insert" );
1398 hotkey
<< wxT("Delete" );
1401 hotkey
<< wxT("Up" );
1404 hotkey
<< wxT("Down" );
1407 hotkey
<< wxT("Page_Up" );
1410 hotkey
<< wxT("Page_Down" );
1413 hotkey
<< wxT("Left" );
1416 hotkey
<< wxT("Right" );
1419 hotkey
<< wxT("Home" );
1422 hotkey
<< wxT("End" );
1425 hotkey
<< wxT("Return" );
1428 hotkey
<< wxT("BackSpace" );
1431 hotkey
<< wxT("Tab" );
1434 hotkey
<< wxT("Esc" );
1437 hotkey
<< wxT("space" );
1440 hotkey
<< wxT("Multiply" );
1443 hotkey
<< wxT("Add" );
1446 hotkey
<< wxT("Separator" );
1449 hotkey
<< wxT("Subtract" );
1452 hotkey
<< wxT("Decimal" );
1455 hotkey
<< wxT("Divide" );
1458 hotkey
<< wxT("Cancel" );
1461 hotkey
<< wxT("Clear" );
1464 hotkey
<< wxT("Menu" );
1467 hotkey
<< wxT("Pause" );
1470 hotkey
<< wxT("Capital" );
1473 hotkey
<< wxT("Select" );
1476 hotkey
<< wxT("Print" );
1479 hotkey
<< wxT("Execute" );
1482 hotkey
<< wxT("Snapshot" );
1485 hotkey
<< wxT("Help" );
1488 hotkey
<< wxT("Num_Lock" );
1491 hotkey
<< wxT("Scroll_Lock" );
1493 case WXK_NUMPAD_INSERT
:
1494 hotkey
<< wxT("KP_Insert" );
1496 case WXK_NUMPAD_DELETE
:
1497 hotkey
<< wxT("KP_Delete" );
1499 case WXK_NUMPAD_SPACE
:
1500 hotkey
<< wxT("KP_Space" );
1502 case WXK_NUMPAD_TAB
:
1503 hotkey
<< wxT("KP_Tab" );
1505 case WXK_NUMPAD_ENTER
:
1506 hotkey
<< wxT("KP_Enter" );
1508 case WXK_NUMPAD_F1
: case WXK_NUMPAD_F2
: case WXK_NUMPAD_F3
:
1510 hotkey
+= wxString::Format(wxT("KP_F%d"), code
- WXK_NUMPAD_F1
+ 1);
1512 case WXK_NUMPAD_HOME
:
1513 hotkey
<< wxT("KP_Home" );
1515 case WXK_NUMPAD_LEFT
:
1516 hotkey
<< wxT("KP_Left" );
1519 hotkey
<< wxT("KP_Up" );
1521 case WXK_NUMPAD_RIGHT
:
1522 hotkey
<< wxT("KP_Right" );
1524 case WXK_NUMPAD_DOWN
:
1525 hotkey
<< wxT("KP_Down" );
1527 case WXK_NUMPAD_PAGEUP
:
1528 hotkey
<< wxT("KP_Page_Up" );
1530 case WXK_NUMPAD_PAGEDOWN
:
1531 hotkey
<< wxT("KP_Page_Down" );
1533 case WXK_NUMPAD_END
:
1534 hotkey
<< wxT("KP_End" );
1536 case WXK_NUMPAD_BEGIN
:
1537 hotkey
<< wxT("KP_Begin" );
1539 case WXK_NUMPAD_EQUAL
:
1540 hotkey
<< wxT("KP_Equal" );
1542 case WXK_NUMPAD_MULTIPLY
:
1543 hotkey
<< wxT("KP_Multiply" );
1545 case WXK_NUMPAD_ADD
:
1546 hotkey
<< wxT("KP_Add" );
1548 case WXK_NUMPAD_SEPARATOR
:
1549 hotkey
<< wxT("KP_Separator" );
1551 case WXK_NUMPAD_SUBTRACT
:
1552 hotkey
<< wxT("KP_Subtract" );
1554 case WXK_NUMPAD_DECIMAL
:
1555 hotkey
<< wxT("KP_Decimal" );
1557 case WXK_NUMPAD_DIVIDE
:
1558 hotkey
<< wxT("KP_Divide" );
1560 case WXK_NUMPAD0
: case WXK_NUMPAD1
: case WXK_NUMPAD2
:
1561 case WXK_NUMPAD3
: case WXK_NUMPAD4
: case WXK_NUMPAD5
:
1562 case WXK_NUMPAD6
: case WXK_NUMPAD7
: case WXK_NUMPAD8
: case WXK_NUMPAD9
:
1563 hotkey
+= wxString::Format(wxT("KP_%d"), code
- WXK_NUMPAD0
);
1565 case WXK_WINDOWS_LEFT
:
1566 hotkey
<< wxT("Super_L" );
1568 case WXK_WINDOWS_RIGHT
:
1569 hotkey
<< wxT("Super_R" );
1571 case WXK_WINDOWS_MENU
:
1572 hotkey
<< wxT("Menu" );
1575 hotkey
<< wxT("Command" );
1577 /* These probably wouldn't work as there is no SpecialX in gdk/keynames.txt
1578 case WXK_SPECIAL1: case WXK_SPECIAL2: case WXK_SPECIAL3: case WXK_SPECIAL4:
1579 case WXK_SPECIAL5: case WXK_SPECIAL6: case WXK_SPECIAL7: case WXK_SPECIAL8:
1580 case WXK_SPECIAL9: case WXK_SPECIAL10: case WXK_SPECIAL11: case WXK_SPECIAL12:
1581 case WXK_SPECIAL13: case WXK_SPECIAL14: case WXK_SPECIAL15: case WXK_SPECIAL16:
1582 case WXK_SPECIAL17: case WXK_SPECIAL18: case WXK_SPECIAL19: case WXK_SPECIAL20:
1583 hotkey += wxString::Format(wxT("Special%d"), code - WXK_SPECIAL1 + 1);
1586 // if there are any other keys wxAcceleratorEntry::Create() may
1587 // return, we should process them here
1593 name
= wxGTK_CONV_BACK_SYS(gdk_keyval_name((guint
)code
));
1594 if ( !name
.empty() )
1601 wxFAIL_MSG( wxT("unknown keyboard accel") );
1610 #endif // wxUSE_ACCEL
1612 // ----------------------------------------------------------------------------
1613 // Pop-up menu stuff
1614 // ----------------------------------------------------------------------------
1616 #if wxUSE_MENUS_NATIVE
1618 extern "C" WXDLLIMPEXP_CORE
1619 void gtk_pop_hide_callback( GtkWidget
*WXUNUSED(widget
), bool* is_waiting
)
1621 *is_waiting
= false;
1624 WXDLLIMPEXP_CORE
void SetInvokingWindow( wxMenu
*menu
, wxWindow
* win
)
1626 menu
->SetInvokingWindow( win
);
1628 wxMenuItemList::compatibility_iterator node
= menu
->GetMenuItems().GetFirst();
1631 wxMenuItem
*menuitem
= node
->GetData();
1632 if (menuitem
->IsSubMenu())
1634 SetInvokingWindow( menuitem
->GetSubMenu(), win
);
1637 node
= node
->GetNext();
1641 extern "C" WXDLLIMPEXP_CORE
1642 void wxPopupMenuPositionCallback( GtkMenu
*menu
,
1644 gboolean
* WXUNUSED(whatever
),
1645 gpointer user_data
)
1647 // ensure that the menu appears entirely on screen
1649 gtk_widget_get_child_requisition(GTK_WIDGET(menu
), &req
);
1651 wxSize sizeScreen
= wxGetDisplaySize();
1652 wxPoint
*pos
= (wxPoint
*)user_data
;
1654 gint xmax
= sizeScreen
.x
- req
.width
,
1655 ymax
= sizeScreen
.y
- req
.height
;
1657 *x
= pos
->x
< xmax
? pos
->x
: xmax
;
1658 *y
= pos
->y
< ymax
? pos
->y
: ymax
;
1661 bool wxWindowGTK::DoPopupMenu( wxMenu
*menu
, int x
, int y
)
1663 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
1665 wxCHECK_MSG( menu
!= NULL
, false, wxT("invalid popup-menu") );
1667 // NOTE: if you change this code, you need to update
1668 // the same code in taskbar.cpp as well. This
1669 // is ugly code duplication, I know.
1671 SetInvokingWindow( menu
, this );
1675 bool is_waiting
= true;
1677 gulong handler
= g_signal_connect (menu
->m_menu
, "hide",
1678 G_CALLBACK (gtk_pop_hide_callback
),
1683 GtkMenuPositionFunc posfunc
;
1684 if ( x
== -1 && y
== -1 )
1686 // use GTK's default positioning algorithm
1692 pos
= ClientToScreen(wxPoint(x
, y
));
1694 posfunc
= wxPopupMenuPositionCallback
;
1697 wxMenuEvent
eventOpen(wxEVT_MENU_OPEN
, -1, menu
);
1698 DoCommonMenuCallbackCode(menu
, eventOpen
);
1701 GTK_MENU(menu
->m_menu
),
1702 (GtkWidget
*) NULL
, // parent menu shell
1703 (GtkWidget
*) NULL
, // parent menu item
1704 posfunc
, // function to position it
1705 userdata
, // client data
1706 0, // button used to activate it
1707 gtk_get_current_event_time()
1712 gtk_main_iteration();
1715 g_signal_handler_disconnect (menu
->m_menu
, handler
);
1717 wxMenuEvent
eventClose(wxEVT_MENU_CLOSE
, -1, menu
);
1718 DoCommonMenuCallbackCode(menu
, eventClose
);
1723 #endif // wxUSE_MENUS_NATIVE
1727 #include <gtk/gtk.h>
1729 const char *wxGetStockGtkID(wxWindowID id
)
1731 #define STOCKITEM(wx,gtk) \
1735 #define STOCKITEM_MISSING(wx) \
1739 #if GTK_CHECK_VERSION(2,4,0)
1740 #define STOCKITEM_24(wx,gtk) STOCKITEM(wx,gtk)
1742 #define STOCKITEM_24(wx,gtk) STOCKITEM_MISSING(wx)
1745 #if GTK_CHECK_VERSION(2,6,0)
1746 #define STOCKITEM_26(wx,gtk) STOCKITEM(wx,gtk)
1748 #define STOCKITEM_26(wx,gtk) STOCKITEM_MISSING(wx)
1751 #if GTK_CHECK_VERSION(2,10,0)
1752 #define STOCKITEM_210(wx,gtk) STOCKITEM(wx,gtk)
1754 #define STOCKITEM_210(wx,gtk) STOCKITEM_MISSING(wx)
1760 STOCKITEM_26(wxID_ABOUT
, GTK_STOCK_ABOUT
)
1761 STOCKITEM(wxID_ADD
, GTK_STOCK_ADD
)
1762 STOCKITEM(wxID_APPLY
, GTK_STOCK_APPLY
)
1763 STOCKITEM(wxID_BOLD
, GTK_STOCK_BOLD
)
1764 STOCKITEM(wxID_CANCEL
, GTK_STOCK_CANCEL
)
1765 STOCKITEM(wxID_CLEAR
, GTK_STOCK_CLEAR
)
1766 STOCKITEM(wxID_CLOSE
, GTK_STOCK_CLOSE
)
1767 STOCKITEM(wxID_COPY
, GTK_STOCK_COPY
)
1768 STOCKITEM(wxID_CUT
, GTK_STOCK_CUT
)
1769 STOCKITEM(wxID_DELETE
, GTK_STOCK_DELETE
)
1770 STOCKITEM_26(wxID_EDIT
, GTK_STOCK_EDIT
)
1771 STOCKITEM(wxID_FIND
, GTK_STOCK_FIND
)
1772 STOCKITEM_26(wxID_FILE
, GTK_STOCK_FILE
)
1773 STOCKITEM(wxID_REPLACE
, GTK_STOCK_FIND_AND_REPLACE
)
1774 STOCKITEM(wxID_BACKWARD
, GTK_STOCK_GO_BACK
)
1775 STOCKITEM(wxID_DOWN
, GTK_STOCK_GO_DOWN
)
1776 STOCKITEM(wxID_FORWARD
, GTK_STOCK_GO_FORWARD
)
1777 STOCKITEM(wxID_UP
, GTK_STOCK_GO_UP
)
1778 STOCKITEM(wxID_HELP
, GTK_STOCK_HELP
)
1779 STOCKITEM(wxID_HOME
, GTK_STOCK_HOME
)
1780 STOCKITEM_24(wxID_INDENT
, GTK_STOCK_INDENT
)
1781 STOCKITEM(wxID_INDEX
, GTK_STOCK_INDEX
)
1782 STOCKITEM(wxID_ITALIC
, GTK_STOCK_ITALIC
)
1783 STOCKITEM(wxID_JUSTIFY_CENTER
, GTK_STOCK_JUSTIFY_CENTER
)
1784 STOCKITEM(wxID_JUSTIFY_FILL
, GTK_STOCK_JUSTIFY_FILL
)
1785 STOCKITEM(wxID_JUSTIFY_LEFT
, GTK_STOCK_JUSTIFY_LEFT
)
1786 STOCKITEM(wxID_JUSTIFY_RIGHT
, GTK_STOCK_JUSTIFY_RIGHT
)
1787 STOCKITEM(wxID_NEW
, GTK_STOCK_NEW
)
1788 STOCKITEM(wxID_NO
, GTK_STOCK_NO
)
1789 STOCKITEM(wxID_OK
, GTK_STOCK_OK
)
1790 STOCKITEM(wxID_OPEN
, GTK_STOCK_OPEN
)
1791 STOCKITEM(wxID_PASTE
, GTK_STOCK_PASTE
)
1792 STOCKITEM(wxID_PREFERENCES
, GTK_STOCK_PREFERENCES
)
1793 STOCKITEM(wxID_PRINT
, GTK_STOCK_PRINT
)
1794 STOCKITEM(wxID_PREVIEW
, GTK_STOCK_PRINT_PREVIEW
)
1795 STOCKITEM(wxID_PROPERTIES
, GTK_STOCK_PROPERTIES
)
1796 STOCKITEM(wxID_EXIT
, GTK_STOCK_QUIT
)
1797 STOCKITEM(wxID_REDO
, GTK_STOCK_REDO
)
1798 STOCKITEM(wxID_REFRESH
, GTK_STOCK_REFRESH
)
1799 STOCKITEM(wxID_REMOVE
, GTK_STOCK_REMOVE
)
1800 STOCKITEM(wxID_REVERT_TO_SAVED
, GTK_STOCK_REVERT_TO_SAVED
)
1801 STOCKITEM(wxID_SAVE
, GTK_STOCK_SAVE
)
1802 STOCKITEM(wxID_SAVEAS
, GTK_STOCK_SAVE_AS
)
1803 STOCKITEM_210(wxID_SELECTALL
, GTK_STOCK_SELECT_ALL
)
1804 STOCKITEM(wxID_STOP
, GTK_STOCK_STOP
)
1805 STOCKITEM(wxID_UNDELETE
, GTK_STOCK_UNDELETE
)
1806 STOCKITEM(wxID_UNDERLINE
, GTK_STOCK_UNDERLINE
)
1807 STOCKITEM(wxID_UNDO
, GTK_STOCK_UNDO
)
1808 STOCKITEM_24(wxID_UNINDENT
, GTK_STOCK_UNINDENT
)
1809 STOCKITEM(wxID_YES
, GTK_STOCK_YES
)
1810 STOCKITEM(wxID_ZOOM_100
, GTK_STOCK_ZOOM_100
)
1811 STOCKITEM(wxID_ZOOM_FIT
, GTK_STOCK_ZOOM_FIT
)
1812 STOCKITEM(wxID_ZOOM_IN
, GTK_STOCK_ZOOM_IN
)
1813 STOCKITEM(wxID_ZOOM_OUT
, GTK_STOCK_ZOOM_OUT
)
1816 wxFAIL_MSG( _T("invalid stock item ID") );
1825 bool wxGetStockGtkAccelerator(const char *id
, GdkModifierType
*mod
, guint
*key
)
1830 GtkStockItem stock_item
;
1831 if (gtk_stock_lookup (id
, &stock_item
))
1833 if (key
) *key
= stock_item
.keyval
;
1834 if (mod
) *mod
= stock_item
.modifier
;
1836 // some GTK stock items have zero values for the keyval;
1837 // it means that they do not have an accelerator...
1838 if (stock_item
.keyval
)
1845 #endif // __WXGTK20__
1847 #endif // wxUSE_MENUS