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