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