]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/gtk/menu.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
document On{Open,Save}Document()
[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 gtk_menu_clicked_callback(GtkWidget *widget, wxMenu *menu);
37}
38
39#if wxUSE_ACCEL
40static bool wxGetStockGtkAccelerator(const char *id, GdkModifierType *mod, guint *key);
41static wxString GetGtkHotKey( const wxMenuItem& item );
42#endif
43
44static void DoCommonMenuCallbackCode(wxMenu *menu, wxMenuEvent& event)
45{
46 event.SetEventObject( menu );
47
48 wxEvtHandler* handler = menu->GetEventHandler();
49 if (handler && handler->SafelyProcessEvent(event))
50 return;
51
52 wxWindow *win = menu->GetInvokingWindow();
53 if (win)
54 win->HandleWindowEvent( event );
55}
56
57//-----------------------------------------------------------------------------
58// wxMenuBar
59//-----------------------------------------------------------------------------
60
61IMPLEMENT_DYNAMIC_CLASS(wxMenuBar,wxWindow)
62
63void wxMenuBar::Init(size_t n, wxMenu *menus[], const wxString titles[], long style)
64{
65 m_invokingWindow = NULL;
66
67#if wxUSE_LIBHILDON
68 // Hildon window uses a single menu instead of a menu bar, so wxMenuBar is
69 // the same as menu in this case
70 m_widget =
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") ))
75 {
76 wxFAIL_MSG( wxT("wxMenuBar creation failed") );
77 return;
78 }
79
80 m_menubar = gtk_menu_bar_new();
81
82 if (style & wxMB_DOCKABLE)
83 {
84 m_widget = gtk_handle_box_new();
85 gtk_container_add(GTK_CONTAINER(m_widget), m_menubar);
86 gtk_widget_show(m_menubar);
87 }
88 else
89 {
90 m_widget = m_menubar;
91 }
92
93 PostCreation();
94
95 ApplyWidgetStyle();
96#endif // wxUSE_LIBHILDON/!wxUSE_LIBHILDON
97
98 for (size_t i = 0; i < n; ++i )
99 Append(menus[i], titles[i]);
100}
101
102wxMenuBar::wxMenuBar(size_t n, wxMenu *menus[], const wxString titles[], long style)
103{
104 Init(n, menus, titles, style);
105}
106
107wxMenuBar::wxMenuBar(long style)
108{
109 Init(0, NULL, NULL, style);
110}
111
112wxMenuBar::wxMenuBar()
113{
114 Init(0, NULL, NULL, 0);
115}
116
117wxMenuBar::~wxMenuBar()
118{
119}
120
121static void
122wxMenubarUnsetInvokingWindow(wxMenu* menu, wxWindow* win, GtkWindow* tlw = NULL)
123{
124 menu->SetInvokingWindow( (wxWindow*) NULL );
125
126 // support for native hot keys
127 if (menu->m_accel)
128 {
129 if (tlw == NULL)
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);
133 }
134
135 wxMenuItemList::compatibility_iterator node = menu->GetMenuItems().GetFirst();
136 while (node)
137 {
138 wxMenuItem *menuitem = node->GetData();
139 if (menuitem->IsSubMenu())
140 wxMenubarUnsetInvokingWindow(menuitem->GetSubMenu(), win, tlw);
141 node = node->GetNext();
142 }
143}
144
145static void
146wxMenubarSetInvokingWindow(wxMenu* menu, wxWindow* win, GtkWindow* tlw = NULL)
147{
148 menu->SetInvokingWindow( win );
149
150 // support for native hot keys
151 if (menu->m_accel)
152 {
153 if (tlw == NULL)
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);
157 }
158
159 wxMenuItemList::compatibility_iterator node = menu->GetMenuItems().GetFirst();
160 while (node)
161 {
162 wxMenuItem *menuitem = node->GetData();
163 if (menuitem->IsSubMenu())
164 wxMenubarSetInvokingWindow(menuitem->GetSubMenu(), win, tlw);
165 node = node->GetNext();
166 }
167}
168
169void wxMenuBar::SetInvokingWindow( wxWindow *win )
170{
171 m_invokingWindow = win;
172
173 wxMenuList::compatibility_iterator node = m_menus.GetFirst();
174 while (node)
175 {
176 wxMenu *menu = node->GetData();
177 wxMenubarSetInvokingWindow( menu, win );
178 node = node->GetNext();
179 }
180}
181
182void wxMenuBar::SetLayoutDirection(wxLayoutDirection dir)
183{
184 if ( dir == wxLayout_Default )
185 {
186 const wxWindow *const frame = GetFrame();
187 if ( frame )
188 {
189 // inherit layout from frame.
190 dir = frame->GetLayoutDirection();
191 }
192 else // use global layout
193 {
194 dir = wxTheApp->GetLayoutDirection();
195 }
196 }
197
198 if ( dir == wxLayout_Default )
199 return;
200
201 GTKSetLayout(m_menubar, dir);
202
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();
206 node;
207 node = node->GetNext() )
208 {
209 wxMenu *const menu = node->GetData();
210 menu->SetLayoutDirection(dir);
211 }
212}
213
214wxLayoutDirection wxMenuBar::GetLayoutDirection() const
215{
216 return GTKGetLayout(m_menubar);
217}
218
219void wxMenuBar::Attach(wxFrame *frame)
220{
221 wxMenuBarBase::Attach(frame);
222
223 SetLayoutDirection(wxLayout_Default);
224}
225
226void wxMenuBar::UnsetInvokingWindow( wxWindow *win )
227{
228 m_invokingWindow = (wxWindow*) NULL;
229
230 wxMenuList::compatibility_iterator node = m_menus.GetFirst();
231 while (node)
232 {
233 wxMenu *menu = node->GetData();
234 wxMenubarUnsetInvokingWindow( menu, win );
235 node = node->GetNext();
236 }
237}
238
239bool wxMenuBar::Append( wxMenu *menu, const wxString &title )
240{
241 if ( !wxMenuBarBase::Append( menu, title ) )
242 return false;
243
244 return GtkAppend(menu, title);
245}
246
247bool wxMenuBar::GtkAppend(wxMenu *menu, const wxString& title, int pos)
248{
249 menu->SetLayoutDirection(GetLayoutDirection());
250
251#if wxUSE_LIBHILDON
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 )
255 {
256 wxMenuItem * const item = menu->FindItemByPosition(0);
257
258 // remove both mnemonics and accelerator: neither is useful under Maemo
259 const wxString str(wxStripMenuCodes(item->GetItemLabel()));
260
261 if ( item->IsSubMenu() )
262 return GtkAppend(item->GetSubMenu(), str, pos);
263
264 menu->m_owner = gtk_menu_item_new_with_mnemonic( wxGTK_CONV( str ) );
265
266 g_signal_connect(menu->m_owner, "activate",
267 G_CALLBACK(gtk_menu_clicked_callback), menu);
268 item->SetMenuItem(menu->m_owner);
269 }
270 else
271#endif // wxUSE_LIBHILDON/!wxUSE_LIBHILDON
272 {
273 const wxString str(wxConvertMnemonicsToGTK(title));
274
275 // This doesn't have much effect right now.
276 menu->SetTitle( str );
277
278 // The "m_owner" is the "menu item"
279 menu->m_owner = gtk_menu_item_new_with_mnemonic( wxGTK_CONV( str ) );
280
281 gtk_menu_item_set_submenu( GTK_MENU_ITEM(menu->m_owner), menu->m_menu );
282 }
283
284 gtk_widget_show( menu->m_owner );
285
286 if (pos == -1)
287 gtk_menu_shell_append( GTK_MENU_SHELL(m_menubar), menu->m_owner );
288 else
289 gtk_menu_shell_insert( GTK_MENU_SHELL(m_menubar), menu->m_owner, pos );
290
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 );
295
296 return true;
297}
298
299bool wxMenuBar::Insert(size_t pos, wxMenu *menu, const wxString& title)
300{
301 if ( !wxMenuBarBase::Insert(pos, menu, title) )
302 return false;
303
304 // TODO
305
306 if ( !GtkAppend(menu, title, (int)pos) )
307 return false;
308
309 return true;
310}
311
312wxMenu *wxMenuBar::Replace(size_t pos, wxMenu *menu, const wxString& title)
313{
314 // remove the old item and insert a new one
315 wxMenu *menuOld = Remove(pos);
316 if ( menuOld && !Insert(pos, menu, title) )
317 {
318 return (wxMenu*) NULL;
319 }
320
321 // either Insert() succeeded or Remove() failed and menuOld is NULL
322 return menuOld;
323}
324
325wxMenu *wxMenuBar::Remove(size_t pos)
326{
327 wxMenu *menu = wxMenuBarBase::Remove(pos);
328 if ( !menu )
329 return (wxMenu*) NULL;
330
331 gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu->m_owner), NULL);
332 gtk_container_remove(GTK_CONTAINER(m_menubar), menu->m_owner);
333
334 gtk_widget_destroy( menu->m_owner );
335 menu->m_owner = NULL;
336
337 if (m_invokingWindow)
338 wxMenubarUnsetInvokingWindow( menu, m_invokingWindow );
339
340 return menu;
341}
342
343static int FindMenuItemRecursive( const wxMenu *menu, const wxString &menuString, const wxString &itemString )
344{
345 if (wxMenuItem::GetLabelText(wxConvertMnemonicsFromGTK(menu->GetTitle())) == wxMenuItem::GetLabelText(menuString))
346 {
347 int res = menu->FindItem( itemString );
348 if (res != wxNOT_FOUND)
349 return res;
350 }
351
352 wxMenuItemList::compatibility_iterator node = menu->GetMenuItems().GetFirst();
353 while (node)
354 {
355 wxMenuItem *item = node->GetData();
356 if (item->IsSubMenu())
357 return FindMenuItemRecursive(item->GetSubMenu(), menuString, itemString);
358
359 node = node->GetNext();
360 }
361
362 return wxNOT_FOUND;
363}
364
365int wxMenuBar::FindMenuItem( const wxString &menuString, const wxString &itemString ) const
366{
367 wxMenuList::compatibility_iterator node = m_menus.GetFirst();
368 while (node)
369 {
370 wxMenu *menu = node->GetData();
371 int res = FindMenuItemRecursive( menu, menuString, itemString);
372 if (res != -1)
373 return res;
374 node = node->GetNext();
375 }
376
377 return wxNOT_FOUND;
378}
379
380// Find a wxMenuItem using its id. Recurses down into sub-menus
381static wxMenuItem* FindMenuItemByIdRecursive(const wxMenu* menu, int id)
382{
383 wxMenuItem* result = menu->FindChildItem(id);
384
385 wxMenuItemList::compatibility_iterator node = menu->GetMenuItems().GetFirst();
386 while ( node && result == NULL )
387 {
388 wxMenuItem *item = node->GetData();
389 if (item->IsSubMenu())
390 {
391 result = FindMenuItemByIdRecursive( item->GetSubMenu(), id );
392 }
393 node = node->GetNext();
394 }
395
396 return result;
397}
398
399wxMenuItem* wxMenuBar::FindItem( int id, wxMenu **menuForItem ) const
400{
401 wxMenuItem* result = 0;
402 wxMenuList::compatibility_iterator node = m_menus.GetFirst();
403 while (node && result == 0)
404 {
405 wxMenu *menu = node->GetData();
406 result = FindMenuItemByIdRecursive( menu, id );
407 node = node->GetNext();
408 }
409
410 if ( menuForItem )
411 {
412 *menuForItem = result ? result->GetMenu() : (wxMenu *)NULL;
413 }
414
415 return result;
416}
417
418void wxMenuBar::EnableTop( size_t pos, bool flag )
419{
420 wxMenuList::compatibility_iterator node = m_menus.Item( pos );
421
422 wxCHECK_RET( node, wxT("menu not found") );
423
424 wxMenu* menu = node->GetData();
425
426 if (menu->m_owner)
427 gtk_widget_set_sensitive( menu->m_owner, flag );
428}
429
430wxString wxMenuBar::GetMenuLabel( size_t pos ) const
431{
432 wxMenuList::compatibility_iterator node = m_menus.Item( pos );
433
434 wxCHECK_MSG( node, wxT("invalid"), wxT("menu not found") );
435
436 wxMenu* menu = node->GetData();
437
438 return wxConvertMnemonicsFromGTK(menu->GetTitle());
439}
440
441void wxMenuBar::SetMenuLabel( size_t pos, const wxString& label )
442{
443 wxMenuList::compatibility_iterator node = m_menus.Item( pos );
444
445 wxCHECK_RET( node, wxT("menu not found") );
446
447 wxMenu* menu = node->GetData();
448
449 const wxString str(wxConvertMnemonicsToGTK(label));
450
451 menu->SetTitle( str );
452
453 if (menu->m_owner)
454 gtk_label_set_text_with_mnemonic( GTK_LABEL( GTK_BIN(menu->m_owner)->child), wxGTK_CONV(str) );
455}
456
457//-----------------------------------------------------------------------------
458// "activate"
459//-----------------------------------------------------------------------------
460
461extern "C" {
462static void gtk_menu_clicked_callback( GtkWidget *widget, wxMenu *menu )
463{
464 int id = menu->FindMenuIdByMenuItem(widget);
465
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") );
469
470 if (!menu->IsEnabled(id))
471 return;
472
473 wxMenuItem* item = menu->FindChildItem( id );
474 wxCHECK_RET( item, wxT("error in menu item callback") );
475
476 if ( item->GetId() == wxGTK_TITLE_ID )
477 {
478 // ignore events from the menu title
479 return;
480 }
481
482 if (item->IsCheckable())
483 {
484 bool isReallyChecked = item->IsChecked(),
485 isInternallyChecked = item->wxMenuItemBase::IsChecked();
486
487 // ensure that the internal state is always consistent with what is
488 // shown on the screen
489 item->wxMenuItemBase::Check(isReallyChecked);
490
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) )
495 {
496 return;
497 }
498 }
499
500
501 // Is this menu on a menubar? (possibly nested)
502 wxFrame* frame = NULL;
503 if(menu->IsAttached())
504 frame = menu->GetMenuBar()->GetFrame();
505
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...
510 if (frame)
511 {
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());
519
520 frame->HandleWindowEvent(commandEvent);
521 }
522 else
523 {
524 // otherwise let the menu have it
525 menu->SendEvent(id, item->IsCheckable() ? item->IsChecked() : -1);
526 }
527}
528}
529
530//-----------------------------------------------------------------------------
531// "select"
532//-----------------------------------------------------------------------------
533
534extern "C" {
535static void gtk_menu_hilight_callback( GtkWidget *widget, wxMenu *menu )
536{
537 int id = menu->FindMenuIdByMenuItem(widget);
538
539 wxASSERT( id != -1 ); // should find it!
540
541 if (!menu->IsEnabled(id))
542 return;
543
544 wxMenuEvent event( wxEVT_MENU_HIGHLIGHT, id );
545 event.SetEventObject( menu );
546
547 wxEvtHandler* handler = menu->GetEventHandler();
548 if (handler && handler->SafelyProcessEvent(event))
549 return;
550
551 wxWindow *win = menu->GetInvokingWindow();
552 if (win) win->HandleWindowEvent( event );
553}
554}
555
556//-----------------------------------------------------------------------------
557// "deselect"
558//-----------------------------------------------------------------------------
559
560extern "C" {
561static void gtk_menu_nolight_callback( GtkWidget *widget, wxMenu *menu )
562{
563 int id = menu->FindMenuIdByMenuItem(widget);
564
565 wxASSERT( id != -1 ); // should find it!
566
567 if (!menu->IsEnabled(id))
568 return;
569
570 wxMenuEvent event( wxEVT_MENU_HIGHLIGHT, -1 );
571 event.SetEventObject( menu );
572
573 wxEvtHandler* handler = menu->GetEventHandler();
574 if (handler && handler->SafelyProcessEvent(event))
575 return;
576
577 wxWindow *win = menu->GetInvokingWindow();
578 if (win)
579 win->HandleWindowEvent( event );
580}
581}
582
583//-----------------------------------------------------------------------------
584// wxMenuItem
585//-----------------------------------------------------------------------------
586
587IMPLEMENT_DYNAMIC_CLASS(wxMenuItem, wxObject)
588
589wxMenuItem *wxMenuItemBase::New(wxMenu *parentMenu,
590 int id,
591 const wxString& name,
592 const wxString& help,
593 wxItemKind kind,
594 wxMenu *subMenu)
595{
596 return new wxMenuItem(parentMenu, id, name, help, kind, subMenu);
597}
598
599wxMenuItem::wxMenuItem(wxMenu *parentMenu,
600 int id,
601 const wxString& text,
602 const wxString& help,
603 wxItemKind kind,
604 wxMenu *subMenu)
605 : wxMenuItemBase(parentMenu, id, text, help, kind, subMenu)
606{
607 Init(text);
608}
609
610wxMenuItem::wxMenuItem(wxMenu *parentMenu,
611 int id,
612 const wxString& text,
613 const wxString& help,
614 bool isCheckable,
615 wxMenu *subMenu)
616 : wxMenuItemBase(parentMenu, id, text, help,
617 isCheckable ? wxITEM_CHECK : wxITEM_NORMAL, subMenu)
618{
619 Init(text);
620}
621
622void wxMenuItem::Init(const wxString& text)
623{
624 m_labelWidget = (GtkWidget *) NULL;
625 m_menuItem = (GtkWidget *) NULL;
626
627 DoSetText(text);
628}
629
630wxMenuItem::~wxMenuItem()
631{
632 // don't delete menu items, the menus take care of that
633}
634
635// return the menu item text without any menu accels
636/* static */
637
638wxString wxMenuItemBase::GetLabelText(const wxString& text)
639{
640 // The argument to this function will now always be in wxWidgets standard label
641 // format, not GTK+ format, so we do what the other ports do.
642
643 return wxStripMenuCodes(text);
644
645#if 0
646 wxString label;
647
648 for ( const wxChar *pc = text.c_str(); *pc; pc++ )
649 {
650 if ( *pc == wxT('\t'))
651 break;
652
653 if ( *pc == wxT('_') )
654 {
655 // GTK 1.2 escapes "xxx_xxx" to "xxx__xxx"
656 pc++;
657 label += *pc;
658 continue;
659 }
660
661 if ( *pc == wxT('\\') )
662 {
663 // GTK 2.0 escapes "xxx/xxx" to "xxx\/xxx"
664 pc++;
665 label += *pc;
666 continue;
667 }
668
669 if ( (*pc == wxT('&')) && (*(pc+1) != wxT('&')) )
670 {
671 // wxMSW escapes "&"
672 // "&" is doubled to indicate "&" instead of accelerator
673 continue;
674 }
675
676 label += *pc;
677 }
678
679 // wxPrintf( wxT("GetLabelText(): text %s label %s\n"), text.c_str(), label.c_str() );
680
681 return label;
682#endif
683}
684
685wxString wxMenuItem::GetItemLabel() const
686{
687 wxString label = wxConvertMnemonicsFromGTK(m_text);
688 if (!m_hotKey.IsEmpty())
689 label << "\t" << m_hotKey;
690 return label;
691}
692
693void wxMenuItem::SetItemLabel( const wxString& str )
694{
695 // cache some data which must be used later
696 bool isstock = wxIsStockID(GetId());
697 const char *stockid = NULL;
698 if (isstock)
699 stockid = wxGetStockGtkID(GetId());
700
701 // Some optimization to avoid flicker
702 wxString oldLabel = m_text;
703 oldLabel = wxStripMenuCodes(oldLabel);
704 oldLabel.Replace(wxT("_"), wxT(""));
705 wxString label1 = wxStripMenuCodes(str);
706#if wxUSE_ACCEL
707 wxString oldhotkey = GetHotKey(); // Store the old hotkey in Ctrl-foo format
708 wxCharBuffer oldbuf = wxGTK_CONV_SYS( GetGtkHotKey(*this) ); // and as <control>foo
709#endif // wxUSE_ACCEL
710
711 DoSetText(str);
712
713#if wxUSE_ACCEL
714 if (oldLabel == label1 &&
715 oldhotkey == GetHotKey()) // Make sure we can change a hotkey even if the label is unaltered
716 return;
717
718 if (m_menuItem)
719 {
720 GtkLabel *label;
721 if (m_labelWidget)
722 label = (GtkLabel*) m_labelWidget;
723 else
724 label = GTK_LABEL( GTK_BIN(m_menuItem)->child );
725
726 // stock menu items can have empty labels:
727 wxString text = m_text;
728 if (text.IsEmpty() && !IsSeparator())
729 {
730 wxASSERT_MSG(isstock, wxT("A non-stock menu item with an empty label?"));
731 text = wxGetStockLabel(GetId());
732
733 // need & => _ conversion
734 text = GTKProcessMenuItemLabel(text, NULL);
735 }
736
737 gtk_label_set_text_with_mnemonic( GTK_LABEL(label), wxGTK_CONV_SYS(text) );
738 }
739
740 // remove old accelerator from our parent's accelerator group, if present
741 guint accel_key;
742 GdkModifierType accel_mods;
743 if (oldbuf[(size_t)0] != '\0')
744 {
745 gtk_accelerator_parse( (const char*) oldbuf, &accel_key, &accel_mods);
746 if (accel_key != 0)
747 {
748 gtk_widget_remove_accelerator(m_menuItem,
749 m_parentMenu->m_accel,
750 accel_key,
751 accel_mods );
752 }
753 }
754 else if (isstock)
755 {
756 // if the accelerator was taken from a stock ID, just get it back from GTK+ stock
757 if (wxGetStockGtkAccelerator(stockid, &accel_mods, &accel_key))
758 gtk_widget_remove_accelerator( m_menuItem,
759 m_parentMenu->m_accel,
760 accel_key,
761 accel_mods );
762 }
763
764 // add new accelerator to our parent's accelerator group
765 wxCharBuffer buf = wxGTK_CONV_SYS( GetGtkHotKey(*this) );
766 if (buf[(size_t)0] != '\0')
767 {
768 gtk_accelerator_parse( (const char*) buf, &accel_key, &accel_mods);
769 if (accel_key != 0)
770 {
771 gtk_widget_add_accelerator( m_menuItem,
772 "activate",
773 m_parentMenu->m_accel,
774 accel_key,
775 accel_mods,
776 GTK_ACCEL_VISIBLE);
777 }
778 }
779 else if (isstock)
780 {
781 // if the accelerator was taken from a stock ID, just get it back from GTK+ stock
782 if (wxGetStockGtkAccelerator(stockid, &accel_mods, &accel_key))
783 gtk_widget_remove_accelerator( m_menuItem,
784 m_parentMenu->m_accel,
785 accel_key,
786 accel_mods );
787 }
788#endif // wxUSE_ACCEL
789}
790
791// NOTE: this function is different from the similar functions GTKProcessMnemonics()
792// implemented in control.cpp and from wxMenuItemBase::GetLabelText...
793// so there's no real code duplication
794wxString wxMenuItem::GTKProcessMenuItemLabel(const wxString& str, wxString *hotKey)
795{
796 wxString text;
797
798 // '\t' is the deliminator indicating a hot key
799 wxString::const_iterator pc = str.begin();
800 while ( pc != str.end() && *pc != wxT('\t') )
801 {
802 if (*pc == wxT('&'))
803 {
804 wxString::const_iterator next = pc + 1;
805 if (next != str.end() && *next == wxT('&'))
806 {
807 // "&" is doubled to indicate "&" instead of accelerator
808 ++pc;
809 text << wxT('&');
810 }
811 else
812 {
813 text << wxT('_');
814 }
815 }
816 else if ( *pc == wxT('_') ) // escape underscores
817 {
818 text << wxT("__");
819 }
820 else
821 {
822 text << *pc;
823 }
824 ++pc;
825 }
826
827 if (hotKey)
828 {
829 hotKey->Empty();
830 if(*pc == wxT('\t'))
831 {
832 pc++;
833 hotKey->assign(pc, str.end());
834 }
835 }
836
837 return text;
838}
839
840// it's valid for this function to be called even if m_menuItem == NULL
841void wxMenuItem::DoSetText( const wxString& str )
842{
843 m_text.Empty();
844 m_text = GTKProcessMenuItemLabel(str, &m_hotKey);
845}
846
847#if wxUSE_ACCEL
848
849wxAcceleratorEntry *wxMenuItem::GetAccel() const
850{
851 if ( !GetHotKey() )
852 {
853 // nothing
854 return NULL;
855 }
856
857 // accelerator parsing code looks for them after a TAB, so insert a dummy
858 // one here
859 wxString label;
860 label << wxT('\t') << GetHotKey();
861
862 return wxAcceleratorEntry::Create(label);
863}
864
865#endif // wxUSE_ACCEL
866
867void wxMenuItem::Check( bool check )
868{
869 wxCHECK_RET( m_menuItem, wxT("invalid menu item") );
870
871 if (check == m_isChecked)
872 return;
873
874 wxMenuItemBase::Check( check );
875
876 switch ( GetKind() )
877 {
878 case wxITEM_CHECK:
879 case wxITEM_RADIO:
880 gtk_check_menu_item_set_active( (GtkCheckMenuItem*)m_menuItem, (gint)check );
881 break;
882
883 default:
884 wxFAIL_MSG( _T("can't check this item") );
885 }
886}
887
888void wxMenuItem::Enable( bool enable )
889{
890 wxCHECK_RET( m_menuItem, wxT("invalid menu item") );
891
892 gtk_widget_set_sensitive( m_menuItem, enable );
893 wxMenuItemBase::Enable( enable );
894}
895
896bool wxMenuItem::IsChecked() const
897{
898 wxCHECK_MSG( m_menuItem, false, wxT("invalid menu item") );
899
900 wxCHECK_MSG( IsCheckable(), false,
901 wxT("can't get state of uncheckable item!") );
902
903 return ((GtkCheckMenuItem*)m_menuItem)->active != 0;
904}
905
906//-----------------------------------------------------------------------------
907// wxMenu
908//-----------------------------------------------------------------------------
909
910extern "C" {
911// "map" from m_menu
912static void menu_map(GtkWidget*, wxMenu* menu)
913{
914 wxMenuEvent event(wxEVT_MENU_OPEN, menu->m_popupShown ? -1 : 0, menu);
915 DoCommonMenuCallbackCode(menu, event);
916}
917
918// "hide" from m_menu
919static void menu_hide(GtkWidget*, wxMenu* menu)
920{
921 wxMenuEvent event(wxEVT_MENU_CLOSE, menu->m_popupShown ? -1 : 0, menu);
922 menu->m_popupShown = false;
923 DoCommonMenuCallbackCode(menu, event);
924}
925}
926
927IMPLEMENT_DYNAMIC_CLASS(wxMenu,wxEvtHandler)
928
929void wxMenu::Init()
930{
931 m_popupShown = false;
932
933 m_accel = gtk_accel_group_new();
934 m_menu = gtk_menu_new();
935 // NB: keep reference to the menu so that it is not destroyed behind
936 // our back by GTK+ e.g. when it is removed from menubar:
937 g_object_ref(m_menu);
938 gtk_object_sink(GTK_OBJECT(m_menu));
939
940 m_owner = (GtkWidget*) NULL;
941
942 // Tearoffs are entries, just like separators. So if we want this
943 // menu to be a tear-off one, we just append a tearoff entry
944 // immediately.
945 if ( m_style & wxMENU_TEAROFF )
946 {
947 GtkWidget *tearoff = gtk_tearoff_menu_item_new();
948
949 gtk_menu_shell_append(GTK_MENU_SHELL(m_menu), tearoff);
950 }
951
952 m_prevRadio = NULL;
953
954 // append the title as the very first entry if we have it
955 if ( !m_title.empty() )
956 {
957 Append(wxGTK_TITLE_ID, m_title);
958 AppendSeparator();
959 }
960
961 // "show" occurs for sub-menus which are not showing, so use "map" instead
962 g_signal_connect(m_menu, "map", G_CALLBACK(menu_map), this);
963 g_signal_connect(m_menu, "hide", G_CALLBACK(menu_hide), this);
964}
965
966wxMenu::~wxMenu()
967{
968 // see wxMenu::Init
969 g_object_unref(m_menu);
970
971 // if the menu is inserted in another menu at this time, there was
972 // one more reference to it:
973 if (m_owner)
974 gtk_widget_destroy(m_menu);
975
976 g_object_unref(m_accel);
977}
978
979void wxMenu::SetLayoutDirection(const wxLayoutDirection dir)
980{
981 if ( m_owner )
982 wxWindow::GTKSetLayout(m_owner, dir);
983 //else: will be called later by wxMenuBar again
984}
985
986wxLayoutDirection wxMenu::GetLayoutDirection() const
987{
988 return wxWindow::GTKGetLayout(m_owner);
989}
990
991bool wxMenu::GtkAppend(wxMenuItem *mitem, int pos)
992{
993 GtkWidget *menuItem;
994
995 // cache some data used later
996 wxString text = mitem->wxMenuItemBase::GetItemLabel();
997 int id = mitem->GetId();
998 bool isstock = wxIsStockID(id);
999 const char *stockid = NULL;
1000 if (isstock)
1001 stockid = wxGetStockGtkID(mitem->GetId());
1002
1003 // stock menu items can have an empty label
1004 if (text.IsEmpty() && !mitem->IsSeparator())
1005 {
1006 wxASSERT_MSG(isstock, wxT("A non-stock menu item with an empty label?"));
1007 text = wxGetStockLabel(id);
1008
1009 // need & => _ conversion
1010 text = wxMenuItem::GTKProcessMenuItemLabel(text, NULL);
1011 }
1012
1013 if ( mitem->IsSeparator() )
1014 {
1015 menuItem = gtk_separator_menu_item_new();
1016 m_prevRadio = NULL;
1017 }
1018 else if ( mitem->GetBitmap().Ok() ||
1019 (mitem->GetKind() == wxITEM_NORMAL && isstock) )
1020 {
1021 wxBitmap bitmap(mitem->GetBitmap());
1022
1023 menuItem = gtk_image_menu_item_new_with_mnemonic( wxGTK_CONV_SYS( text ) );
1024
1025 GtkWidget *image;
1026 if ( !bitmap.Ok() )
1027 {
1028 // use stock bitmap for this item if available on the assumption
1029 // that it never hurts to follow GTK+ conventions more closely
1030 image = stockid ? gtk_image_new_from_stock(stockid, GTK_ICON_SIZE_MENU)
1031 : NULL;
1032 }
1033 else // we have a custom bitmap
1034 {
1035 wxASSERT_MSG( mitem->GetKind() == wxITEM_NORMAL,
1036 _T("only normal menu items can have bitmaps") );
1037
1038 if ( bitmap.HasPixbuf() )
1039 {
1040 image = gtk_image_new_from_pixbuf(bitmap.GetPixbuf());
1041 }
1042 else
1043 {
1044 GdkPixmap *gdk_pixmap = bitmap.GetPixmap();
1045 GdkBitmap *gdk_bitmap = bitmap.GetMask() ?
1046 bitmap.GetMask()->GetBitmap() :
1047 (GdkBitmap*) NULL;
1048 image = gtk_image_new_from_pixmap( gdk_pixmap, gdk_bitmap );
1049 }
1050 }
1051
1052 if ( image )
1053 {
1054 gtk_widget_show(image);
1055
1056 gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(menuItem), image );
1057 }
1058
1059 m_prevRadio = NULL;
1060 }
1061 else // a normal item
1062 {
1063 // NB: 'text' variable has "_" instead of "&" after mitem->SetItemLabel()
1064 // so don't use it
1065
1066 switch ( mitem->GetKind() )
1067 {
1068 case wxITEM_CHECK:
1069 {
1070 menuItem = gtk_check_menu_item_new_with_mnemonic( wxGTK_CONV_SYS( text ) );
1071 m_prevRadio = NULL;
1072 break;
1073 }
1074
1075 case wxITEM_RADIO:
1076 {
1077 GSList *group = NULL;
1078 if ( m_prevRadio == NULL )
1079 {
1080 // start of a new radio group
1081 m_prevRadio = menuItem =
1082 gtk_radio_menu_item_new_with_mnemonic( group, wxGTK_CONV_SYS( text ) );
1083 }
1084 else // continue the radio group
1085 {
1086 group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (m_prevRadio));
1087 m_prevRadio = menuItem =
1088 gtk_radio_menu_item_new_with_mnemonic( group, wxGTK_CONV_SYS( text ) );
1089 }
1090 break;
1091 }
1092
1093 default:
1094 wxFAIL_MSG( _T("unexpected menu item kind") );
1095 // fall through
1096
1097 case wxITEM_NORMAL:
1098 {
1099 menuItem = gtk_menu_item_new_with_mnemonic( wxGTK_CONV_SYS( text ) );
1100 m_prevRadio = NULL;
1101 break;
1102 }
1103 }
1104
1105 }
1106
1107#if wxUSE_ACCEL
1108 guint accel_key;
1109 GdkModifierType accel_mods;
1110 wxCharBuffer buf = wxGTK_CONV_SYS( GetGtkHotKey(*mitem) );
1111
1112 if (buf[(size_t)0] != '\0')
1113 {
1114 gtk_accelerator_parse( (const char*) buf, &accel_key, &accel_mods);
1115 if (accel_key != 0)
1116 {
1117 gtk_widget_add_accelerator (menuItem,
1118 "activate",
1119 m_accel,
1120 accel_key,
1121 accel_mods,
1122 GTK_ACCEL_VISIBLE);
1123 }
1124 }
1125 else if (isstock)
1126 {
1127 // if the accelerator was taken from a stock ID, just get it back from GTK+ stock
1128 if (wxGetStockGtkAccelerator(stockid, &accel_mods, &accel_key))
1129 gtk_widget_add_accelerator( menuItem,
1130 "activate",
1131 m_accel,
1132 accel_key,
1133 accel_mods,
1134 GTK_ACCEL_VISIBLE);
1135 }
1136#endif // wxUSE_ACCEL
1137
1138 if (pos == -1)
1139 gtk_menu_shell_append(GTK_MENU_SHELL(m_menu), menuItem);
1140 else
1141 gtk_menu_shell_insert(GTK_MENU_SHELL(m_menu), menuItem, pos);
1142
1143 gtk_widget_show( menuItem );
1144
1145 if ( !mitem->IsSeparator() )
1146 {
1147 wxASSERT_MSG( menuItem, wxT("invalid menuitem") );
1148
1149 g_signal_connect (menuItem, "select",
1150 G_CALLBACK (gtk_menu_hilight_callback), this);
1151 g_signal_connect (menuItem, "deselect",
1152 G_CALLBACK (gtk_menu_nolight_callback), this);
1153
1154 if ( mitem->IsSubMenu() && mitem->GetKind() != wxITEM_RADIO && mitem->GetKind() != wxITEM_CHECK )
1155 {
1156 gtk_menu_item_set_submenu( GTK_MENU_ITEM(menuItem), mitem->GetSubMenu()->m_menu );
1157
1158 gtk_widget_show( mitem->GetSubMenu()->m_menu );
1159
1160 // if adding a submenu to a menu already existing in the menu bar, we
1161 // must set invoking window to allow processing events from this
1162 // submenu
1163 if ( m_invokingWindow )
1164 wxMenubarSetInvokingWindow(mitem->GetSubMenu(), m_invokingWindow);
1165 }
1166 else
1167 {
1168 g_signal_connect (menuItem, "activate",
1169 G_CALLBACK (gtk_menu_clicked_callback),
1170 this);
1171 }
1172 }
1173
1174 mitem->SetMenuItem(menuItem);
1175
1176 if (ms_locked)
1177 {
1178 // This doesn't even exist!
1179 // gtk_widget_lock_accelerators(mitem->GetMenuItem());
1180 }
1181
1182 return true;
1183}
1184
1185wxMenuItem* wxMenu::DoAppend(wxMenuItem *mitem)
1186{
1187 if (!GtkAppend(mitem))
1188 return NULL;
1189
1190 return wxMenuBase::DoAppend(mitem);
1191}
1192
1193wxMenuItem* wxMenu::DoInsert(size_t pos, wxMenuItem *item)
1194{
1195 if ( !wxMenuBase::DoInsert(pos, item) )
1196 return NULL;
1197
1198 // TODO
1199 if ( !GtkAppend(item, (int)pos) )
1200 return NULL;
1201
1202 return item;
1203}
1204
1205wxMenuItem *wxMenu::DoRemove(wxMenuItem *item)
1206{
1207 if ( !wxMenuBase::DoRemove(item) )
1208 return NULL;
1209
1210 GtkWidget * const mitem = item->GetMenuItem();
1211 if ( m_prevRadio == mitem )
1212 {
1213 // deleting an item starts a new radio group (has to as we shouldn't
1214 // keep a deleted pointer anyhow)
1215 m_prevRadio = NULL;
1216 }
1217
1218 // TODO: this code doesn't delete the item factory item and this seems
1219 // impossible as of GTK 1.2.6.
1220 gtk_widget_destroy( mitem );
1221
1222 return item;
1223}
1224
1225int wxMenu::FindMenuIdByMenuItem( GtkWidget *menuItem ) const
1226{
1227 wxMenuItemList::compatibility_iterator node = m_items.GetFirst();
1228 while (node)
1229 {
1230 wxMenuItem *item = node->GetData();
1231 if (item->GetMenuItem() == menuItem)
1232 return item->GetId();
1233 node = node->GetNext();
1234 }
1235
1236 return wxNOT_FOUND;
1237}
1238
1239void wxMenu::Attach(wxMenuBarBase *menubar)
1240{
1241 wxMenuBase::Attach(menubar);
1242
1243 // inherit layout direction from menubar.
1244 SetLayoutDirection(menubar->GetLayoutDirection());
1245}
1246
1247// ----------------------------------------------------------------------------
1248// helpers
1249// ----------------------------------------------------------------------------
1250
1251#if wxUSE_ACCEL
1252
1253static wxString GetGtkHotKey( const wxMenuItem& item )
1254{
1255 wxString hotkey;
1256
1257 wxAcceleratorEntry *accel = item.GetAccel();
1258 if ( accel )
1259 {
1260 int flags = accel->GetFlags();
1261 if ( flags & wxACCEL_ALT )
1262 hotkey += wxT("<alt>");
1263 if ( flags & wxACCEL_CTRL )
1264 hotkey += wxT("<control>");
1265 if ( flags & wxACCEL_SHIFT )
1266 hotkey += wxT("<shift>");
1267
1268 int code = accel->GetKeyCode();
1269 switch ( code )
1270 {
1271 case WXK_F1:
1272 case WXK_F2:
1273 case WXK_F3:
1274 case WXK_F4:
1275 case WXK_F5:
1276 case WXK_F6:
1277 case WXK_F7:
1278 case WXK_F8:
1279 case WXK_F9:
1280 case WXK_F10:
1281 case WXK_F11:
1282 case WXK_F12:
1283 case WXK_F13:
1284 case WXK_F14:
1285 case WXK_F15:
1286 case WXK_F16:
1287 case WXK_F17:
1288 case WXK_F18:
1289 case WXK_F19:
1290 case WXK_F20:
1291 case WXK_F21:
1292 case WXK_F22:
1293 case WXK_F23:
1294 case WXK_F24:
1295 hotkey += wxString::Format(wxT("F%d"), code - WXK_F1 + 1);
1296 break;
1297
1298 // TODO: we should use gdk_keyval_name() (a.k.a.
1299 // XKeysymToString) here as well as hardcoding the keysym
1300 // names this might be not portable
1301 case WXK_INSERT:
1302 hotkey << wxT("Insert" );
1303 break;
1304 case WXK_DELETE:
1305 hotkey << wxT("Delete" );
1306 break;
1307 case WXK_UP:
1308 hotkey << wxT("Up" );
1309 break;
1310 case WXK_DOWN:
1311 hotkey << wxT("Down" );
1312 break;
1313 case WXK_PAGEUP:
1314 hotkey << wxT("Page_Up" );
1315 break;
1316 case WXK_PAGEDOWN:
1317 hotkey << wxT("Page_Down" );
1318 break;
1319 case WXK_LEFT:
1320 hotkey << wxT("Left" );
1321 break;
1322 case WXK_RIGHT:
1323 hotkey << wxT("Right" );
1324 break;
1325 case WXK_HOME:
1326 hotkey << wxT("Home" );
1327 break;
1328 case WXK_END:
1329 hotkey << wxT("End" );
1330 break;
1331 case WXK_RETURN:
1332 hotkey << wxT("Return" );
1333 break;
1334 case WXK_BACK:
1335 hotkey << wxT("BackSpace" );
1336 break;
1337 case WXK_TAB:
1338 hotkey << wxT("Tab" );
1339 break;
1340 case WXK_ESCAPE:
1341 hotkey << wxT("Esc" );
1342 break;
1343 case WXK_SPACE:
1344 hotkey << wxT("space" );
1345 break;
1346 case WXK_MULTIPLY:
1347 hotkey << wxT("Multiply" );
1348 break;
1349 case WXK_ADD:
1350 hotkey << wxT("Add" );
1351 break;
1352 case WXK_SEPARATOR:
1353 hotkey << wxT("Separator" );
1354 break;
1355 case WXK_SUBTRACT:
1356 hotkey << wxT("Subtract" );
1357 break;
1358 case WXK_DECIMAL:
1359 hotkey << wxT("Decimal" );
1360 break;
1361 case WXK_DIVIDE:
1362 hotkey << wxT("Divide" );
1363 break;
1364 case WXK_CANCEL:
1365 hotkey << wxT("Cancel" );
1366 break;
1367 case WXK_CLEAR:
1368 hotkey << wxT("Clear" );
1369 break;
1370 case WXK_MENU:
1371 hotkey << wxT("Menu" );
1372 break;
1373 case WXK_PAUSE:
1374 hotkey << wxT("Pause" );
1375 break;
1376 case WXK_CAPITAL:
1377 hotkey << wxT("Capital" );
1378 break;
1379 case WXK_SELECT:
1380 hotkey << wxT("Select" );
1381 break;
1382 case WXK_PRINT:
1383 hotkey << wxT("Print" );
1384 break;
1385 case WXK_EXECUTE:
1386 hotkey << wxT("Execute" );
1387 break;
1388 case WXK_SNAPSHOT:
1389 hotkey << wxT("Snapshot" );
1390 break;
1391 case WXK_HELP:
1392 hotkey << wxT("Help" );
1393 break;
1394 case WXK_NUMLOCK:
1395 hotkey << wxT("Num_Lock" );
1396 break;
1397 case WXK_SCROLL:
1398 hotkey << wxT("Scroll_Lock" );
1399 break;
1400 case WXK_NUMPAD_INSERT:
1401 hotkey << wxT("KP_Insert" );
1402 break;
1403 case WXK_NUMPAD_DELETE:
1404 hotkey << wxT("KP_Delete" );
1405 break;
1406 case WXK_NUMPAD_SPACE:
1407 hotkey << wxT("KP_Space" );
1408 break;
1409 case WXK_NUMPAD_TAB:
1410 hotkey << wxT("KP_Tab" );
1411 break;
1412 case WXK_NUMPAD_ENTER:
1413 hotkey << wxT("KP_Enter" );
1414 break;
1415 case WXK_NUMPAD_F1: case WXK_NUMPAD_F2: case WXK_NUMPAD_F3:
1416 case WXK_NUMPAD_F4:
1417 hotkey += wxString::Format(wxT("KP_F%d"), code - WXK_NUMPAD_F1 + 1);
1418 break;
1419 case WXK_NUMPAD_HOME:
1420 hotkey << wxT("KP_Home" );
1421 break;
1422 case WXK_NUMPAD_LEFT:
1423 hotkey << wxT("KP_Left" );
1424 break;
1425 case WXK_NUMPAD_UP:
1426 hotkey << wxT("KP_Up" );
1427 break;
1428 case WXK_NUMPAD_RIGHT:
1429 hotkey << wxT("KP_Right" );
1430 break;
1431 case WXK_NUMPAD_DOWN:
1432 hotkey << wxT("KP_Down" );
1433 break;
1434 case WXK_NUMPAD_PAGEUP:
1435 hotkey << wxT("KP_Page_Up" );
1436 break;
1437 case WXK_NUMPAD_PAGEDOWN:
1438 hotkey << wxT("KP_Page_Down" );
1439 break;
1440 case WXK_NUMPAD_END:
1441 hotkey << wxT("KP_End" );
1442 break;
1443 case WXK_NUMPAD_BEGIN:
1444 hotkey << wxT("KP_Begin" );
1445 break;
1446 case WXK_NUMPAD_EQUAL:
1447 hotkey << wxT("KP_Equal" );
1448 break;
1449 case WXK_NUMPAD_MULTIPLY:
1450 hotkey << wxT("KP_Multiply" );
1451 break;
1452 case WXK_NUMPAD_ADD:
1453 hotkey << wxT("KP_Add" );
1454 break;
1455 case WXK_NUMPAD_SEPARATOR:
1456 hotkey << wxT("KP_Separator" );
1457 break;
1458 case WXK_NUMPAD_SUBTRACT:
1459 hotkey << wxT("KP_Subtract" );
1460 break;
1461 case WXK_NUMPAD_DECIMAL:
1462 hotkey << wxT("KP_Decimal" );
1463 break;
1464 case WXK_NUMPAD_DIVIDE:
1465 hotkey << wxT("KP_Divide" );
1466 break;
1467 case WXK_NUMPAD0: case WXK_NUMPAD1: case WXK_NUMPAD2:
1468 case WXK_NUMPAD3: case WXK_NUMPAD4: case WXK_NUMPAD5:
1469 case WXK_NUMPAD6: case WXK_NUMPAD7: case WXK_NUMPAD8: case WXK_NUMPAD9:
1470 hotkey += wxString::Format(wxT("KP_%d"), code - WXK_NUMPAD0);
1471 break;
1472 case WXK_WINDOWS_LEFT:
1473 hotkey << wxT("Super_L" );
1474 break;
1475 case WXK_WINDOWS_RIGHT:
1476 hotkey << wxT("Super_R" );
1477 break;
1478 case WXK_WINDOWS_MENU:
1479 hotkey << wxT("Menu" );
1480 break;
1481 case WXK_COMMAND:
1482 hotkey << wxT("Command" );
1483 break;
1484 /* These probably wouldn't work as there is no SpecialX in gdk/keynames.txt
1485 case WXK_SPECIAL1: case WXK_SPECIAL2: case WXK_SPECIAL3: case WXK_SPECIAL4:
1486 case WXK_SPECIAL5: case WXK_SPECIAL6: case WXK_SPECIAL7: case WXK_SPECIAL8:
1487 case WXK_SPECIAL9: case WXK_SPECIAL10: case WXK_SPECIAL11: case WXK_SPECIAL12:
1488 case WXK_SPECIAL13: case WXK_SPECIAL14: case WXK_SPECIAL15: case WXK_SPECIAL16:
1489 case WXK_SPECIAL17: case WXK_SPECIAL18: case WXK_SPECIAL19: case WXK_SPECIAL20:
1490 hotkey += wxString::Format(wxT("Special%d"), code - WXK_SPECIAL1 + 1);
1491 break;
1492 */
1493 // if there are any other keys wxAcceleratorEntry::Create() may
1494 // return, we should process them here
1495
1496 default:
1497 if ( code < 127 )
1498 {
1499 const wxString
1500 name = wxGTK_CONV_BACK_SYS(gdk_keyval_name((guint)code));
1501 if ( !name.empty() )
1502 {
1503 hotkey << name;
1504 break;
1505 }
1506 }
1507
1508 wxFAIL_MSG( wxT("unknown keyboard accel") );
1509 }
1510
1511 delete accel;
1512 }
1513
1514 return hotkey;
1515}
1516
1517#endif // wxUSE_ACCEL
1518
1519const char *wxGetStockGtkID(wxWindowID id)
1520{
1521 #define STOCKITEM(wx,gtk) \
1522 case wx: \
1523 return gtk;
1524
1525 #define STOCKITEM_MISSING(wx) \
1526 case wx: \
1527 return NULL;
1528
1529 #if GTK_CHECK_VERSION(2,4,0)
1530 #define STOCKITEM_24(wx,gtk) STOCKITEM(wx,gtk)
1531 #else
1532 #define STOCKITEM_24(wx,gtk) STOCKITEM_MISSING(wx)
1533 #endif
1534
1535 #if GTK_CHECK_VERSION(2,6,0)
1536 #define STOCKITEM_26(wx,gtk) STOCKITEM(wx,gtk)
1537 #else
1538 #define STOCKITEM_26(wx,gtk) STOCKITEM_MISSING(wx)
1539 #endif
1540
1541 #if GTK_CHECK_VERSION(2,10,0)
1542 #define STOCKITEM_210(wx,gtk) STOCKITEM(wx,gtk)
1543 #else
1544 #define STOCKITEM_210(wx,gtk) STOCKITEM_MISSING(wx)
1545 #endif
1546
1547
1548 switch (id)
1549 {
1550 STOCKITEM_26(wxID_ABOUT, GTK_STOCK_ABOUT)
1551 STOCKITEM(wxID_ADD, GTK_STOCK_ADD)
1552 STOCKITEM(wxID_APPLY, GTK_STOCK_APPLY)
1553 STOCKITEM(wxID_BOLD, GTK_STOCK_BOLD)
1554 STOCKITEM(wxID_CANCEL, GTK_STOCK_CANCEL)
1555 STOCKITEM(wxID_CLEAR, GTK_STOCK_CLEAR)
1556 STOCKITEM(wxID_CLOSE, GTK_STOCK_CLOSE)
1557 STOCKITEM(wxID_COPY, GTK_STOCK_COPY)
1558 STOCKITEM(wxID_CUT, GTK_STOCK_CUT)
1559 STOCKITEM(wxID_DELETE, GTK_STOCK_DELETE)
1560 STOCKITEM_26(wxID_EDIT, GTK_STOCK_EDIT)
1561 STOCKITEM(wxID_FIND, GTK_STOCK_FIND)
1562 STOCKITEM_26(wxID_FILE, GTK_STOCK_FILE)
1563 STOCKITEM(wxID_REPLACE, GTK_STOCK_FIND_AND_REPLACE)
1564 STOCKITEM(wxID_BACKWARD, GTK_STOCK_GO_BACK)
1565 STOCKITEM(wxID_DOWN, GTK_STOCK_GO_DOWN)
1566 STOCKITEM(wxID_FORWARD, GTK_STOCK_GO_FORWARD)
1567 STOCKITEM(wxID_UP, GTK_STOCK_GO_UP)
1568 STOCKITEM(wxID_HELP, GTK_STOCK_HELP)
1569 STOCKITEM(wxID_HOME, GTK_STOCK_HOME)
1570 STOCKITEM_24(wxID_INDENT, GTK_STOCK_INDENT)
1571 STOCKITEM(wxID_INDEX, GTK_STOCK_INDEX)
1572 STOCKITEM(wxID_ITALIC, GTK_STOCK_ITALIC)
1573 STOCKITEM(wxID_JUSTIFY_CENTER, GTK_STOCK_JUSTIFY_CENTER)
1574 STOCKITEM(wxID_JUSTIFY_FILL, GTK_STOCK_JUSTIFY_FILL)
1575 STOCKITEM(wxID_JUSTIFY_LEFT, GTK_STOCK_JUSTIFY_LEFT)
1576 STOCKITEM(wxID_JUSTIFY_RIGHT, GTK_STOCK_JUSTIFY_RIGHT)
1577 STOCKITEM(wxID_NEW, GTK_STOCK_NEW)
1578 STOCKITEM(wxID_NO, GTK_STOCK_NO)
1579 STOCKITEM(wxID_OK, GTK_STOCK_OK)
1580 STOCKITEM(wxID_OPEN, GTK_STOCK_OPEN)
1581 STOCKITEM(wxID_PASTE, GTK_STOCK_PASTE)
1582 STOCKITEM(wxID_PREFERENCES, GTK_STOCK_PREFERENCES)
1583 STOCKITEM(wxID_PRINT, GTK_STOCK_PRINT)
1584 STOCKITEM(wxID_PREVIEW, GTK_STOCK_PRINT_PREVIEW)
1585 STOCKITEM(wxID_PROPERTIES, GTK_STOCK_PROPERTIES)
1586 STOCKITEM(wxID_EXIT, GTK_STOCK_QUIT)
1587 STOCKITEM(wxID_REDO, GTK_STOCK_REDO)
1588 STOCKITEM(wxID_REFRESH, GTK_STOCK_REFRESH)
1589 STOCKITEM(wxID_REMOVE, GTK_STOCK_REMOVE)
1590 STOCKITEM(wxID_REVERT_TO_SAVED, GTK_STOCK_REVERT_TO_SAVED)
1591 STOCKITEM(wxID_SAVE, GTK_STOCK_SAVE)
1592 STOCKITEM(wxID_SAVEAS, GTK_STOCK_SAVE_AS)
1593 STOCKITEM_210(wxID_SELECTALL, GTK_STOCK_SELECT_ALL)
1594 STOCKITEM(wxID_STOP, GTK_STOCK_STOP)
1595 STOCKITEM(wxID_UNDELETE, GTK_STOCK_UNDELETE)
1596 STOCKITEM(wxID_UNDERLINE, GTK_STOCK_UNDERLINE)
1597 STOCKITEM(wxID_UNDO, GTK_STOCK_UNDO)
1598 STOCKITEM_24(wxID_UNINDENT, GTK_STOCK_UNINDENT)
1599 STOCKITEM(wxID_YES, GTK_STOCK_YES)
1600 STOCKITEM(wxID_ZOOM_100, GTK_STOCK_ZOOM_100)
1601 STOCKITEM(wxID_ZOOM_FIT, GTK_STOCK_ZOOM_FIT)
1602 STOCKITEM(wxID_ZOOM_IN, GTK_STOCK_ZOOM_IN)
1603 STOCKITEM(wxID_ZOOM_OUT, GTK_STOCK_ZOOM_OUT)
1604
1605 default:
1606 wxFAIL_MSG( _T("invalid stock item ID") );
1607 break;
1608 };
1609
1610 #undef STOCKITEM
1611
1612 return NULL;
1613}
1614
1615#if wxUSE_ACCEL
1616static
1617bool wxGetStockGtkAccelerator(const char *id, GdkModifierType *mod, guint *key)
1618{
1619 if (!id)
1620 return false;
1621
1622 GtkStockItem stock_item;
1623 if (gtk_stock_lookup (id, &stock_item))
1624 {
1625 if (key) *key = stock_item.keyval;
1626 if (mod) *mod = stock_item.modifier;
1627
1628 // some GTK stock items have zero values for the keyval;
1629 // it means that they do not have an accelerator...
1630 if (stock_item.keyval)
1631 return true;
1632 }
1633
1634 return false;
1635}
1636#endif // wxUSE_ACCEL
1637
1638#endif // wxUSE_MENUS
wxWidgets (Impactor)