projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
make accelerators for bitmap menu items work (patch 626048)
[wxWidgets.git] / src / gtk1 / menu.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: menu.cpp
3 // Purpose:
4 // Author: Robert Roebling
5 // Id: $Id$
6 // Copyright: (c) 1998 Robert Roebling
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
9
10 #ifdef __GNUG__
11 #pragma implementation "menu.h"
12 #pragma implementation "menuitem.h"
13 #endif
14
15 #include "wx/log.h"
16 #include "wx/intl.h"
17 #include "wx/app.h"
18 #include "wx/bitmap.h"
19 #include "wx/menu.h"
20
21 #if wxUSE_ACCEL
22 #include "wx/accel.h"
23 #endif // wxUSE_ACCEL
24
25 #include "wx/gtk/private.h"
26
27 #include <gdk/gdkkeysyms.h>
28
29 // FIXME: is this right? somehow I don't think so (VZ)
30 #ifdef __WXGTK20__
31 #include <glib-object.h>
32
33 #define gtk_accel_group_attach(g, o) _gtk_accel_group_attach((g), (o))
34 #define gtk_accel_group_detach(g, o) _gtk_accel_group_detach((g), (o))
35 #define gtk_menu_ensure_uline_accel_group(m) gtk_menu_get_accel_group(m)
36
37 #define ACCEL_OBJECT GObject
38 #define ACCEL_OBJECTS(a) (a)->acceleratables
39 #define ACCEL_OBJ_CAST(obj) G_OBJECT(obj)
40 #else // GTK+ 1.x
41 #define ACCEL_OBJECT GtkObject
42 #define ACCEL_OBJECTS(a) (a)->attach_objects
43 #define ACCEL_OBJ_CAST(obj) GTK_OBJECT(obj)
44 #endif
45
46 //-----------------------------------------------------------------------------
47 // idle system
48 //-----------------------------------------------------------------------------
49
50 extern void wxapp_install_idle_handler();
51 extern bool g_isIdle;
52
53 #if GTK_CHECK_VERSION(1, 2, 0) && wxUSE_ACCEL
54 static wxString GetHotKey( const wxMenuItem& item );
55 #endif
56
57 //-----------------------------------------------------------------------------
58 // substitute for missing GtkPixmapMenuItem
59 //-----------------------------------------------------------------------------
60
61 // FIXME: I can't make this compile with GTK+ 2.0, disabling for now (VZ)
62 #ifndef __WXGTK20__
63 #define USE_MENU_BITMAPS
64 #endif
65
66 #ifdef USE_MENU_BITMAPS
67
68 #define GTK_TYPE_PIXMAP_MENU_ITEM (gtk_pixmap_menu_item_get_type ())
69 #define GTK_PIXMAP_MENU_ITEM(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_PIXMAP_MENU_ITEM, GtkPixmapMenuItem))
70 #define GTK_PIXMAP_MENU_ITEM_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_PIXMAP_MENU_ITEM, GtkPixmapMenuItemClass))
71 #define GTK_IS_PIXMAP_MENU_ITEM(obj) (GTK_CHECK_TYPE ((obj), GTK_TYPE_PIXMAP_MENU_ITEM))
72 #define GTK_IS_PIXMAP_MENU_ITEM_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_PIXMAP_MENU_ITEM))
73 //#define GTK_PIXMAP_MENU_ITEM_GET_CLASS(obj) (GTK_CHECK_GET_CLASS ((obj), GTK_TYPE_PIXMAP_MENU_ITEM))
74 #define GTK_PIXMAP_MENU_ITEM_GET_CLASS(obj) (GTK_PIXMAP_MENU_ITEM_CLASS( GTK_OBJECT_GET_CLASS(obj)))
75
76 #ifndef GTK_MENU_ITEM_GET_CLASS
77 #define GTK_MENU_ITEM_GET_CLASS(obj) (GTK_MENU_ITEM_CLASS( GTK_OBJECT_GET_CLASS(obj)))
78 #endif
79
80 typedef struct _GtkPixmapMenuItem GtkPixmapMenuItem;
81 typedef struct _GtkPixmapMenuItemClass GtkPixmapMenuItemClass;
82
83 struct _GtkPixmapMenuItem
84 {
85 GtkMenuItem menu_item;
86
87 GtkWidget *pixmap;
88 };
89
90 struct _GtkPixmapMenuItemClass
91 {
92 GtkMenuItemClass parent_class;
93
94 guint orig_toggle_size;
95 guint have_pixmap_count;
96 };
97
98
99 GtkType gtk_pixmap_menu_item_get_type (void);
100 GtkWidget* gtk_pixmap_menu_item_new (void);
101 void gtk_pixmap_menu_item_set_pixmap (GtkPixmapMenuItem *menu_item,
102 GtkWidget *pixmap);
103
104 #endif // USE_MENU_BITMAPS
105
106 //-----------------------------------------------------------------------------
107 // idle system
108 //-----------------------------------------------------------------------------
109
110 static wxString wxReplaceUnderscore( const wxString& title )
111 {
112 const wxChar *pc;
113
114 /* GTK 1.2 wants to have "_" instead of "&" for accelerators */
115 wxString str;
116 pc = title;
117 while (*pc != wxT('\0'))
118 {
119 if ((*pc == wxT('&')) && (*(pc+1) == wxT('&')))
120 {
121 // "&" is doubled to indicate "&" instead of accelerator
122 ++pc;
123 str << wxT('&');
124 }
125 else if (*pc == wxT('&'))
126 {
127 #if GTK_CHECK_VERSION(1, 2, 0)
128 str << wxT('_');
129 #endif
130 }
131 #if GTK_CHECK_VERSION(2, 0, 0)
132 else if (*pc == wxT('/'))
133 {
134 str << wxT("\\/");
135 }
136 else if (*pc == wxT('\\'))
137 {
138 str << wxT("\\\\");
139 }
140 #elif GTK_CHECK_VERSION(1, 2, 0)
141 else if (*pc == wxT('/'))
142 {
143 str << wxT('\\');
144 }
145 #endif
146 else
147 {
148 #ifdef __WXGTK12__
149 if ( *pc == wxT('_') )
150 {
151 // underscores must be doubled to prevent them from being
152 // interpreted as accelerator character prefix by GTK
153 str << *pc;
154 }
155 #endif // GTK+ 1.2
156
157 str << *pc;
158 }
159 ++pc;
160 }
161 return str;
162 }
163
164 //-----------------------------------------------------------------------------
165 // activate message from GTK
166 //-----------------------------------------------------------------------------
167
168 static void gtk_menu_open_callback( GtkWidget *widget, wxMenu *menu )
169 {
170 if (g_isIdle) wxapp_install_idle_handler();
171
172 wxMenuEvent event( wxEVT_MENU_OPEN, -1 );
173 event.SetEventObject( menu );
174
175 wxEvtHandler* handler = menu->GetEventHandler();
176 if (handler && handler->ProcessEvent(event))
177 return;
178
179 wxWindow *win = menu->GetInvokingWindow();
180 if (win) win->GetEventHandler()->ProcessEvent( event );
181 }
182
183 //-----------------------------------------------------------------------------
184 // wxMenuBar
185 //-----------------------------------------------------------------------------
186
187 IMPLEMENT_DYNAMIC_CLASS(wxMenuBar,wxWindow)
188
189 wxMenuBar::wxMenuBar( long style )
190 {
191 /* the parent window is known after wxFrame::SetMenu() */
192 m_needParent = FALSE;
193 m_style = style;
194 m_invokingWindow = (wxWindow*) NULL;
195
196 if (!PreCreation( (wxWindow*) NULL, wxDefaultPosition, wxDefaultSize ) ||
197 !CreateBase( (wxWindow*) NULL, -1, wxDefaultPosition, wxDefaultSize, style, wxDefaultValidator, wxT("menubar") ))
198 {
199 wxFAIL_MSG( wxT("wxMenuBar creation failed") );
200 return;
201 }
202
203 m_menus.DeleteContents( TRUE );
204
205 /* GTK 1.2.0 doesn't have gtk_item_factory_get_item(), but GTK 1.2.1 has. */
206 #if GTK_CHECK_VERSION(1, 2, 1)
207 m_accel = gtk_accel_group_new();
208 m_factory = gtk_item_factory_new( GTK_TYPE_MENU_BAR, "<main>", m_accel );
209 m_menubar = gtk_item_factory_get_widget( m_factory, "<main>" );
210 #else
211 m_menubar = gtk_menu_bar_new();
212 #endif
213
214 if (style & wxMB_DOCKABLE)
215 {
216 m_widget = gtk_handle_box_new();
217 gtk_container_add( GTK_CONTAINER(m_widget), GTK_WIDGET(m_menubar) );
218 gtk_widget_show( GTK_WIDGET(m_menubar) );
219 }
220 else
221 {
222 m_widget = GTK_WIDGET(m_menubar);
223 }
224
225 PostCreation();
226
227 ApplyWidgetStyle();
228 }
229
230 wxMenuBar::wxMenuBar()
231 {
232 /* the parent window is known after wxFrame::SetMenu() */
233 m_needParent = FALSE;
234 m_style = 0;
235 m_invokingWindow = (wxWindow*) NULL;
236
237 if (!PreCreation( (wxWindow*) NULL, wxDefaultPosition, wxDefaultSize ) ||
238 !CreateBase( (wxWindow*) NULL, -1, wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, wxT("menubar") ))
239 {
240 wxFAIL_MSG( wxT("wxMenuBar creation failed") );
241 return;
242 }
243
244 m_menus.DeleteContents( TRUE );
245
246 /* GTK 1.2.0 doesn't have gtk_item_factory_get_item(), but GTK 1.2.1 has. */
247 #if GTK_CHECK_VERSION(1, 2, 1)
248 m_accel = gtk_accel_group_new();
249 m_factory = gtk_item_factory_new( GTK_TYPE_MENU_BAR, "<main>", m_accel );
250 m_menubar = gtk_item_factory_get_widget( m_factory, "<main>" );
251 #else
252 m_menubar = gtk_menu_bar_new();
253 #endif
254
255 m_widget = GTK_WIDGET(m_menubar);
256
257 PostCreation();
258
259 ApplyWidgetStyle();
260 }
261
262 wxMenuBar::~wxMenuBar()
263 {
264 // gtk_object_unref( GTK_OBJECT(m_factory) ); why not ?
265 }
266
267 static void wxMenubarUnsetInvokingWindow( wxMenu *menu, wxWindow *win )
268 {
269 menu->SetInvokingWindow( (wxWindow*) NULL );
270
271 wxWindow *top_frame = win;
272 while (top_frame->GetParent() && !(top_frame->IsTopLevel()))
273 top_frame = top_frame->GetParent();
274
275 /* support for native hot keys */
276 gtk_accel_group_detach( menu->m_accel, ACCEL_OBJ_CAST(top_frame->m_widget) );
277
278 wxMenuItemList::Node *node = menu->GetMenuItems().GetFirst();
279 while (node)
280 {
281 wxMenuItem *menuitem = node->GetData();
282 if (menuitem->IsSubMenu())
283 wxMenubarUnsetInvokingWindow( menuitem->GetSubMenu(), win );
284 node = node->GetNext();
285 }
286 }
287
288 static void wxMenubarSetInvokingWindow( wxMenu *menu, wxWindow *win )
289 {
290 menu->SetInvokingWindow( win );
291
292 #if GTK_CHECK_VERSION(1, 2, 1)
293 wxWindow *top_frame = win;
294 while (top_frame->GetParent() && !(top_frame->IsTopLevel()))
295 top_frame = top_frame->GetParent();
296
297 /* support for native hot keys */
298 ACCEL_OBJECT *obj = ACCEL_OBJ_CAST(top_frame->m_widget);
299 if ( !g_slist_find( ACCEL_OBJECTS(menu->m_accel), obj ) )
300 gtk_accel_group_attach( menu->m_accel, obj );
301 #endif // GTK+ 1.2.1+
302
303 wxMenuItemList::Node *node = menu->GetMenuItems().GetFirst();
304 while (node)
305 {
306 wxMenuItem *menuitem = node->GetData();
307 if (menuitem->IsSubMenu())
308 wxMenubarSetInvokingWindow( menuitem->GetSubMenu(), win );
309 node = node->GetNext();
310 }
311 }
312
313 void wxMenuBar::SetInvokingWindow( wxWindow *win )
314 {
315 m_invokingWindow = win;
316 #if GTK_CHECK_VERSION(1, 2, 1)
317 wxWindow *top_frame = win;
318 while (top_frame->GetParent() && !(top_frame->IsTopLevel()))
319 top_frame = top_frame->GetParent();
320
321 /* support for native key accelerators indicated by underscroes */
322 ACCEL_OBJECT *obj = ACCEL_OBJ_CAST(top_frame->m_widget);
323 if ( !g_slist_find( ACCEL_OBJECTS(m_accel), obj ) )
324 gtk_accel_group_attach( m_accel, obj );
325 #endif // GTK+ 1.2.1+
326
327 wxMenuList::Node *node = m_menus.GetFirst();
328 while (node)
329 {
330 wxMenu *menu = node->GetData();
331 wxMenubarSetInvokingWindow( menu, win );
332 node = node->GetNext();
333 }
334 }
335
336 void wxMenuBar::UnsetInvokingWindow( wxWindow *win )
337 {
338 m_invokingWindow = (wxWindow*) NULL;
339 #if GTK_CHECK_VERSION(1, 2, 1)
340 wxWindow *top_frame = win;
341 while (top_frame->GetParent() && !(top_frame->IsTopLevel()))
342 top_frame = top_frame->GetParent();
343
344 // support for native key accelerators indicated by underscroes
345 gtk_accel_group_detach( m_accel, ACCEL_OBJ_CAST(top_frame->m_widget) );
346 #endif // GTK+ 1.2.1+
347
348 wxMenuList::Node *node = m_menus.GetFirst();
349 while (node)
350 {
351 wxMenu *menu = node->GetData();
352 wxMenubarUnsetInvokingWindow( menu, win );
353 node = node->GetNext();
354 }
355 }
356
357 bool wxMenuBar::Append( wxMenu *menu, const wxString &title )
358 {
359 if ( !wxMenuBarBase::Append( menu, title ) )
360 return FALSE;
361
362 return GtkAppend(menu, title);
363 }
364
365 bool wxMenuBar::GtkAppend(wxMenu *menu, const wxString& title)
366 {
367 wxString str( wxReplaceUnderscore( title ) );
368
369 // This doesn't have much effect right now.
370 menu->SetTitle( str );
371
372 // GTK 1.2.0 doesn't have gtk_item_factory_get_item(), but GTK 1.2.1 has.
373 #if GTK_CHECK_VERSION(1, 2, 1)
374
375 wxString buf;
376 buf << wxT('/') << str.c_str();
377
378 // local buffer in multibyte form
379 char cbuf[400];
380 strcpy(cbuf, wxGTK_CONV(buf) );
381
382 GtkItemFactoryEntry entry;
383 entry.path = (gchar *)cbuf; // const_cast
384 entry.accelerator = (gchar*) NULL;
385 entry.callback = (GtkItemFactoryCallback) NULL;
386 entry.callback_action = 0;
387 entry.item_type = (char *)"<Branch>";
388
389 gtk_item_factory_create_item( m_factory, &entry, (gpointer) this, 2 ); // what is 2 ?
390 // in order to get the pointer to the item we need the item text _without_ underscores
391 wxString tmp = wxT("<main>/");
392 const wxChar *pc;
393 for ( pc = str; *pc != wxT('\0'); pc++ )
394 {
395 // contrary to the common sense, we must throw out _all_ underscores,
396 // (i.e. "Hello__World" => "HelloWorld" and not "Hello_World" as we
397 // might naively think). IMHO it's a bug in GTK+ (VZ)
398 while (*pc == wxT('_'))
399 pc++;
400 tmp << *pc;
401 }
402 menu->m_owner = gtk_item_factory_get_item( m_factory, wxGTK_CONV( tmp ) );
403 gtk_menu_item_set_submenu( GTK_MENU_ITEM(menu->m_owner), menu->m_menu );
404 #else
405
406 menu->m_owner = gtk_menu_item_new_with_label( wxGTK_CONV( str ) );
407 gtk_widget_show( menu->m_owner );
408 gtk_menu_item_set_submenu( GTK_MENU_ITEM(menu->m_owner), menu->m_menu );
409
410 gtk_menu_bar_append( GTK_MENU_BAR(m_menubar), menu->m_owner );
411
412 #endif
413
414 gtk_signal_connect( GTK_OBJECT(menu->m_owner), "activate",
415 GTK_SIGNAL_FUNC(gtk_menu_open_callback),
416 (gpointer)menu );
417
418 // m_invokingWindow is set after wxFrame::SetMenuBar(). This call enables
419 // addings menu later on.
420 if (m_invokingWindow)
421 {
422 wxMenubarSetInvokingWindow( menu, m_invokingWindow );
423
424 // OPTIMISE ME: we should probably cache this, or pass it
425 // directly, but for now this is a minimal
426 // change to validate the new dynamic sizing.
427 // see (and refactor :) similar code in Remove
428 // below.
429
430 wxFrame *frame = wxDynamicCast( m_invokingWindow, wxFrame );
431
432 if( frame )
433 frame->UpdateMenuBarSize();
434 }
435
436 return TRUE;
437 }
438
439 bool wxMenuBar::Insert(size_t pos, wxMenu *menu, const wxString& title)
440 {
441 if ( !wxMenuBarBase::Insert(pos, menu, title) )
442 return FALSE;
443
444 // GTK+ doesn't have a function to insert a menu using GtkItemFactory (as
445 // of version 1.2.6), so we first append the item and then change its
446 // index
447 if ( !GtkAppend(menu, title) )
448 return FALSE;
449
450 if (pos+1 >= m_menus.GetCount())
451 return TRUE;
452
453 GtkMenuShell *menu_shell = GTK_MENU_SHELL(m_factory->widget);
454 gpointer data = g_list_last(menu_shell->children)->data;
455 menu_shell->children = g_list_remove(menu_shell->children, data);
456 menu_shell->children = g_list_insert(menu_shell->children, data, pos);
457
458 return TRUE;
459 }
460
461 wxMenu *wxMenuBar::Replace(size_t pos, wxMenu *menu, const wxString& title)
462 {
463 // remove the old item and insert a new one
464 wxMenu *menuOld = Remove(pos);
465 if ( menuOld && !Insert(pos, menu, title) )
466 {
467 return (wxMenu*) NULL;
468 }
469
470 // either Insert() succeeded or Remove() failed and menuOld is NULL
471 return menuOld;
472 }
473
474 static wxMenu *CopyMenu (wxMenu *menu)
475 {
476 wxMenu *menucopy = new wxMenu ();
477 wxMenuItemList::Node *node = menu->GetMenuItems().GetFirst();
478 while (node)
479 {
480 wxMenuItem *item = node->GetData();
481 int itemid = item->GetId();
482 wxString text = item->GetText();
483 text.Replace(wxT("_"), wxT("&"));
484 wxMenu *submenu = item->GetSubMenu();
485 if (!submenu)
486 {
487 wxMenuItem* itemcopy = new wxMenuItem(menucopy,
488 itemid, text,
489 menu->GetHelpString(itemid));
490 itemcopy->SetBitmap(item->GetBitmap());
491 itemcopy->SetCheckable(item->IsCheckable());
492 menucopy->Append(itemcopy);
493 }
494 else
495 menucopy->Append (itemid, text, CopyMenu(submenu),
496 menu->GetHelpString(itemid));
497
498 node = node->GetNext();
499 }
500
501 return menucopy;
502 }
503
504 wxMenu *wxMenuBar::Remove(size_t pos)
505 {
506 wxMenu *menu = wxMenuBarBase::Remove(pos);
507 if ( !menu )
508 return (wxMenu*) NULL;
509
510 /*
511 GtkMenuShell *menu_shell = GTK_MENU_SHELL(m_factory->widget);
512
513 printf( "factory entries before %d\n", (int)g_slist_length(m_factory->items) );
514 printf( "menu shell entries before %d\n", (int)g_list_length( menu_shell->children ) );
515 */
516
517 wxMenu *menucopy = CopyMenu( menu );
518
519 // unparent calls unref() and that would delete the widget so we raise
520 // the ref count to 2 artificially before invoking unparent.
521 gtk_widget_ref( menu->m_menu );
522 gtk_widget_unparent( menu->m_menu );
523
524 gtk_widget_destroy( menu->m_owner );
525 delete menu;
526
527 menu = menucopy;
528 /*
529 printf( "factory entries after %d\n", (int)g_slist_length(m_factory->items) );
530 printf( "menu shell entries after %d\n", (int)g_list_length( menu_shell->children ) );
531 */
532
533 if (m_invokingWindow)
534 {
535 // OPTIMISE ME: see comment in GtkAppend
536
537 wxFrame *frame = wxDynamicCast( m_invokingWindow, wxFrame );
538
539 if( frame )
540 frame->UpdateMenuBarSize();
541 }
542
543 return menu;
544 }
545
546 static int FindMenuItemRecursive( const wxMenu *menu, const wxString &menuString, const wxString &itemString )
547 {
548 if (wxMenuItem::GetLabelFromText(menu->GetTitle()) == wxMenuItem::GetLabelFromText(menuString))
549 {
550 int res = menu->FindItem( itemString );
551 if (res != wxNOT_FOUND)
552 return res;
553 }
554
555 wxMenuItemList::Node *node = menu->GetMenuItems().GetFirst();
556 while (node)
557 {
558 wxMenuItem *item = node->GetData();
559 if (item->IsSubMenu())
560 return FindMenuItemRecursive(item->GetSubMenu(), menuString, itemString);
561
562 node = node->GetNext();
563 }
564
565 return wxNOT_FOUND;
566 }
567
568 int wxMenuBar::FindMenuItem( const wxString &menuString, const wxString &itemString ) const
569 {
570 wxMenuList::Node *node = m_menus.GetFirst();
571 while (node)
572 {
573 wxMenu *menu = node->GetData();
574 int res = FindMenuItemRecursive( menu, menuString, itemString);
575 if (res != -1)
576 return res;
577 node = node->GetNext();
578 }
579
580 return wxNOT_FOUND;
581 }
582
583 // Find a wxMenuItem using its id. Recurses down into sub-menus
584 static wxMenuItem* FindMenuItemByIdRecursive(const wxMenu* menu, int id)
585 {
586 wxMenuItem* result = menu->FindChildItem(id);
587
588 wxMenuItemList::Node *node = menu->GetMenuItems().GetFirst();
589 while ( node && result == NULL )
590 {
591 wxMenuItem *item = node->GetData();
592 if (item->IsSubMenu())
593 {
594 result = FindMenuItemByIdRecursive( item->GetSubMenu(), id );
595 }
596 node = node->GetNext();
597 }
598
599 return result;
600 }
601
602 wxMenuItem* wxMenuBar::FindItem( int id, wxMenu **menuForItem ) const
603 {
604 wxMenuItem* result = 0;
605 wxMenuList::Node *node = m_menus.GetFirst();
606 while (node && result == 0)
607 {
608 wxMenu *menu = node->GetData();
609 result = FindMenuItemByIdRecursive( menu, id );
610 node = node->GetNext();
611 }
612
613 if ( menuForItem )
614 {
615 *menuForItem = result ? result->GetMenu() : (wxMenu *)NULL;
616 }
617
618 return result;
619 }
620
621 void wxMenuBar::EnableTop( size_t pos, bool flag )
622 {
623 wxMenuList::Node *node = m_menus.Item( pos );
624
625 wxCHECK_RET( node, wxT("menu not found") );
626
627 wxMenu* menu = node->GetData();
628
629 if (menu->m_owner)
630 gtk_widget_set_sensitive( menu->m_owner, flag );
631 }
632
633 wxString wxMenuBar::GetLabelTop( size_t pos ) const
634 {
635 wxMenuList::Node *node = m_menus.Item( pos );
636
637 wxCHECK_MSG( node, wxT("invalid"), wxT("menu not found") );
638
639 wxMenu* menu = node->GetData();
640
641 wxString label;
642 wxString text( menu->GetTitle() );
643 for ( const wxChar *pc = text.c_str(); *pc; pc++ )
644 {
645 if ( *pc == wxT('_') )
646 {
647 // '_' is the escape character for GTK+
648 continue;
649 }
650
651 // don't remove ampersands '&' since if we have them in the menu title
652 // it means that they were doubled to indicate "&" instead of accelerator
653
654 label += *pc;
655 }
656
657 return label;
658 }
659
660 void wxMenuBar::SetLabelTop( size_t pos, const wxString& label )
661 {
662 wxMenuList::Node *node = m_menus.Item( pos );
663
664 wxCHECK_RET( node, wxT("menu not found") );
665
666 wxMenu* menu = node->GetData();
667
668 wxString str( wxReplaceUnderscore( label ) );
669
670 menu->SetTitle( str );
671
672 if (menu->m_owner)
673 {
674 GtkLabel *label = GTK_LABEL( GTK_BIN(menu->m_owner)->child );
675
676 /* set new text */
677 gtk_label_set( label, wxGTK_CONV( str ) );
678
679 /* reparse key accel */
680 (void)gtk_label_parse_uline (GTK_LABEL(label), wxGTK_CONV( str ) );
681 gtk_accel_label_refetch( GTK_ACCEL_LABEL(label) );
682 }
683
684 }
685
686 //-----------------------------------------------------------------------------
687 // "activate"
688 //-----------------------------------------------------------------------------
689
690 static void gtk_menu_clicked_callback( GtkWidget *widget, wxMenu *menu )
691 {
692 if (g_isIdle)
693 wxapp_install_idle_handler();
694
695 int id = menu->FindMenuIdByMenuItem(widget);
696
697 /* should find it for normal (not popup) menu */
698 wxASSERT_MSG( (id != -1) || (menu->GetInvokingWindow() != NULL),
699 _T("menu item not found in gtk_menu_clicked_callback") );
700
701 if (!menu->IsEnabled(id))
702 return;
703
704 wxMenuItem* item = menu->FindChildItem( id );
705 wxCHECK_RET( item, wxT("error in menu item callback") );
706
707 if (item->IsCheckable())
708 {
709 bool isReallyChecked = item->IsChecked(),
710 isInternallyChecked = item->wxMenuItemBase::IsChecked();
711
712 // ensure that the internal state is always consistent with what is
713 // shown on the screen
714 item->wxMenuItemBase::Check(isReallyChecked);
715
716 // we must not report the events for the radio button going up nor the
717 // events resulting from the calls to wxMenuItem::Check()
718 if ( (item->GetKind() == wxITEM_RADIO && !isReallyChecked) ||
719 (isInternallyChecked == isReallyChecked) )
720 {
721 return;
722 }
723 }
724
725
726 // Is this menu on a menubar? (possibly nested)
727 wxFrame* frame = NULL;
728 wxMenu* pm = menu;
729 while ( pm && !frame )
730 {
731 if ( pm->IsAttached() )
732 frame = pm->GetMenuBar()->GetFrame();
733 pm = pm->GetParent();
734 }
735
736 if (frame)
737 {
738 // If it is attached then let the frame send the event.
739 // Don't call frame->ProcessCommand(id) because it toggles
740 // checkable items and we've already done that above.
741 wxCommandEvent commandEvent(wxEVT_COMMAND_MENU_SELECTED, id);
742 commandEvent.SetEventObject(frame);
743 if (item->IsCheckable())
744 commandEvent.SetInt(item->IsChecked());
745
746 frame->GetEventHandler()->ProcessEvent(commandEvent);
747 }
748 else
749 {
750 // otherwise let the menu have it
751 menu->SendEvent(id, item->IsCheckable() ? item->IsChecked() : -1);
752 }
753 }
754
755 //-----------------------------------------------------------------------------
756 // "select"
757 //-----------------------------------------------------------------------------
758
759 static void gtk_menu_hilight_callback( GtkWidget *widget, wxMenu *menu )
760 {
761 if (g_isIdle) wxapp_install_idle_handler();
762
763 int id = menu->FindMenuIdByMenuItem(widget);
764
765 wxASSERT( id != -1 ); // should find it!
766
767 if (!menu->IsEnabled(id))
768 return;
769
770 wxMenuEvent event( wxEVT_MENU_HIGHLIGHT, id );
771 event.SetEventObject( menu );
772
773 wxEvtHandler* handler = menu->GetEventHandler();
774 if (handler && handler->ProcessEvent(event))
775 return;
776
777 wxWindow *win = menu->GetInvokingWindow();
778 if (win) win->GetEventHandler()->ProcessEvent( event );
779 }
780
781 //-----------------------------------------------------------------------------
782 // "deselect"
783 //-----------------------------------------------------------------------------
784
785 static void gtk_menu_nolight_callback( GtkWidget *widget, wxMenu *menu )
786 {
787 if (g_isIdle) wxapp_install_idle_handler();
788
789 int id = menu->FindMenuIdByMenuItem(widget);
790
791 wxASSERT( id != -1 ); // should find it!
792
793 if (!menu->IsEnabled(id))
794 return;
795
796 wxMenuEvent event( wxEVT_MENU_HIGHLIGHT, -1 );
797 event.SetEventObject( menu );
798
799 wxEvtHandler* handler = menu->GetEventHandler();
800 if (handler && handler->ProcessEvent(event))
801 return;
802
803 wxWindow *win = menu->GetInvokingWindow();
804 if (win)
805 win->GetEventHandler()->ProcessEvent( event );
806 }
807
808 //-----------------------------------------------------------------------------
809 // wxMenuItem
810 //-----------------------------------------------------------------------------
811
812 IMPLEMENT_DYNAMIC_CLASS(wxMenuItem, wxObject)
813
814 wxMenuItem *wxMenuItemBase::New(wxMenu *parentMenu,
815 int id,
816 const wxString& name,
817 const wxString& help,
818 wxItemKind kind,
819 wxMenu *subMenu)
820 {
821 return new wxMenuItem(parentMenu, id, name, help, kind, subMenu);
822 }
823
824 wxMenuItem::wxMenuItem(wxMenu *parentMenu,
825 int id,
826 const wxString& text,
827 const wxString& help,
828 wxItemKind kind,
829 wxMenu *subMenu)
830 : wxMenuItemBase(parentMenu, id, text, help, kind, subMenu)
831 {
832 Init(text);
833 }
834
835 wxMenuItem::wxMenuItem(wxMenu *parentMenu,
836 int id,
837 const wxString& text,
838 const wxString& help,
839 bool isCheckable,
840 wxMenu *subMenu)
841 : wxMenuItemBase(parentMenu, id, text, help,
842 isCheckable ? wxITEM_CHECK : wxITEM_NORMAL, subMenu)
843 {
844 Init(text);
845 }
846
847 void wxMenuItem::Init(const wxString& text)
848 {
849 m_labelWidget = (GtkWidget *) NULL;
850 m_menuItem = (GtkWidget *) NULL;
851
852 DoSetText(text);
853 }
854
855 wxMenuItem::~wxMenuItem()
856 {
857 // don't delete menu items, the menus take care of that
858 }
859
860 // return the menu item text without any menu accels
861 /* static */
862 wxString wxMenuItemBase::GetLabelFromText(const wxString& text)
863 {
864 wxString label;
865
866 for ( const wxChar *pc = text.c_str(); *pc; pc++ )
867 {
868 if ( *pc == wxT('_') )
869 {
870 // GTK 1.2 escapes "xxx_xxx" to "xxx__xxx"
871 pc++;
872 label += *pc;
873 continue;
874 }
875
876 #if GTK_CHECK_VERSION(2, 0, 0)
877 if ( *pc == wxT('\\') )
878 {
879 // GTK 2.0 escapes "xxx/xxx" to "xxx\/xxx"
880 pc++;
881 label += *pc;
882 continue;
883 }
884 #endif
885
886 if ( (*pc == wxT('&')) && (*(pc+1) != wxT('&')) )
887 {
888 // wxMSW escapes "&"
889 // "&" is doubled to indicate "&" instead of accelerator
890 continue;
891 }
892
893 label += *pc;
894 }
895
896 // wxPrintf( L"text %s label %s\n", text.c_str(), label.c_str() );
897
898 return label;
899 }
900
901 void wxMenuItem::SetText( const wxString& str )
902 {
903 // Some optimization to avoid flicker
904 wxString oldLabel = m_text;
905 oldLabel = wxStripMenuCodes(oldLabel.BeforeFirst('\t'));
906 oldLabel.Replace(wxT("_"), wxT(""));
907 wxString label1 = wxStripMenuCodes(str.BeforeFirst('\t'));
908 if (oldLabel == label1)
909 return;
910
911 DoSetText(str);
912
913 if (m_menuItem)
914 {
915 GtkLabel *label;
916 if (m_labelWidget)
917 label = (GtkLabel*) m_labelWidget;
918 else
919 label = GTK_LABEL( GTK_BIN(m_menuItem)->child );
920
921 #if GTK_CHECK_VERSION(2, 0, 0)
922 // We have to imitate item_factory_unescape_label here
923 wxString tmp;
924 for (size_t n = 0; n < m_text.Len(); n++)
925 {
926 if (m_text[n] != wxT('\\'))
927 tmp += m_text[n];
928 }
929
930 gtk_label_set_text_with_mnemonic( GTK_LABEL(label), wxGTK_CONV(tmp) );
931 #else
932 // set new text
933 gtk_label_set( label, wxGTK_CONV( m_text ) );
934
935 // reparse key accel
936 (void)gtk_label_parse_uline (GTK_LABEL(label), wxGTK_CONV(m_text) );
937 gtk_accel_label_refetch( GTK_ACCEL_LABEL(label) );
938 #endif
939 }
940 }
941
942 // it's valid for this function to be called even if m_menuItem == NULL
943 void wxMenuItem::DoSetText( const wxString& str )
944 {
945 // '\t' is the deliminator indicating a hot key
946 m_text.Empty();
947 const wxChar *pc = str;
948 while ( (*pc != wxT('\0')) && (*pc != wxT('\t')) )
949 {
950 if ((*pc == wxT('&')) && (*(pc+1) == wxT('&')))
951 {
952 // "&" is doubled to indicate "&" instead of accelerator
953 ++pc;
954 m_text << wxT('&');
955 }
956 else if (*pc == wxT('&'))
957 {
958 m_text << wxT('_');
959 }
960 #if GTK_CHECK_VERSION(2, 0, 0)
961 else if ( *pc == wxT('_') ) // escape underscores
962 {
963 // m_text << wxT("__"); doesn't work
964 m_text << wxT("__");
965 }
966 else if (*pc == wxT('/')) // we have to escape slashes
967 {
968 m_text << wxT("\\/");
969 }
970 else if (*pc == wxT('\\')) // we have to double backslashes
971 {
972 m_text << wxT("\\\\");
973 }
974 #else
975 else if ( *pc == wxT('_') ) // escape underscores
976 {
977 m_text << wxT("__");
978 }
979 else if (*pc == wxT('/')) /* we have to filter out slashes ... */
980 {
981 m_text << wxT('\\'); /* ... and replace them with back slashes */
982 }
983 #endif
984 else {
985 m_text << *pc;
986 }
987 ++pc;
988 }
989
990 // wxPrintf( L"str %s m_text %s\n", str.c_str(), m_text.c_str() );
991
992 m_hotKey = wxT("");
993
994 if(*pc == wxT('\t'))
995 {
996 pc++;
997 m_hotKey = pc;
998 }
999 }
1000
1001 #if wxUSE_ACCEL
1002
1003 wxAcceleratorEntry *wxMenuItem::GetAccel() const
1004 {
1005 if ( !GetHotKey() )
1006 {
1007 // nothing
1008 return (wxAcceleratorEntry *)NULL;
1009 }
1010
1011 // as wxGetAccelFromString() looks for TAB, insert a dummy one here
1012 wxString label;
1013 label << wxT('\t') << GetHotKey();
1014
1015 return wxGetAccelFromString(label);
1016 }
1017
1018 #endif // wxUSE_ACCEL
1019
1020 void wxMenuItem::Check( bool check )
1021 {
1022 wxCHECK_RET( m_menuItem, wxT("invalid menu item") );
1023
1024 if (check == m_isChecked)
1025 return;
1026
1027 wxMenuItemBase::Check( check );
1028
1029 switch ( GetKind() )
1030 {
1031 case wxITEM_CHECK:
1032 case wxITEM_RADIO:
1033 gtk_check_menu_item_set_state( (GtkCheckMenuItem*)m_menuItem, (gint)check );
1034 break;
1035
1036 default:
1037 wxFAIL_MSG( _T("can't check this item") );
1038 }
1039 }
1040
1041 void wxMenuItem::Enable( bool enable )
1042 {
1043 wxCHECK_RET( m_menuItem, wxT("invalid menu item") );
1044
1045 gtk_widget_set_sensitive( m_menuItem, enable );
1046 wxMenuItemBase::Enable( enable );
1047 }
1048
1049 bool wxMenuItem::IsChecked() const
1050 {
1051 wxCHECK_MSG( m_menuItem, FALSE, wxT("invalid menu item") );
1052
1053 wxCHECK_MSG( IsCheckable(), FALSE,
1054 wxT("can't get state of uncheckable item!") );
1055
1056 return ((GtkCheckMenuItem*)m_menuItem)->active != 0;
1057 }
1058
1059 wxString wxMenuItem::GetFactoryPath() const
1060 {
1061 // In order to get the pointer to the item we need the item
1062 // text _without_ underscores in GTK 1.2
1063 wxString path( wxT("<main>/") );
1064
1065 for ( const wxChar *pc = m_text.c_str(); *pc; pc++ )
1066 {
1067 if ( *pc == wxT('_') )
1068 {
1069 #ifdef __WXGTK20__
1070 pc++;
1071 #else
1072 // remove '_' unconditionally
1073 continue;
1074 #endif
1075 }
1076
1077 // don't remove ampersands '&' since if we have them in the menu item title
1078 // it means that they were doubled to indicate "&" instead of accelerator
1079
1080 path += *pc;
1081 }
1082
1083 return path;
1084 }
1085
1086 //-----------------------------------------------------------------------------
1087 // wxMenu
1088 //-----------------------------------------------------------------------------
1089
1090 IMPLEMENT_DYNAMIC_CLASS(wxMenu,wxEvtHandler)
1091
1092 void wxMenu::Init()
1093 {
1094 m_accel = gtk_accel_group_new();
1095 m_factory = gtk_item_factory_new( GTK_TYPE_MENU, "<main>", m_accel );
1096 m_menu = gtk_item_factory_get_widget( m_factory, "<main>" );
1097
1098 m_owner = (GtkWidget*) NULL;
1099
1100 // Tearoffs are entries, just like separators. So if we want this
1101 // menu to be a tear-off one, we just append a tearoff entry
1102 // immediately.
1103 if(m_style & wxMENU_TEAROFF)
1104 {
1105 GtkItemFactoryEntry entry;
1106 entry.path = (char *)"/tearoff";
1107 entry.callback = (GtkItemFactoryCallback) NULL;
1108 entry.callback_action = 0;
1109 entry.item_type = (char *)"<Tearoff>";
1110 entry.accelerator = (gchar*) NULL;
1111 gtk_item_factory_create_item( m_factory, &entry, (gpointer) this, 2 ); // what is 2 ?
1112 //GtkWidget *menuItem = gtk_item_factory_get_widget( m_factory, "<main>/tearoff" );
1113 }
1114
1115 // append the title as the very first entry if we have it
1116 if ( !!m_title )
1117 {
1118 Append(-2, m_title);
1119 AppendSeparator();
1120 }
1121 }
1122
1123 wxMenu::~wxMenu()
1124 {
1125 m_items.Clear();
1126
1127 if ( GTK_IS_WIDGET( m_menu ))
1128 gtk_widget_destroy( m_menu );
1129
1130 gtk_object_unref( GTK_OBJECT(m_factory) );
1131 }
1132
1133 bool wxMenu::GtkAppend(wxMenuItem *mitem)
1134 {
1135 GtkWidget *menuItem;
1136
1137 #if defined(USE_MENU_BITMAPS) || !GTK_CHECK_VERSION(1, 2, 0)
1138 bool appended = FALSE;
1139 #endif
1140
1141 // does this item terminate the current radio group?
1142 bool endOfRadioGroup = TRUE;
1143
1144 if ( mitem->IsSeparator() )
1145 {
1146 GtkItemFactoryEntry entry;
1147 entry.path = (char *)"/sep";
1148 entry.callback = (GtkItemFactoryCallback) NULL;
1149 entry.callback_action = 0;
1150 entry.item_type = (char *)"<Separator>";
1151 entry.accelerator = (gchar*) NULL;
1152
1153 gtk_item_factory_create_item( m_factory, &entry, (gpointer) this, 2 ); // what is 2 ?
1154
1155 // this will be wrong for more than one separator. do we care?
1156 menuItem = gtk_item_factory_get_widget( m_factory, "<main>/sep" );
1157
1158 // we might have a separator inside a radio group
1159 endOfRadioGroup = FALSE;
1160 }
1161 else if ( mitem->IsSubMenu() )
1162 {
1163 // text has "_" instead of "&" after mitem->SetText()
1164 wxString text( mitem->GetText() );
1165
1166 // local buffer in multibyte form
1167 char buf[200];
1168 strcpy( buf, "/" );
1169 strcat( buf, wxGTK_CONV( text ) );
1170
1171 GtkItemFactoryEntry entry;
1172 entry.path = buf;
1173 entry.callback = (GtkItemFactoryCallback) 0;
1174 entry.callback_action = 0;
1175 entry.item_type = (char *)"<Branch>";
1176 entry.accelerator = (gchar*) NULL;
1177
1178 gtk_item_factory_create_item( m_factory, &entry, (gpointer) this, 2 ); // what is 2 ?
1179
1180 wxString path( mitem->GetFactoryPath() );
1181 menuItem = gtk_item_factory_get_item( m_factory, wxGTK_CONV( path ) );
1182
1183 gtk_menu_item_set_submenu( GTK_MENU_ITEM(menuItem), mitem->GetSubMenu()->m_menu );
1184
1185 // if adding a submenu to a menu already existing in the menu bar, we
1186 // must set invoking window to allow processing events from this
1187 // submenu
1188 if ( m_invokingWindow )
1189 wxMenubarSetInvokingWindow(mitem->GetSubMenu(), m_invokingWindow);
1190 }
1191 #ifdef USE_MENU_BITMAPS
1192 else if (mitem->GetBitmap().Ok()) // An item with bitmap
1193 {
1194 wxString text( mitem->GetText() );
1195 const wxBitmap *bitmap = &mitem->GetBitmap();
1196
1197 menuItem = gtk_pixmap_menu_item_new ();
1198 GtkWidget *label = gtk_accel_label_new ( wxGTK_CONV( text ) );
1199 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
1200 gtk_container_add (GTK_CONTAINER (menuItem), label);
1201 gtk_accel_label_set_accel_widget (GTK_ACCEL_LABEL (label), menuItem);
1202 guint accel_key;
1203 GdkModifierType accel_mods;
1204
1205 // accelerator for the item, as specified by its label
1206 // (ex. Ctrl+O for open)
1207 gtk_accelerator_parse(GetHotKey(*mitem).c_str(),
1208 &accel_key, &accel_mods);
1209 if (accel_key != GDK_VoidSymbol)
1210 {
1211 gtk_widget_add_accelerator (menuItem,
1212 "activate_item",
1213 gtk_menu_get_accel_group(
1214 GTK_MENU(m_menu)),
1215 accel_key, accel_mods,
1216 GTK_ACCEL_VISIBLE);
1217 }
1218
1219 // accelerator for the underlined char (ex ALT+F for the File menu)
1220 accel_key = gtk_label_parse_uline (GTK_LABEL(label), wxGTK_CONV( text ) );
1221 if (accel_key != GDK_VoidSymbol)
1222 {
1223 gtk_widget_add_accelerator (menuItem,
1224 "activate_item",
1225 gtk_menu_ensure_uline_accel_group (
1226 GTK_MENU (m_menu)),
1227 accel_key, 0,
1228 GTK_ACCEL_LOCKED);
1229 }
1230
1231 gtk_widget_show (label);
1232
1233 mitem->SetLabelWidget(label);
1234
1235 GtkWidget* pixmap = gtk_pixmap_new( bitmap->GetPixmap(), bitmap->GetMask() ? bitmap->GetMask()->GetBitmap() : (GdkBitmap* )NULL);
1236 gtk_widget_show(pixmap);
1237 gtk_pixmap_menu_item_set_pixmap(GTK_PIXMAP_MENU_ITEM( menuItem ), pixmap);
1238
1239 gtk_signal_connect( GTK_OBJECT(menuItem), "activate",
1240 GTK_SIGNAL_FUNC(gtk_menu_clicked_callback),
1241 (gpointer)this );
1242
1243 gtk_menu_append( GTK_MENU(m_menu), menuItem );
1244
1245 gtk_widget_show( menuItem );
1246
1247 appended = TRUE; // We've done this, don't do it again
1248 }
1249 #endif // USE_MENU_BITMAPS
1250 else // a normal item
1251 {
1252 // text has "_" instead of "&" after mitem->SetText() so don't use it
1253 wxString text( mitem->GetText() );
1254
1255 // buffers containing the menu item path and type in multibyte form
1256 char bufPath[256],
1257 bufType[256];
1258
1259 strcpy( bufPath, "/" );
1260 strncat( bufPath, wxGTK_CONV(text), WXSIZEOF(bufPath) - 2 );
1261 bufPath[WXSIZEOF(bufPath) - 1] = '\0';
1262
1263 GtkItemFactoryEntry entry;
1264 entry.path = bufPath;
1265 entry.callback = (GtkItemFactoryCallback) gtk_menu_clicked_callback;
1266 entry.callback_action = 0;
1267
1268 wxString pathRadio;
1269 const char *item_type;
1270 switch ( mitem->GetKind() )
1271 {
1272 case wxITEM_CHECK:
1273 item_type = "<CheckItem>";
1274 break;
1275
1276 case wxITEM_RADIO:
1277 if ( m_pathLastRadio.empty() )
1278 {
1279 // start of a new radio group
1280 item_type = "<RadioItem>";
1281 wxString tmp( wxGTK_CONV_BACK( bufPath ) );
1282 tmp.Remove(0,1);
1283 m_pathLastRadio = tmp;
1284 }
1285 else // continue the radio group
1286 {
1287 pathRadio = m_pathLastRadio;
1288 pathRadio.Replace(wxT("_"), wxT(""));
1289 pathRadio.Prepend(wxT("<main>/"));
1290
1291 strncpy(bufType, wxGTK_CONV(pathRadio), WXSIZEOF(bufType));
1292 bufType[WXSIZEOF(bufType) - 1] = '\0';
1293 item_type = bufType;
1294 }
1295
1296 // continue the existing radio group, if any
1297 endOfRadioGroup = FALSE;
1298 break;
1299
1300 default:
1301 wxFAIL_MSG( _T("unexpected menu item kind") );
1302 // fall through
1303
1304 case wxITEM_NORMAL:
1305 item_type = "<Item>";
1306 break;
1307 }
1308
1309 entry.item_type = (char *)item_type; // cast needed for GTK+
1310 entry.accelerator = (gchar*) NULL;
1311
1312 #if wxUSE_ACCEL
1313 // due to an apparent bug in GTK+, we have to use a static buffer here -
1314 // otherwise GTK+ 1.2.2 manages to override the memory we pass to it
1315 // somehow! (VZ)
1316 char s_accel[50]; // should be big enough, we check for overruns
1317 wxString tmp( GetHotKey(*mitem) );
1318 strncpy(s_accel, wxGTK_CONV( tmp ), WXSIZEOF(s_accel));
1319 s_accel[WXSIZEOF(s_accel) - 1] = '\0';
1320 entry.accelerator = s_accel;
1321 #else // !wxUSE_ACCEL
1322 entry.accelerator = (char*) NULL;
1323 #endif // wxUSE_ACCEL/!wxUSE_ACCEL
1324
1325 gtk_item_factory_create_item( m_factory, &entry, (gpointer) this, 2 ); /* what is 2 ? */
1326
1327 wxString path( mitem->GetFactoryPath() );
1328 menuItem = gtk_item_factory_get_widget( m_factory, wxGTK_CONV( path ) );
1329
1330 if (!menuItem)
1331 wxLogError( wxT("Wrong menu path: %s\n"), path.c_str() );
1332 }
1333
1334 if ( !mitem->IsSeparator() )
1335 {
1336 wxASSERT_MSG( menuItem, wxT("invalid menuitem") );
1337
1338 gtk_signal_connect( GTK_OBJECT(menuItem), "select",
1339 GTK_SIGNAL_FUNC(gtk_menu_hilight_callback),
1340 (gpointer)this );
1341
1342 gtk_signal_connect( GTK_OBJECT(menuItem), "deselect",
1343 GTK_SIGNAL_FUNC(gtk_menu_nolight_callback),
1344 (gpointer)this );
1345 }
1346
1347 mitem->SetMenuItem(menuItem);
1348
1349 if ( endOfRadioGroup )
1350 {
1351 m_pathLastRadio.clear();
1352 }
1353
1354 return TRUE;
1355 }
1356
1357 bool wxMenu::DoAppend(wxMenuItem *mitem)
1358 {
1359 return GtkAppend(mitem) && wxMenuBase::DoAppend(mitem);
1360 }
1361
1362 bool wxMenu::DoInsert(size_t pos, wxMenuItem *item)
1363 {
1364 if ( !wxMenuBase::DoInsert(pos, item) )
1365 return FALSE;
1366
1367 // GTK+ doesn't have a function to insert a menu using GtkItemFactory (as
1368 // of version 1.2.6), so we first append the item and then change its
1369 // index
1370 if ( !GtkAppend(item) )
1371 return FALSE;
1372
1373 if ( m_style & wxMENU_TEAROFF )
1374 {
1375 // change the position as the first item is the tear-off marker
1376 pos++;
1377 }
1378
1379 GtkMenuShell *menu_shell = GTK_MENU_SHELL(m_factory->widget);
1380 gpointer data = g_list_last(menu_shell->children)->data;
1381 menu_shell->children = g_list_remove(menu_shell->children, data);
1382 menu_shell->children = g_list_insert(menu_shell->children, data, pos);
1383
1384 return TRUE;
1385 }
1386
1387 wxMenuItem *wxMenu::DoRemove(wxMenuItem *item)
1388 {
1389 if ( !wxMenuBase::DoRemove(item) )
1390 return (wxMenuItem *)NULL;
1391
1392 // TODO: this code doesn't delete the item factory item and this seems
1393 // impossible as of GTK 1.2.6.
1394 gtk_widget_destroy( item->GetMenuItem() );
1395
1396 return item;
1397 }
1398
1399 int wxMenu::FindMenuIdByMenuItem( GtkWidget *menuItem ) const
1400 {
1401 wxMenuItemList::Node *node = m_items.GetFirst();
1402 while (node)
1403 {
1404 wxMenuItem *item = node->GetData();
1405 if (item->GetMenuItem() == menuItem)
1406 return item->GetId();
1407 node = node->GetNext();
1408 }
1409
1410 return wxNOT_FOUND;
1411 }
1412
1413 // ----------------------------------------------------------------------------
1414 // helpers
1415 // ----------------------------------------------------------------------------
1416
1417 #if GTK_CHECK_VERSION(1, 2, 0) && wxUSE_ACCEL
1418
1419 static wxString GetHotKey( const wxMenuItem& item )
1420 {
1421 wxString hotkey;
1422
1423 wxAcceleratorEntry *accel = item.GetAccel();
1424 if ( accel )
1425 {
1426 int flags = accel->GetFlags();
1427 if ( flags & wxACCEL_ALT )
1428 hotkey += wxT("<alt>");
1429 if ( flags & wxACCEL_CTRL )
1430 hotkey += wxT("<control>");
1431 if ( flags & wxACCEL_SHIFT )
1432 hotkey += wxT("<shift>");
1433
1434 int code = accel->GetKeyCode();
1435 switch ( code )
1436 {
1437 case WXK_F1:
1438 case WXK_F2:
1439 case WXK_F3:
1440 case WXK_F4:
1441 case WXK_F5:
1442 case WXK_F6:
1443 case WXK_F7:
1444 case WXK_F8:
1445 case WXK_F9:
1446 case WXK_F10:
1447 case WXK_F11:
1448 case WXK_F12:
1449 hotkey << wxT('F') << code - WXK_F1 + 1;
1450 break;
1451
1452 // TODO: we should use gdk_keyval_name() (a.k.a.
1453 // XKeysymToString) here as well as hardcoding the keysym
1454 // names this might be not portable
1455 case WXK_NUMPAD_INSERT:
1456 hotkey << wxT("KP_Insert" );
1457 break;
1458 case WXK_NUMPAD_DELETE:
1459 hotkey << wxT("KP_Delete" );
1460 break;
1461 case WXK_INSERT:
1462 hotkey << wxT("Insert" );
1463 break;
1464 case WXK_DELETE:
1465 hotkey << wxT("Delete" );
1466 break;
1467 case WXK_UP:
1468 hotkey << wxT("Up" );
1469 break;
1470 case WXK_DOWN:
1471 hotkey << wxT("Down" );
1472 break;
1473 case WXK_PAGEUP:
1474 hotkey << wxT("Prior" );
1475 break;
1476 case WXK_PAGEDOWN:
1477 hotkey << wxT("Next" );
1478 break;
1479 case WXK_LEFT:
1480 hotkey << wxT("Left" );
1481 break;
1482 case WXK_RIGHT:
1483 hotkey << wxT("Right" );
1484 break;
1485 case WXK_HOME:
1486 hotkey << wxT("Home" );
1487 break;
1488 case WXK_END:
1489 hotkey << wxT("End" );
1490 break;
1491 case WXK_RETURN:
1492 hotkey << wxT("Return" );
1493 break;
1494
1495 // if there are any other keys wxGetAccelFromString() may
1496 // return, we should process them here
1497
1498 default:
1499 if ( code < 127 )
1500 {
1501 wxString name = wxGTK_CONV_BACK( gdk_keyval_name((guint)code) );
1502 if ( name )
1503 {
1504 hotkey << name;
1505 break;
1506 }
1507 }
1508
1509 wxFAIL_MSG( wxT("unknown keyboard accel") );
1510 }
1511
1512 delete accel;
1513 }
1514
1515 return hotkey;
1516 }
1517
1518 #endif // wxUSE_ACCEL
1519
1520
1521 //-----------------------------------------------------------------------------
1522 // substitute for missing GtkPixmapMenuItem
1523 //-----------------------------------------------------------------------------
1524
1525 #ifdef USE_MENU_BITMAPS
1526
1527 /*
1528 * Copyright (C) 1998, 1999, 2000 Free Software Foundation
1529 * All rights reserved.
1530 *
1531 * This file is part of the Gnome Library.
1532 *
1533 * The Gnome Library is free software; you can redistribute it and/or
1534 * modify it under the terms of the GNU Library General Public License as
1535 * published by the Free Software Foundation; either version 2 of the
1536 * License, or (at your option) any later version.
1537 *
1538 * The Gnome Library is distributed in the hope that it will be useful,
1539 * but WITHOUT ANY WARRANTY; without even the implied warranty of
1540 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
1541 * Library General Public License for more details.
1542 *
1543 * You should have received a copy of the GNU Library General Public
1544 * License along with the Gnome Library; see the file COPYING.LIB. If not,
1545 * write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
1546 * Boston, MA 02111-1307, USA.
1547 */
1548 /*
1549 @NOTATION@
1550 */
1551
1552 /* Author: Dietmar Maurer <dm@vlsivie.tuwien.ac.at> */
1553
1554 #include <gtk/gtkaccellabel.h>
1555 #include <gtk/gtksignal.h>
1556 #include <gtk/gtkmenuitem.h>
1557 #include <gtk/gtkmenu.h>
1558 #include <gtk/gtkcontainer.h>
1559
1560 extern "C"
1561 {
1562
1563 static void gtk_pixmap_menu_item_class_init (GtkPixmapMenuItemClass *klass);
1564 static void gtk_pixmap_menu_item_init (GtkPixmapMenuItem *menu_item);
1565 static void gtk_pixmap_menu_item_draw (GtkWidget *widget,
1566 GdkRectangle *area);
1567 static gint gtk_pixmap_menu_item_expose (GtkWidget *widget,
1568 GdkEventExpose *event);
1569
1570 /* we must override the following functions */
1571
1572 static void gtk_pixmap_menu_item_map (GtkWidget *widget);
1573 static void gtk_pixmap_menu_item_size_allocate (GtkWidget *widget,
1574 GtkAllocation *allocation);
1575 static void gtk_pixmap_menu_item_forall (GtkContainer *container,
1576 gboolean include_internals,
1577 GtkCallback callback,
1578 gpointer callback_data);
1579 static void gtk_pixmap_menu_item_size_request (GtkWidget *widget,
1580 GtkRequisition *requisition);
1581 static void gtk_pixmap_menu_item_remove (GtkContainer *container,
1582 GtkWidget *child);
1583
1584 static void changed_have_pixmap_status (GtkPixmapMenuItem *menu_item);
1585
1586 static GtkMenuItemClass *parent_class = NULL;
1587
1588 }
1589
1590 #define BORDER_SPACING 3
1591 #define PMAP_WIDTH 20
1592
1593 GtkType
1594 gtk_pixmap_menu_item_get_type (void)
1595 {
1596 static GtkType pixmap_menu_item_type = 0;
1597
1598 if (!pixmap_menu_item_type)
1599 {
1600 GtkTypeInfo pixmap_menu_item_info =
1601 {
1602 (char *)"GtkPixmapMenuItem",
1603 sizeof (GtkPixmapMenuItem),
1604 sizeof (GtkPixmapMenuItemClass),
1605 (GtkClassInitFunc) gtk_pixmap_menu_item_class_init,
1606 (GtkObjectInitFunc) gtk_pixmap_menu_item_init,
1607 /* reserved_1 */ NULL,
1608 /* reserved_2 */ NULL,
1609 (GtkClassInitFunc) NULL,
1610 };
1611
1612 pixmap_menu_item_type = gtk_type_unique (gtk_menu_item_get_type (),
1613 &pixmap_menu_item_info);
1614 }
1615
1616 return pixmap_menu_item_type;
1617 }
1618
1619 /**
1620 * gtk_pixmap_menu_item_new
1621 *
1622 * Creates a new pixmap menu item. Use gtk_pixmap_menu_item_set_pixmap()
1623 * to set the pixmap wich is displayed at the left side.
1624 *
1625 * Returns:
1626 * &GtkWidget pointer to new menu item
1627 **/
1628
1629 GtkWidget*
1630 gtk_pixmap_menu_item_new (void)
1631 {
1632 return GTK_WIDGET (gtk_type_new (gtk_pixmap_menu_item_get_type ()));
1633 }
1634
1635 static void
1636 gtk_pixmap_menu_item_class_init (GtkPixmapMenuItemClass *klass)
1637 {
1638 GtkObjectClass *object_class;
1639 GtkWidgetClass *widget_class;
1640 GtkMenuItemClass *menu_item_class;
1641 GtkContainerClass *container_class;
1642
1643 object_class = (GtkObjectClass*) klass;
1644 widget_class = (GtkWidgetClass*) klass;
1645 menu_item_class = (GtkMenuItemClass*) klass;
1646 container_class = (GtkContainerClass*) klass;
1647
1648 parent_class = (GtkMenuItemClass*) gtk_type_class (gtk_menu_item_get_type ());
1649
1650 widget_class->draw = gtk_pixmap_menu_item_draw;
1651 widget_class->expose_event = gtk_pixmap_menu_item_expose;
1652 widget_class->map = gtk_pixmap_menu_item_map;
1653 widget_class->size_allocate = gtk_pixmap_menu_item_size_allocate;
1654 widget_class->size_request = gtk_pixmap_menu_item_size_request;
1655
1656 container_class->forall = gtk_pixmap_menu_item_forall;
1657 container_class->remove = gtk_pixmap_menu_item_remove;
1658
1659 klass->orig_toggle_size = menu_item_class->toggle_size;
1660 klass->have_pixmap_count = 0;
1661 }
1662
1663 static void
1664 gtk_pixmap_menu_item_init (GtkPixmapMenuItem *menu_item)
1665 {
1666 GtkMenuItem *mi;
1667
1668 mi = GTK_MENU_ITEM (menu_item);
1669
1670 menu_item->pixmap = NULL;
1671 }
1672
1673 static void
1674 gtk_pixmap_menu_item_draw (GtkWidget *widget,
1675 GdkRectangle *area)
1676 {
1677 g_return_if_fail (widget != NULL);
1678 g_return_if_fail (GTK_IS_PIXMAP_MENU_ITEM (widget));
1679 g_return_if_fail (area != NULL);
1680
1681 if (GTK_WIDGET_CLASS (parent_class)->draw)
1682 (* GTK_WIDGET_CLASS (parent_class)->draw) (widget, area);
1683
1684 if (GTK_WIDGET_DRAWABLE (widget) &&
1685 GTK_PIXMAP_MENU_ITEM(widget)->pixmap) {
1686 gtk_widget_draw(GTK_WIDGET(GTK_PIXMAP_MENU_ITEM(widget)->pixmap),NULL);
1687 }
1688 }
1689
1690 static gint
1691 gtk_pixmap_menu_item_expose (GtkWidget *widget,
1692 GdkEventExpose *event)
1693 {
1694 g_return_val_if_fail (widget != NULL, FALSE);
1695 g_return_val_if_fail (GTK_IS_PIXMAP_MENU_ITEM (widget), FALSE);
1696 g_return_val_if_fail (event != NULL, FALSE);
1697
1698 if (GTK_WIDGET_CLASS (parent_class)->expose_event)
1699 (* GTK_WIDGET_CLASS (parent_class)->expose_event) (widget, event);
1700
1701 if (GTK_WIDGET_DRAWABLE (widget) &&
1702 GTK_PIXMAP_MENU_ITEM(widget)->pixmap) {
1703 gtk_widget_draw(GTK_WIDGET(GTK_PIXMAP_MENU_ITEM(widget)->pixmap),NULL);
1704 }
1705
1706 return FALSE;
1707 }
1708
1709 /**
1710 * gtk_pixmap_menu_item_set_pixmap
1711 * @menu_item: Pointer to the pixmap menu item
1712 * @pixmap: Pointer to a pixmap widget
1713 *
1714 * Set the pixmap of the menu item.
1715 *
1716 **/
1717
1718 void
1719 gtk_pixmap_menu_item_set_pixmap (GtkPixmapMenuItem *menu_item,
1720 GtkWidget *pixmap)
1721 {
1722 g_return_if_fail (menu_item != NULL);
1723 g_return_if_fail (pixmap != NULL);
1724 g_return_if_fail (GTK_IS_PIXMAP_MENU_ITEM (menu_item));
1725 g_return_if_fail (GTK_IS_WIDGET (pixmap));
1726 g_return_if_fail (menu_item->pixmap == NULL);
1727
1728 gtk_widget_set_parent (pixmap, GTK_WIDGET (menu_item));
1729 menu_item->pixmap = pixmap;
1730
1731 if (GTK_WIDGET_REALIZED (pixmap->parent) &&
1732 !GTK_WIDGET_REALIZED (pixmap))
1733 gtk_widget_realize (pixmap);
1734
1735 if (GTK_WIDGET_VISIBLE (pixmap->parent)) {
1736 if (GTK_WIDGET_MAPPED (pixmap->parent) &&
1737 GTK_WIDGET_VISIBLE(pixmap) &&
1738 !GTK_WIDGET_MAPPED (pixmap))
1739 gtk_widget_map (pixmap);
1740 }
1741
1742 changed_have_pixmap_status(menu_item);
1743
1744 if (GTK_WIDGET_VISIBLE (pixmap) && GTK_WIDGET_VISIBLE (menu_item))
1745 gtk_widget_queue_resize (pixmap);
1746 }
1747
1748 static void
1749 gtk_pixmap_menu_item_map (GtkWidget *widget)
1750 {
1751 GtkPixmapMenuItem *menu_item;
1752
1753 g_return_if_fail (widget != NULL);
1754 g_return_if_fail (GTK_IS_PIXMAP_MENU_ITEM (widget));
1755
1756 menu_item = GTK_PIXMAP_MENU_ITEM(widget);
1757
1758 GTK_WIDGET_CLASS(parent_class)->map(widget);
1759
1760 if (menu_item->pixmap &&
1761 GTK_WIDGET_VISIBLE (menu_item->pixmap) &&
1762 !GTK_WIDGET_MAPPED (menu_item->pixmap))
1763 gtk_widget_map (menu_item->pixmap);
1764 }
1765
1766 static void
1767 gtk_pixmap_menu_item_size_allocate (GtkWidget *widget,
1768 GtkAllocation *allocation)
1769 {
1770 GtkPixmapMenuItem *pmenu_item;
1771
1772 pmenu_item = GTK_PIXMAP_MENU_ITEM(widget);
1773
1774 if (pmenu_item->pixmap && GTK_WIDGET_VISIBLE(pmenu_item))
1775 {
1776 GtkAllocation child_allocation;
1777 int border_width;
1778
1779 border_width = GTK_CONTAINER (widget)->border_width;
1780
1781 child_allocation.width = pmenu_item->pixmap->requisition.width;
1782 child_allocation.height = pmenu_item->pixmap->requisition.height;
1783 child_allocation.x = border_width + BORDER_SPACING;
1784 child_allocation.y = (border_width + BORDER_SPACING
1785 + (((allocation->height - child_allocation.height) - child_allocation.x)
1786 / 2)); /* center pixmaps vertically */
1787 gtk_widget_size_allocate (pmenu_item->pixmap, &child_allocation);
1788 }
1789
1790 if (GTK_WIDGET_CLASS (parent_class)->size_allocate)
1791 GTK_WIDGET_CLASS(parent_class)->size_allocate (widget, allocation);
1792 }
1793
1794 static void
1795 gtk_pixmap_menu_item_forall (GtkContainer *container,
1796 gboolean include_internals,
1797 GtkCallback callback,
1798 gpointer callback_data)
1799 {
1800 GtkPixmapMenuItem *menu_item;
1801
1802 g_return_if_fail (container != NULL);
1803 g_return_if_fail (GTK_IS_PIXMAP_MENU_ITEM (container));
1804 g_return_if_fail (callback != NULL);
1805
1806 menu_item = GTK_PIXMAP_MENU_ITEM (container);
1807
1808 if (menu_item->pixmap)
1809 (* callback) (menu_item->pixmap, callback_data);
1810
1811 GTK_CONTAINER_CLASS(parent_class)->forall(container,include_internals,
1812 callback,callback_data);
1813 }
1814
1815 static void
1816 gtk_pixmap_menu_item_size_request (GtkWidget *widget,
1817 GtkRequisition *requisition)
1818 {
1819 GtkPixmapMenuItem *menu_item;
1820 GtkRequisition req = {0, 0};
1821
1822 g_return_if_fail (widget != NULL);
1823 g_return_if_fail (GTK_IS_MENU_ITEM (widget));
1824 g_return_if_fail (requisition != NULL);
1825
1826 GTK_WIDGET_CLASS(parent_class)->size_request(widget,requisition);
1827
1828 menu_item = GTK_PIXMAP_MENU_ITEM (widget);
1829
1830 if (menu_item->pixmap)
1831 gtk_widget_size_request(menu_item->pixmap, &req);
1832
1833 requisition->height = MAX(req.height + GTK_CONTAINER(widget)->border_width + BORDER_SPACING, (unsigned int) requisition->height);
1834 requisition->width += (req.width + GTK_CONTAINER(widget)->border_width + BORDER_SPACING);
1835 }
1836
1837 static void
1838 gtk_pixmap_menu_item_remove (GtkContainer *container,
1839 GtkWidget *child)
1840 {
1841 GtkBin *bin;
1842 gboolean widget_was_visible;
1843
1844 g_return_if_fail (container != NULL);
1845 g_return_if_fail (GTK_IS_PIXMAP_MENU_ITEM (container));
1846 g_return_if_fail (child != NULL);
1847 g_return_if_fail (GTK_IS_WIDGET (child));
1848
1849 bin = GTK_BIN (container);
1850 g_return_if_fail ((bin->child == child ||
1851 (GTK_PIXMAP_MENU_ITEM(container)->pixmap == child)));
1852
1853 widget_was_visible = GTK_WIDGET_VISIBLE (child);
1854
1855 gtk_widget_unparent (child);
1856 if (bin->child == child)
1857 bin->child = NULL;
1858 else {
1859 GTK_PIXMAP_MENU_ITEM(container)->pixmap = NULL;
1860 changed_have_pixmap_status(GTK_PIXMAP_MENU_ITEM(container));
1861 }
1862
1863 if (widget_was_visible)
1864 gtk_widget_queue_resize (GTK_WIDGET (container));
1865 }
1866
1867
1868 /* important to only call this if there was actually a _change_ in pixmap == NULL */
1869 static void
1870 changed_have_pixmap_status (GtkPixmapMenuItem *menu_item)
1871 {
1872 if (menu_item->pixmap != NULL) {
1873 GTK_PIXMAP_MENU_ITEM_GET_CLASS(menu_item)->have_pixmap_count += 1;
1874
1875 if (GTK_PIXMAP_MENU_ITEM_GET_CLASS(menu_item)->have_pixmap_count == 1) {
1876 /* Install pixmap toggle size */
1877 GTK_MENU_ITEM_GET_CLASS(menu_item)->toggle_size = MAX(GTK_PIXMAP_MENU_ITEM_GET_CLASS(menu_item)->orig_toggle_size, PMAP_WIDTH);
1878 }
1879 } else {
1880 GTK_PIXMAP_MENU_ITEM_GET_CLASS(menu_item)->have_pixmap_count -= 1;
1881
1882 if (GTK_PIXMAP_MENU_ITEM_GET_CLASS(menu_item)->have_pixmap_count == 0) {
1883 /* Install normal toggle size */
1884 GTK_MENU_ITEM_GET_CLASS(menu_item)->toggle_size = GTK_PIXMAP_MENU_ITEM_GET_CLASS(menu_item)->orig_toggle_size;
1885 }
1886 }
1887
1888 /* Note that we actually need to do this for _all_ GtkPixmapMenuItem
1889 whenever the klass->toggle_size changes; but by doing it anytime
1890 this function is called, we get the same effect, just because of
1891 how the preferences option to show pixmaps works. Bogus, broken.
1892 */
1893 if (GTK_WIDGET_VISIBLE(GTK_WIDGET(menu_item)))
1894 gtk_widget_queue_resize(GTK_WIDGET(menu_item));
1895 }
1896
1897 #endif // USE_MENU_BITMAPS
1898
wxWidgets (Impactor)