]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/gtk/menu.cpp
make sure wxNativeFontInfo is defined
[wxWidgets.git] / src / gtk / menu.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: src/gtk/menu.cpp
3// Purpose: implementation of wxMenuBar and wxMenu classes for wxGTK
4// Author: Robert Roebling
5// Id: $Id$
6// Copyright: (c) 1998 Robert Roebling
7// Licence: wxWindows licence
8/////////////////////////////////////////////////////////////////////////////
9
10// For compilers that support precompilation, includes "wx.h".
11#include "wx/wxprec.h"
12
13#if wxUSE_MENUS
14
15#include "wx/menu.h"
16
17#ifndef WX_PRECOMP
18 #include "wx/intl.h"
19 #include "wx/log.h"
20 #include "wx/frame.h"
21 #include "wx/bitmap.h"
22 #include "wx/app.h"
23#endif
24
25#include "wx/accel.h"
26#include "wx/stockitem.h"
27#include "wx/gtk/private.h"
28#include "wx/gtk/private/mnemonics.h"
29
30// we use normal item but with a special id for the menu title
31static const int wxGTK_TITLE_ID = -3;
32
33// forward declare it as it's used by wxMenuBar too when using Hildon
34extern "C"
35{
36 static void menuitem_activate(GtkWidget*, wxMenuItem* item);
37}
38
39#if wxUSE_ACCEL
40static void wxGetGtkAccel(const wxMenuItem*, guint*, GdkModifierType*);
41#endif
42
43static void DoCommonMenuCallbackCode(wxMenu *menu, wxMenuEvent& event)
44{
45 event.SetEventObject( menu );
46
47 wxEvtHandler* handler = menu->GetEventHandler();
48 if (handler && handler->SafelyProcessEvent(event))
49 return;
50
51 wxWindow *win = menu->GetWindow();
52 wxCHECK_RET( win, "event for a menu without associated window?" );
53
54 win->HandleWindowEvent( event );
55}
56
57//-----------------------------------------------------------------------------
58// wxMenuBar
59//-----------------------------------------------------------------------------
60
61void wxMenuBar::Init(size_t n, wxMenu *menus[], const wxString titles[], long style)
62{
63#if wxUSE_LIBHILDON || wxUSE_LIBHILDON2
64 // Hildon window uses a single menu instead of a menu bar, so wxMenuBar is
65 // the same as menu in this case
66 m_widget =
67 m_menubar = gtk_menu_new();
68#else // !wxUSE_LIBHILDON && !wxUSE_LIBHILDON2
69 if (!PreCreation( NULL, wxDefaultPosition, wxDefaultSize ) ||
70 !CreateBase( NULL, -1, wxDefaultPosition, wxDefaultSize, style, wxDefaultValidator, wxT("menubar") ))
71 {
72 wxFAIL_MSG( wxT("wxMenuBar creation failed") );
73 return;
74 }
75
76 m_menubar = gtk_menu_bar_new();
77
78 if (style & wxMB_DOCKABLE)
79 {
80 m_widget = gtk_handle_box_new();
81 gtk_container_add(GTK_CONTAINER(m_widget), m_menubar);
82 gtk_widget_show(m_menubar);
83 }
84 else
85 {
86 m_widget = m_menubar;
87 }
88
89 PostCreation();
90
91 GTKApplyWidgetStyle();
92#endif // wxUSE_LIBHILDON || wxUSE_LIBHILDON2/!wxUSE_LIBHILDON && !wxUSE_LIBHILDON2
93
94 g_object_ref(m_widget);
95
96 for (size_t i = 0; i < n; ++i )
97 Append(menus[i], titles[i]);
98}
99
100wxMenuBar::wxMenuBar(size_t n, wxMenu *menus[], const wxString titles[], long style)
101{
102 Init(n, menus, titles, style);
103}
104
105wxMenuBar::wxMenuBar(long style)
106{
107 Init(0, NULL, NULL, style);
108}
109
110wxMenuBar::wxMenuBar()
111{
112 Init(0, NULL, NULL, 0);
113}
114
115// recursive helpers for wxMenuBar::Attach() and Detach(): they are called to
116// associate the menus with the frame they belong to or dissociate them from it
117namespace
118{
119
120void
121DetachFromFrame(wxMenu* menu, wxFrame* frame)
122{
123 // support for native hot keys
124 if (menu->m_accel)
125 {
126 // Note that wxGetTopLevelParent() is really needed because this frame
127 // can be an MDI child frame which is a fake frame and not a TLW at all
128 GtkWindow * const tlw = GTK_WINDOW(wxGetTopLevelParent(frame)->m_widget);
129 if (g_slist_find(menu->m_accel->acceleratables, tlw))
130 gtk_window_remove_accel_group(tlw, menu->m_accel);
131 }
132
133 wxMenuItemList::compatibility_iterator node = menu->GetMenuItems().GetFirst();
134 while (node)
135 {
136 wxMenuItem *menuitem = node->GetData();
137 if (menuitem->IsSubMenu())
138 DetachFromFrame(menuitem->GetSubMenu(), frame);
139 node = node->GetNext();
140 }
141}
142
143void
144AttachToFrame(wxMenu* menu, wxFrame* frame)
145{
146 // support for native hot keys
147 if (menu->m_accel)
148 {
149 GtkWindow * const tlw = GTK_WINDOW(wxGetTopLevelParent(frame)->m_widget);
150 if (!g_slist_find(menu->m_accel->acceleratables, tlw))
151 gtk_window_add_accel_group(tlw, menu->m_accel);
152 }
153
154 wxMenuItemList::compatibility_iterator node = menu->GetMenuItems().GetFirst();
155 while (node)
156 {
157 wxMenuItem *menuitem = node->GetData();
158 if (menuitem->IsSubMenu())
159 AttachToFrame(menuitem->GetSubMenu(), frame);
160 node = node->GetNext();
161 }
162}
163
164} // anonymous namespace
165
166void wxMenuBar::SetLayoutDirection(wxLayoutDirection dir)
167{
168 if ( dir == wxLayout_Default )
169 {
170 const wxWindow *const frame = GetFrame();
171 if ( frame )
172 {
173 // inherit layout from frame.
174 dir = frame->GetLayoutDirection();
175 }
176 else // use global layout
177 {
178 dir = wxTheApp->GetLayoutDirection();
179 }
180 }
181
182 if ( dir == wxLayout_Default )
183 return;
184
185 GTKSetLayout(m_menubar, dir);
186
187 // also set the layout of all menus we already have (new ones will inherit
188 // the current layout)
189 for ( wxMenuList::compatibility_iterator node = m_menus.GetFirst();
190 node;
191 node = node->GetNext() )
192 {
193 wxMenu *const menu = node->GetData();
194 menu->SetLayoutDirection(dir);
195 }
196}
197
198wxLayoutDirection wxMenuBar::GetLayoutDirection() const
199{
200 return GTKGetLayout(m_menubar);
201}
202
203void wxMenuBar::Attach(wxFrame *frame)
204{
205 wxMenuBarBase::Attach(frame);
206
207 wxMenuList::compatibility_iterator node = m_menus.GetFirst();
208 while (node)
209 {
210 wxMenu *menu = node->GetData();
211 AttachToFrame( menu, frame );
212 node = node->GetNext();
213 }
214
215 SetLayoutDirection(wxLayout_Default);
216}
217
218void wxMenuBar::Detach()
219{
220 wxMenuList::compatibility_iterator node = m_menus.GetFirst();
221 while (node)
222 {
223 wxMenu *menu = node->GetData();
224 DetachFromFrame( menu, m_menuBarFrame );
225 node = node->GetNext();
226 }
227
228 wxMenuBarBase::Detach();
229}
230
231bool wxMenuBar::Append( wxMenu *menu, const wxString &title )
232{
233 if ( !wxMenuBarBase::Append( menu, title ) )
234 return false;
235
236 return GtkAppend(menu, title);
237}
238
239bool wxMenuBar::GtkAppend(wxMenu *menu, const wxString& title, int pos)
240{
241 menu->SetLayoutDirection(GetLayoutDirection());
242
243#if wxUSE_LIBHILDON || wxUSE_LIBHILDON2
244 // if the menu has only one item, append it directly to the top level menu
245 // instead of inserting a useless submenu
246 if ( menu->GetMenuItemCount() == 1 )
247 {
248 wxMenuItem * const item = menu->FindItemByPosition(0);
249
250 // remove both mnemonics and accelerator: neither is useful under Maemo
251 const wxString str(wxStripMenuCodes(item->GetItemLabel()));
252
253 if ( item->IsSubMenu() )
254 return GtkAppend(item->GetSubMenu(), str, pos);
255
256 menu->m_owner = gtk_menu_item_new_with_mnemonic( wxGTK_CONV( str ) );
257
258 g_signal_connect(menu->m_owner, "activate",
259 G_CALLBACK(menuitem_activate), item);
260 item->SetMenuItem(menu->m_owner);
261 }
262 else
263#endif // wxUSE_LIBHILDON || wxUSE_LIBHILDON2 /!wxUSE_LIBHILDON && !wxUSE_LIBHILDON2
264 {
265 const wxString str(wxConvertMnemonicsToGTK(title));
266
267 // This doesn't have much effect right now.
268 menu->SetTitle( str );
269
270 // The "m_owner" is the "menu item"
271 menu->m_owner = gtk_menu_item_new_with_mnemonic( wxGTK_CONV( str ) );
272
273 gtk_menu_item_set_submenu( GTK_MENU_ITEM(menu->m_owner), menu->m_menu );
274 }
275
276 gtk_widget_show( menu->m_owner );
277
278 if (pos == -1)
279 gtk_menu_shell_append( GTK_MENU_SHELL(m_menubar), menu->m_owner );
280 else
281 gtk_menu_shell_insert( GTK_MENU_SHELL(m_menubar), menu->m_owner, pos );
282
283 if ( m_menuBarFrame )
284 AttachToFrame( menu, m_menuBarFrame );
285
286 return true;
287}
288
289bool wxMenuBar::Insert(size_t pos, wxMenu *menu, const wxString& title)
290{
291 if ( !wxMenuBarBase::Insert(pos, menu, title) )
292 return false;
293
294 // TODO
295
296 if ( !GtkAppend(menu, title, (int)pos) )
297 return false;
298
299 return true;
300}
301
302wxMenu *wxMenuBar::Replace(size_t pos, wxMenu *menu, const wxString& title)
303{
304 // remove the old item and insert a new one
305 wxMenu *menuOld = Remove(pos);
306 if ( menuOld && !Insert(pos, menu, title) )
307 {
308 return NULL;
309 }
310
311 // either Insert() succeeded or Remove() failed and menuOld is NULL
312 return menuOld;
313}
314
315wxMenu *wxMenuBar::Remove(size_t pos)
316{
317 wxMenu *menu = wxMenuBarBase::Remove(pos);
318 if ( !menu )
319 return NULL;
320
321 gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu->m_owner), NULL);
322 gtk_container_remove(GTK_CONTAINER(m_menubar), menu->m_owner);
323
324 gtk_widget_destroy( menu->m_owner );
325 menu->m_owner = NULL;
326
327 DetachFromFrame( menu, m_menuBarFrame );
328
329 return menu;
330}
331
332static int FindMenuItemRecursive( const wxMenu *menu, const wxString &menuString, const wxString &itemString )
333{
334 if (wxMenuItem::GetLabelText(menu->GetTitle()) == wxMenuItem::GetLabelText(menuString))
335 {
336 int res = menu->FindItem( itemString );
337 if (res != wxNOT_FOUND)
338 return res;
339 }
340
341 wxMenuItemList::compatibility_iterator node = menu->GetMenuItems().GetFirst();
342 while (node)
343 {
344 wxMenuItem *item = node->GetData();
345 if (item->IsSubMenu())
346 return FindMenuItemRecursive(item->GetSubMenu(), menuString, itemString);
347
348 node = node->GetNext();
349 }
350
351 return wxNOT_FOUND;
352}
353
354int wxMenuBar::FindMenuItem( const wxString &menuString, const wxString &itemString ) const
355{
356 wxMenuList::compatibility_iterator node = m_menus.GetFirst();
357 while (node)
358 {
359 wxMenu *menu = node->GetData();
360 int res = FindMenuItemRecursive( menu, menuString, itemString);
361 if (res != -1)
362 return res;
363 node = node->GetNext();
364 }
365
366 return wxNOT_FOUND;
367}
368
369// Find a wxMenuItem using its id. Recurses down into sub-menus
370static wxMenuItem* FindMenuItemByIdRecursive(const wxMenu* menu, int id)
371{
372 wxMenuItem* result = menu->FindChildItem(id);
373
374 wxMenuItemList::compatibility_iterator node = menu->GetMenuItems().GetFirst();
375 while ( node && result == NULL )
376 {
377 wxMenuItem *item = node->GetData();
378 if (item->IsSubMenu())
379 {
380 result = FindMenuItemByIdRecursive( item->GetSubMenu(), id );
381 }
382 node = node->GetNext();
383 }
384
385 return result;
386}
387
388wxMenuItem* wxMenuBar::FindItem( int id, wxMenu **menuForItem ) const
389{
390 wxMenuItem* result = 0;
391 wxMenuList::compatibility_iterator node = m_menus.GetFirst();
392 while (node && result == 0)
393 {
394 wxMenu *menu = node->GetData();
395 result = FindMenuItemByIdRecursive( menu, id );
396 node = node->GetNext();
397 }
398
399 if ( menuForItem )
400 {
401 *menuForItem = result ? result->GetMenu() : NULL;
402 }
403
404 return result;
405}
406
407void wxMenuBar::EnableTop( size_t pos, bool flag )
408{
409 wxMenuList::compatibility_iterator node = m_menus.Item( pos );
410
411 wxCHECK_RET( node, wxT("menu not found") );
412
413 wxMenu* menu = node->GetData();
414
415 if (menu->m_owner)
416 gtk_widget_set_sensitive( menu->m_owner, flag );
417}
418
419wxString wxMenuBar::GetMenuLabel( size_t pos ) const
420{
421 wxMenuList::compatibility_iterator node = m_menus.Item( pos );
422
423 wxCHECK_MSG( node, wxT("invalid"), wxT("menu not found") );
424
425 wxMenu* menu = node->GetData();
426
427 return menu->GetTitle();
428}
429
430void wxMenuBar::SetMenuLabel( size_t pos, const wxString& label )
431{
432 wxMenuList::compatibility_iterator node = m_menus.Item( pos );
433
434 wxCHECK_RET( node, wxT("menu not found") );
435
436 wxMenu* menu = node->GetData();
437
438 const wxString str(wxConvertMnemonicsToGTK(label));
439
440 menu->SetTitle( str );
441
442 if (menu->m_owner)
443 gtk_label_set_text_with_mnemonic( GTK_LABEL( GTK_BIN(menu->m_owner)->child), wxGTK_CONV(str) );
444}
445
446//-----------------------------------------------------------------------------
447// "activate"
448//-----------------------------------------------------------------------------
449
450extern "C" {
451static void menuitem_activate(GtkWidget*, wxMenuItem* item)
452{
453 if (!item->IsEnabled())
454 return;
455
456 int id = item->GetId();
457 if (id == wxGTK_TITLE_ID)
458 {
459 // ignore events from the menu title
460 return;
461 }
462
463 if (item->IsCheckable())
464 {
465 bool isReallyChecked = item->IsChecked(),
466 isInternallyChecked = item->wxMenuItemBase::IsChecked();
467
468 // ensure that the internal state is always consistent with what is
469 // shown on the screen
470 item->wxMenuItemBase::Check(isReallyChecked);
471
472 // we must not report the events for the radio button going up nor the
473 // events resulting from the calls to wxMenuItem::Check()
474 if ( (item->GetKind() == wxITEM_RADIO && !isReallyChecked) ||
475 (isInternallyChecked == isReallyChecked) )
476 {
477 return;
478 }
479 }
480
481 wxMenu* menu = item->GetMenu();
482 menu->SendEvent(id, item->IsCheckable() ? item->IsChecked() : -1);
483}
484}
485
486//-----------------------------------------------------------------------------
487// "select"
488//-----------------------------------------------------------------------------
489
490extern "C" {
491static void menuitem_select(GtkWidget*, wxMenuItem* item)
492{
493 if (!item->IsEnabled())
494 return;
495
496 wxMenuEvent event(wxEVT_MENU_HIGHLIGHT, item->GetId());
497 DoCommonMenuCallbackCode(item->GetMenu(), event);
498}
499}
500
501//-----------------------------------------------------------------------------
502// "deselect"
503//-----------------------------------------------------------------------------
504
505extern "C" {
506static void menuitem_deselect(GtkWidget*, wxMenuItem* item)
507{
508 if (!item->IsEnabled())
509 return;
510
511 wxMenuEvent event( wxEVT_MENU_HIGHLIGHT, -1 );
512 DoCommonMenuCallbackCode(item->GetMenu(), event);
513}
514}
515
516//-----------------------------------------------------------------------------
517// wxMenuItem
518//-----------------------------------------------------------------------------
519
520wxMenuItem *wxMenuItemBase::New(wxMenu *parentMenu,
521 int id,
522 const wxString& name,
523 const wxString& help,
524 wxItemKind kind,
525 wxMenu *subMenu)
526{
527 return new wxMenuItem(parentMenu, id, name, help, kind, subMenu);
528}
529
530wxMenuItem::wxMenuItem(wxMenu *parentMenu,
531 int id,
532 const wxString& text,
533 const wxString& help,
534 wxItemKind kind,
535 wxMenu *subMenu)
536 : wxMenuItemBase(parentMenu, id, text, help, kind, subMenu)
537{
538 m_menuItem = NULL;
539}
540
541#if WXWIN_COMPATIBILITY_2_8
542wxMenuItem::wxMenuItem(wxMenu *parentMenu,
543 int id,
544 const wxString& text,
545 const wxString& help,
546 bool isCheckable,
547 wxMenu *subMenu)
548 : wxMenuItemBase(parentMenu, id, text, help,
549 isCheckable ? wxITEM_CHECK : wxITEM_NORMAL, subMenu)
550{
551 m_menuItem = NULL;
552}
553#endif
554
555wxMenuItem::~wxMenuItem()
556{
557 // don't delete menu items, the menus take care of that
558}
559
560void wxMenuItem::SetItemLabel( const wxString& str )
561{
562#if wxUSE_ACCEL
563 if (m_menuItem)
564 {
565 // remove old accelerator
566 guint accel_key;
567 GdkModifierType accel_mods;
568 wxGetGtkAccel(this, &accel_key, &accel_mods);
569 if (accel_key)
570 {
571 gtk_widget_remove_accelerator(
572 m_menuItem, m_parentMenu->m_accel, accel_key, accel_mods);
573 }
574 }
575#endif // wxUSE_ACCEL
576 wxMenuItemBase::SetItemLabel(str);
577 if (m_menuItem)
578 SetGtkLabel();
579}
580
581void wxMenuItem::SetGtkLabel()
582{
583 const wxString text = wxConvertMnemonicsToGTK(m_text.BeforeFirst('\t'));
584 GtkLabel* label = GTK_LABEL(GTK_BIN(m_menuItem)->child);
585 gtk_label_set_text_with_mnemonic(label, wxGTK_CONV_SYS(text));
586#if wxUSE_ACCEL
587 guint accel_key;
588 GdkModifierType accel_mods;
589 wxGetGtkAccel(this, &accel_key, &accel_mods);
590 if (accel_key)
591 {
592 gtk_widget_add_accelerator(
593 m_menuItem, "activate", m_parentMenu->m_accel,
594 accel_key, accel_mods, GTK_ACCEL_VISIBLE);
595 }
596#endif // wxUSE_ACCEL
597}
598
599void wxMenuItem::SetBitmap(const wxBitmap& bitmap)
600{
601 if (m_kind == wxITEM_NORMAL)
602 m_bitmap = bitmap;
603 else
604 wxFAIL_MSG("only normal menu items can have bitmaps");
605}
606
607void wxMenuItem::Check( bool check )
608{
609 wxCHECK_RET( m_menuItem, wxT("invalid menu item") );
610
611 if (check == m_isChecked)
612 return;
613
614 wxMenuItemBase::Check( check );
615
616 switch ( GetKind() )
617 {
618 case wxITEM_CHECK:
619 case wxITEM_RADIO:
620 gtk_check_menu_item_set_active( (GtkCheckMenuItem*)m_menuItem, (gint)check );
621 break;
622
623 default:
624 wxFAIL_MSG( wxT("can't check this item") );
625 }
626}
627
628void wxMenuItem::Enable( bool enable )
629{
630 wxCHECK_RET( m_menuItem, wxT("invalid menu item") );
631
632 gtk_widget_set_sensitive( m_menuItem, enable );
633 wxMenuItemBase::Enable( enable );
634}
635
636bool wxMenuItem::IsChecked() const
637{
638 wxCHECK_MSG( m_menuItem, false, wxT("invalid menu item") );
639
640 wxCHECK_MSG( IsCheckable(), false,
641 wxT("can't get state of uncheckable item!") );
642
643 return ((GtkCheckMenuItem*)m_menuItem)->active != 0;
644}
645
646//-----------------------------------------------------------------------------
647// wxMenu
648//-----------------------------------------------------------------------------
649
650extern "C" {
651// "map" from m_menu
652static void menu_map(GtkWidget*, wxMenu* menu)
653{
654 wxMenuEvent event(wxEVT_MENU_OPEN, menu->m_popupShown ? -1 : 0, menu);
655 DoCommonMenuCallbackCode(menu, event);
656}
657
658// "hide" from m_menu
659static void menu_hide(GtkWidget*, wxMenu* menu)
660{
661 wxMenuEvent event(wxEVT_MENU_CLOSE, menu->m_popupShown ? -1 : 0, menu);
662 menu->m_popupShown = false;
663 DoCommonMenuCallbackCode(menu, event);
664}
665}
666
667// "can_activate_accel" from menu item
668extern "C" {
669static gboolean can_activate_accel(GtkWidget*, guint, wxMenu* menu)
670{
671 menu->UpdateUI();
672 // always allow our "activate" handler to be called
673 return true;
674}
675}
676
677void wxMenu::Init()
678{
679 m_popupShown = false;
680
681 m_accel = gtk_accel_group_new();
682 m_menu = gtk_menu_new();
683 // NB: keep reference to the menu so that it is not destroyed behind
684 // our back by GTK+ e.g. when it is removed from menubar:
685 g_object_ref(m_menu);
686 gtk_object_sink(GTK_OBJECT(m_menu));
687
688 m_owner = NULL;
689
690 // Tearoffs are entries, just like separators. So if we want this
691 // menu to be a tear-off one, we just append a tearoff entry
692 // immediately.
693 if ( m_style & wxMENU_TEAROFF )
694 {
695 GtkWidget *tearoff = gtk_tearoff_menu_item_new();
696
697 gtk_menu_shell_append(GTK_MENU_SHELL(m_menu), tearoff);
698 }
699
700 m_prevRadio = NULL;
701
702 // append the title as the very first entry if we have it
703 if ( !m_title.empty() )
704 {
705 Append(wxGTK_TITLE_ID, m_title);
706 AppendSeparator();
707 }
708
709 // "show" occurs for sub-menus which are not showing, so use "map" instead
710 g_signal_connect(m_menu, "map", G_CALLBACK(menu_map), this);
711 g_signal_connect(m_menu, "hide", G_CALLBACK(menu_hide), this);
712}
713
714wxMenu::~wxMenu()
715{
716 // Destroying a menu generates a "hide" signal even if it's not shown
717 // currently, so disconnect it to avoid dummy wxEVT_MENU_CLOSE events
718 // generation.
719 g_signal_handlers_disconnect_by_func(m_menu, (gpointer)menu_hide, this);
720
721 // see wxMenu::Init
722 g_object_unref(m_menu);
723
724 // if the menu is inserted in another menu at this time, there was
725 // one more reference to it:
726 if (m_owner)
727 gtk_widget_destroy(m_menu);
728
729 g_object_unref(m_accel);
730}
731
732void wxMenu::SetLayoutDirection(const wxLayoutDirection dir)
733{
734 if ( m_owner )
735 wxWindow::GTKSetLayout(m_owner, dir);
736 //else: will be called later by wxMenuBar again
737}
738
739wxLayoutDirection wxMenu::GetLayoutDirection() const
740{
741 return wxWindow::GTKGetLayout(m_owner);
742}
743
744wxString wxMenu::GetTitle() const
745{
746 return wxConvertMnemonicsFromGTK(wxMenuBase::GetTitle());
747}
748
749bool wxMenu::GtkAppend(wxMenuItem *mitem, int pos)
750{
751 GtkWidget *menuItem;
752 GtkWidget* prevRadio = m_prevRadio;
753 m_prevRadio = NULL;
754 switch (mitem->GetKind())
755 {
756 case wxITEM_SEPARATOR:
757 menuItem = gtk_separator_menu_item_new();
758 break;
759 case wxITEM_CHECK:
760 menuItem = gtk_check_menu_item_new_with_label("");
761 break;
762 case wxITEM_RADIO:
763 {
764 GSList* group = NULL;
765 if (prevRadio)
766 group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(prevRadio));
767 menuItem = gtk_radio_menu_item_new_with_label(group, "");
768 m_prevRadio = menuItem;
769 }
770 break;
771 default:
772 wxFAIL_MSG("unexpected menu item kind");
773 // fall through
774 case wxITEM_NORMAL:
775 const wxBitmap& bitmap = mitem->GetBitmap();
776 const char* stockid;
777 if (bitmap.IsOk())
778 {
779 // always use pixbuf, because pixmap mask does not
780 // work with disabled images in some themes
781 GtkWidget* image = gtk_image_new_from_pixbuf(bitmap.GetPixbuf());
782 menuItem = gtk_image_menu_item_new_with_label("");
783 gtk_widget_show(image);
784 gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menuItem), image);
785 }
786 else if ((stockid = wxGetStockGtkID(mitem->GetId())) != NULL)
787 // use stock bitmap for this item if available on the assumption
788 // that it never hurts to follow GTK+ conventions more closely
789 menuItem = gtk_image_menu_item_new_from_stock(stockid, NULL);
790 else
791 menuItem = gtk_menu_item_new_with_label("");
792 break;
793 }
794 mitem->SetMenuItem(menuItem);
795
796 gtk_menu_shell_insert(GTK_MENU_SHELL(m_menu), menuItem, pos);
797
798 gtk_widget_show( menuItem );
799
800 if ( !mitem->IsSeparator() )
801 {
802 mitem->SetGtkLabel();
803 g_signal_connect (menuItem, "select",
804 G_CALLBACK(menuitem_select), mitem);
805 g_signal_connect (menuItem, "deselect",
806 G_CALLBACK(menuitem_deselect), mitem);
807
808 if ( mitem->IsSubMenu() && mitem->GetKind() != wxITEM_RADIO && mitem->GetKind() != wxITEM_CHECK )
809 {
810 gtk_menu_item_set_submenu( GTK_MENU_ITEM(menuItem), mitem->GetSubMenu()->m_menu );
811
812 gtk_widget_show( mitem->GetSubMenu()->m_menu );
813 }
814 else
815 {
816 g_signal_connect(menuItem, "can_activate_accel",
817 G_CALLBACK(can_activate_accel), this);
818 g_signal_connect (menuItem, "activate",
819 G_CALLBACK(menuitem_activate),
820 mitem);
821 }
822 }
823
824 return true;
825}
826
827wxMenuItem* wxMenu::DoAppend(wxMenuItem *mitem)
828{
829 if (!GtkAppend(mitem))
830 return NULL;
831
832 return wxMenuBase::DoAppend(mitem);
833}
834
835wxMenuItem* wxMenu::DoInsert(size_t pos, wxMenuItem *item)
836{
837 if ( !wxMenuBase::DoInsert(pos, item) )
838 return NULL;
839
840 // TODO
841 if ( !GtkAppend(item, (int)pos) )
842 return NULL;
843
844 return item;
845}
846
847wxMenuItem *wxMenu::DoRemove(wxMenuItem *item)
848{
849 if ( !wxMenuBase::DoRemove(item) )
850 return NULL;
851
852 GtkWidget * const mitem = item->GetMenuItem();
853 if ( m_prevRadio == mitem )
854 {
855 // deleting an item starts a new radio group (has to as we shouldn't
856 // keep a deleted pointer anyhow)
857 m_prevRadio = NULL;
858 }
859
860 gtk_menu_item_set_submenu(GTK_MENU_ITEM(mitem), NULL);
861 gtk_widget_destroy(mitem);
862 item->SetMenuItem(NULL);
863
864 return item;
865}
866
867void wxMenu::Attach(wxMenuBarBase *menubar)
868{
869 wxMenuBase::Attach(menubar);
870
871 // inherit layout direction from menubar.
872 SetLayoutDirection(menubar->GetLayoutDirection());
873}
874
875// ----------------------------------------------------------------------------
876// helpers
877// ----------------------------------------------------------------------------
878
879#if wxUSE_ACCEL
880
881static wxString GetGtkHotKey( const wxMenuItem& item )
882{
883 wxString hotkey;
884
885 wxAcceleratorEntry *accel = item.GetAccel();
886 if ( accel )
887 {
888 int flags = accel->GetFlags();
889 if ( flags & wxACCEL_ALT )
890 hotkey += wxT("<alt>");
891 if ( flags & wxACCEL_CTRL )
892 hotkey += wxT("<control>");
893 if ( flags & wxACCEL_SHIFT )
894 hotkey += wxT("<shift>");
895
896 int code = accel->GetKeyCode();
897 switch ( code )
898 {
899 case WXK_F1:
900 case WXK_F2:
901 case WXK_F3:
902 case WXK_F4:
903 case WXK_F5:
904 case WXK_F6:
905 case WXK_F7:
906 case WXK_F8:
907 case WXK_F9:
908 case WXK_F10:
909 case WXK_F11:
910 case WXK_F12:
911 case WXK_F13:
912 case WXK_F14:
913 case WXK_F15:
914 case WXK_F16:
915 case WXK_F17:
916 case WXK_F18:
917 case WXK_F19:
918 case WXK_F20:
919 case WXK_F21:
920 case WXK_F22:
921 case WXK_F23:
922 case WXK_F24:
923 hotkey += wxString::Format(wxT("F%d"), code - WXK_F1 + 1);
924 break;
925
926 // TODO: we should use gdk_keyval_name() (a.k.a.
927 // XKeysymToString) here as well as hardcoding the keysym
928 // names this might be not portable
929 case WXK_INSERT:
930 hotkey << wxT("Insert" );
931 break;
932 case WXK_DELETE:
933 hotkey << wxT("Delete" );
934 break;
935 case WXK_UP:
936 hotkey << wxT("Up" );
937 break;
938 case WXK_DOWN:
939 hotkey << wxT("Down" );
940 break;
941 case WXK_PAGEUP:
942 hotkey << wxT("Page_Up" );
943 break;
944 case WXK_PAGEDOWN:
945 hotkey << wxT("Page_Down" );
946 break;
947 case WXK_LEFT:
948 hotkey << wxT("Left" );
949 break;
950 case WXK_RIGHT:
951 hotkey << wxT("Right" );
952 break;
953 case WXK_HOME:
954 hotkey << wxT("Home" );
955 break;
956 case WXK_END:
957 hotkey << wxT("End" );
958 break;
959 case WXK_RETURN:
960 hotkey << wxT("Return" );
961 break;
962 case WXK_BACK:
963 hotkey << wxT("BackSpace" );
964 break;
965 case WXK_TAB:
966 hotkey << wxT("Tab" );
967 break;
968 case WXK_ESCAPE:
969 hotkey << wxT("Esc" );
970 break;
971 case WXK_SPACE:
972 hotkey << wxT("space" );
973 break;
974 case WXK_MULTIPLY:
975 hotkey << wxT("Multiply" );
976 break;
977 case WXK_ADD:
978 hotkey << wxT("Add" );
979 break;
980 case WXK_SEPARATOR:
981 hotkey << wxT("Separator" );
982 break;
983 case WXK_SUBTRACT:
984 hotkey << wxT("Subtract" );
985 break;
986 case WXK_DECIMAL:
987 hotkey << wxT("Decimal" );
988 break;
989 case WXK_DIVIDE:
990 hotkey << wxT("Divide" );
991 break;
992 case WXK_CANCEL:
993 hotkey << wxT("Cancel" );
994 break;
995 case WXK_CLEAR:
996 hotkey << wxT("Clear" );
997 break;
998 case WXK_MENU:
999 hotkey << wxT("Menu" );
1000 break;
1001 case WXK_PAUSE:
1002 hotkey << wxT("Pause" );
1003 break;
1004 case WXK_CAPITAL:
1005 hotkey << wxT("Capital" );
1006 break;
1007 case WXK_SELECT:
1008 hotkey << wxT("Select" );
1009 break;
1010 case WXK_PRINT:
1011 hotkey << wxT("Print" );
1012 break;
1013 case WXK_EXECUTE:
1014 hotkey << wxT("Execute" );
1015 break;
1016 case WXK_SNAPSHOT:
1017 hotkey << wxT("Snapshot" );
1018 break;
1019 case WXK_HELP:
1020 hotkey << wxT("Help" );
1021 break;
1022 case WXK_NUMLOCK:
1023 hotkey << wxT("Num_Lock" );
1024 break;
1025 case WXK_SCROLL:
1026 hotkey << wxT("Scroll_Lock" );
1027 break;
1028 case WXK_NUMPAD_INSERT:
1029 hotkey << wxT("KP_Insert" );
1030 break;
1031 case WXK_NUMPAD_DELETE:
1032 hotkey << wxT("KP_Delete" );
1033 break;
1034 case WXK_NUMPAD_SPACE:
1035 hotkey << wxT("KP_Space" );
1036 break;
1037 case WXK_NUMPAD_TAB:
1038 hotkey << wxT("KP_Tab" );
1039 break;
1040 case WXK_NUMPAD_ENTER:
1041 hotkey << wxT("KP_Enter" );
1042 break;
1043 case WXK_NUMPAD_F1: case WXK_NUMPAD_F2: case WXK_NUMPAD_F3:
1044 case WXK_NUMPAD_F4:
1045 hotkey += wxString::Format(wxT("KP_F%d"), code - WXK_NUMPAD_F1 + 1);
1046 break;
1047 case WXK_NUMPAD_HOME:
1048 hotkey << wxT("KP_Home" );
1049 break;
1050 case WXK_NUMPAD_LEFT:
1051 hotkey << wxT("KP_Left" );
1052 break;
1053 case WXK_NUMPAD_UP:
1054 hotkey << wxT("KP_Up" );
1055 break;
1056 case WXK_NUMPAD_RIGHT:
1057 hotkey << wxT("KP_Right" );
1058 break;
1059 case WXK_NUMPAD_DOWN:
1060 hotkey << wxT("KP_Down" );
1061 break;
1062 case WXK_NUMPAD_PAGEUP:
1063 hotkey << wxT("KP_Page_Up" );
1064 break;
1065 case WXK_NUMPAD_PAGEDOWN:
1066 hotkey << wxT("KP_Page_Down" );
1067 break;
1068 case WXK_NUMPAD_END:
1069 hotkey << wxT("KP_End" );
1070 break;
1071 case WXK_NUMPAD_BEGIN:
1072 hotkey << wxT("KP_Begin" );
1073 break;
1074 case WXK_NUMPAD_EQUAL:
1075 hotkey << wxT("KP_Equal" );
1076 break;
1077 case WXK_NUMPAD_MULTIPLY:
1078 hotkey << wxT("KP_Multiply" );
1079 break;
1080 case WXK_NUMPAD_ADD:
1081 hotkey << wxT("KP_Add" );
1082 break;
1083 case WXK_NUMPAD_SEPARATOR:
1084 hotkey << wxT("KP_Separator" );
1085 break;
1086 case WXK_NUMPAD_SUBTRACT:
1087 hotkey << wxT("KP_Subtract" );
1088 break;
1089 case WXK_NUMPAD_DECIMAL:
1090 hotkey << wxT("KP_Decimal" );
1091 break;
1092 case WXK_NUMPAD_DIVIDE:
1093 hotkey << wxT("KP_Divide" );
1094 break;
1095 case WXK_NUMPAD0: case WXK_NUMPAD1: case WXK_NUMPAD2:
1096 case WXK_NUMPAD3: case WXK_NUMPAD4: case WXK_NUMPAD5:
1097 case WXK_NUMPAD6: case WXK_NUMPAD7: case WXK_NUMPAD8: case WXK_NUMPAD9:
1098 hotkey += wxString::Format(wxT("KP_%d"), code - WXK_NUMPAD0);
1099 break;
1100 case WXK_WINDOWS_LEFT:
1101 hotkey << wxT("Super_L" );
1102 break;
1103 case WXK_WINDOWS_RIGHT:
1104 hotkey << wxT("Super_R" );
1105 break;
1106 case WXK_WINDOWS_MENU:
1107 hotkey << wxT("Menu" );
1108 break;
1109 case WXK_COMMAND:
1110 hotkey << wxT("Command" );
1111 break;
1112 /* These probably wouldn't work as there is no SpecialX in gdk/keynames.txt
1113 case WXK_SPECIAL1: case WXK_SPECIAL2: case WXK_SPECIAL3: case WXK_SPECIAL4:
1114 case WXK_SPECIAL5: case WXK_SPECIAL6: case WXK_SPECIAL7: case WXK_SPECIAL8:
1115 case WXK_SPECIAL9: case WXK_SPECIAL10: case WXK_SPECIAL11: case WXK_SPECIAL12:
1116 case WXK_SPECIAL13: case WXK_SPECIAL14: case WXK_SPECIAL15: case WXK_SPECIAL16:
1117 case WXK_SPECIAL17: case WXK_SPECIAL18: case WXK_SPECIAL19: case WXK_SPECIAL20:
1118 hotkey += wxString::Format(wxT("Special%d"), code - WXK_SPECIAL1 + 1);
1119 break;
1120 */
1121 // if there are any other keys wxAcceleratorEntry::Create() may
1122 // return, we should process them here
1123
1124 default:
1125 if ( code < 127 )
1126 {
1127 const wxString
1128 name = wxGTK_CONV_BACK_SYS(gdk_keyval_name((guint)code));
1129 if ( !name.empty() )
1130 {
1131 hotkey << name;
1132 break;
1133 }
1134 }
1135
1136 wxFAIL_MSG( wxT("unknown keyboard accel") );
1137 }
1138
1139 delete accel;
1140 }
1141
1142 return hotkey;
1143}
1144
1145static void
1146wxGetGtkAccel(const wxMenuItem* item, guint* accel_key, GdkModifierType* accel_mods)
1147{
1148 *accel_key = 0;
1149 const wxString string = GetGtkHotKey(*item);
1150 if (!string.empty())
1151 gtk_accelerator_parse(wxGTK_CONV_SYS(string), accel_key, accel_mods);
1152 else
1153 {
1154 GtkStockItem stock_item;
1155 const char* stockid = wxGetStockGtkID(item->GetId());
1156 if (stockid && gtk_stock_lookup(stockid, &stock_item))
1157 {
1158 *accel_key = stock_item.keyval;
1159 *accel_mods = stock_item.modifier;
1160 }
1161 }
1162}
1163#endif // wxUSE_ACCEL
1164
1165const char *wxGetStockGtkID(wxWindowID id)
1166{
1167 #define STOCKITEM(wx,gtk) \
1168 case wx: \
1169 return gtk;
1170
1171 #if GTK_CHECK_VERSION(2,6,0)
1172 #define STOCKITEM_26(wx,gtk) STOCKITEM(wx,gtk)
1173 #else
1174 #define STOCKITEM_26(wx,gtk)
1175 #endif
1176
1177 #if GTK_CHECK_VERSION(2,8,0)
1178 #define STOCKITEM_28(wx,gtk) STOCKITEM(wx,gtk)
1179 #else
1180 #define STOCKITEM_28(wx,gtk)
1181 #endif
1182
1183 #if GTK_CHECK_VERSION(2,10,0)
1184 #define STOCKITEM_210(wx,gtk) STOCKITEM(wx,gtk)
1185 #else
1186 #define STOCKITEM_210(wx,gtk)
1187 #endif
1188
1189
1190 switch (id)
1191 {
1192 STOCKITEM_26(wxID_ABOUT, GTK_STOCK_ABOUT)
1193 STOCKITEM(wxID_ADD, GTK_STOCK_ADD)
1194 STOCKITEM(wxID_APPLY, GTK_STOCK_APPLY)
1195 STOCKITEM(wxID_BACKWARD, GTK_STOCK_GO_BACK)
1196 STOCKITEM(wxID_BOLD, GTK_STOCK_BOLD)
1197 STOCKITEM(wxID_BOTTOM, GTK_STOCK_GOTO_BOTTOM)
1198 STOCKITEM(wxID_CANCEL, GTK_STOCK_CANCEL)
1199 STOCKITEM(wxID_CDROM, GTK_STOCK_CDROM)
1200 STOCKITEM(wxID_CLEAR, GTK_STOCK_CLEAR)
1201 STOCKITEM(wxID_CLOSE, GTK_STOCK_CLOSE)
1202 STOCKITEM(wxID_CONVERT, GTK_STOCK_CONVERT)
1203 STOCKITEM(wxID_COPY, GTK_STOCK_COPY)
1204 STOCKITEM(wxID_CUT, GTK_STOCK_CUT)
1205 STOCKITEM(wxID_DELETE, GTK_STOCK_DELETE)
1206 STOCKITEM(wxID_DOWN, GTK_STOCK_GO_DOWN)
1207 STOCKITEM_26(wxID_EDIT, GTK_STOCK_EDIT)
1208 STOCKITEM(wxID_EXECUTE, GTK_STOCK_EXECUTE)
1209 STOCKITEM(wxID_EXIT, GTK_STOCK_QUIT)
1210 STOCKITEM_26(wxID_FILE, GTK_STOCK_FILE)
1211 STOCKITEM(wxID_FIND, GTK_STOCK_FIND)
1212 STOCKITEM(wxID_FIRST, GTK_STOCK_GOTO_FIRST)
1213 STOCKITEM(wxID_FLOPPY, GTK_STOCK_FLOPPY)
1214 STOCKITEM(wxID_FORWARD, GTK_STOCK_GO_FORWARD)
1215 STOCKITEM(wxID_HARDDISK, GTK_STOCK_HARDDISK)
1216 STOCKITEM(wxID_HELP, GTK_STOCK_HELP)
1217 STOCKITEM(wxID_HOME, GTK_STOCK_HOME)
1218 STOCKITEM(wxID_INDENT, GTK_STOCK_INDENT)
1219 STOCKITEM(wxID_INDEX, GTK_STOCK_INDEX)
1220 STOCKITEM_28(wxID_INFO, GTK_STOCK_INFO)
1221 STOCKITEM(wxID_ITALIC, GTK_STOCK_ITALIC)
1222 STOCKITEM(wxID_JUMP_TO, GTK_STOCK_JUMP_TO)
1223 STOCKITEM(wxID_JUSTIFY_CENTER, GTK_STOCK_JUSTIFY_CENTER)
1224 STOCKITEM(wxID_JUSTIFY_FILL, GTK_STOCK_JUSTIFY_FILL)
1225 STOCKITEM(wxID_JUSTIFY_LEFT, GTK_STOCK_JUSTIFY_LEFT)
1226 STOCKITEM(wxID_JUSTIFY_RIGHT, GTK_STOCK_JUSTIFY_RIGHT)
1227 STOCKITEM(wxID_LAST, GTK_STOCK_GOTO_LAST)
1228 STOCKITEM(wxID_NETWORK, GTK_STOCK_NETWORK)
1229 STOCKITEM(wxID_NEW, GTK_STOCK_NEW)
1230 STOCKITEM(wxID_NO, GTK_STOCK_NO)
1231 STOCKITEM(wxID_OK, GTK_STOCK_OK)
1232 STOCKITEM(wxID_OPEN, GTK_STOCK_OPEN)
1233 STOCKITEM(wxID_PASTE, GTK_STOCK_PASTE)
1234 STOCKITEM(wxID_PREFERENCES, GTK_STOCK_PREFERENCES)
1235 STOCKITEM(wxID_PREVIEW, GTK_STOCK_PRINT_PREVIEW)
1236 STOCKITEM(wxID_PRINT, GTK_STOCK_PRINT)
1237 STOCKITEM(wxID_PROPERTIES, GTK_STOCK_PROPERTIES)
1238 STOCKITEM(wxID_REDO, GTK_STOCK_REDO)
1239 STOCKITEM(wxID_REFRESH, GTK_STOCK_REFRESH)
1240 STOCKITEM(wxID_REMOVE, GTK_STOCK_REMOVE)
1241 STOCKITEM(wxID_REPLACE, GTK_STOCK_FIND_AND_REPLACE)
1242 STOCKITEM(wxID_REVERT_TO_SAVED, GTK_STOCK_REVERT_TO_SAVED)
1243 STOCKITEM(wxID_SAVE, GTK_STOCK_SAVE)
1244 STOCKITEM(wxID_SAVEAS, GTK_STOCK_SAVE_AS)
1245 STOCKITEM_210(wxID_SELECTALL, GTK_STOCK_SELECT_ALL)
1246 STOCKITEM(wxID_SELECT_COLOR, GTK_STOCK_SELECT_COLOR)
1247 STOCKITEM(wxID_SELECT_FONT, GTK_STOCK_SELECT_FONT)
1248 STOCKITEM(wxID_SORT_ASCENDING, GTK_STOCK_SORT_ASCENDING)
1249 STOCKITEM(wxID_SORT_DESCENDING, GTK_STOCK_SORT_DESCENDING)
1250 STOCKITEM(wxID_SPELL_CHECK, GTK_STOCK_SPELL_CHECK)
1251 STOCKITEM(wxID_STOP, GTK_STOCK_STOP)
1252 STOCKITEM(wxID_STRIKETHROUGH, GTK_STOCK_STRIKETHROUGH)
1253 STOCKITEM(wxID_TOP, GTK_STOCK_GOTO_TOP)
1254 STOCKITEM(wxID_UNDELETE, GTK_STOCK_UNDELETE)
1255 STOCKITEM(wxID_UNDERLINE, GTK_STOCK_UNDERLINE)
1256 STOCKITEM(wxID_UNDO, GTK_STOCK_UNDO)
1257 STOCKITEM(wxID_UNINDENT, GTK_STOCK_UNINDENT)
1258 STOCKITEM(wxID_UP, GTK_STOCK_GO_UP)
1259 STOCKITEM(wxID_YES, GTK_STOCK_YES)
1260 STOCKITEM(wxID_ZOOM_100, GTK_STOCK_ZOOM_100)
1261 STOCKITEM(wxID_ZOOM_FIT, GTK_STOCK_ZOOM_FIT)
1262 STOCKITEM(wxID_ZOOM_IN, GTK_STOCK_ZOOM_IN)
1263 STOCKITEM(wxID_ZOOM_OUT, GTK_STOCK_ZOOM_OUT)
1264
1265 default:
1266 break;
1267 };
1268
1269 #undef STOCKITEM
1270
1271 return NULL;
1272}
1273
1274#endif // wxUSE_MENUS