]> git.saurik.com Git - wxWidgets.git/blob - src/gtk/menu.cpp
these files are not used any more
[wxWidgets.git] / src / gtk / 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/menu.h"
16 #include "wx/log.h"
17 #include "wx/intl.h"
18 #include "wx/app.h"
19
20 #include "gdk/gdk.h"
21 #include "gtk/gtk.h"
22
23 //-----------------------------------------------------------------------------
24 // idle system
25 //-----------------------------------------------------------------------------
26
27 extern void wxapp_install_idle_handler();
28 extern bool g_isIdle;
29
30 //-----------------------------------------------------------------------------
31 // wxMenuBar
32 //-----------------------------------------------------------------------------
33
34 IMPLEMENT_DYNAMIC_CLASS(wxMenuBar,wxWindow)
35
36 wxMenuBar::wxMenuBar( long style )
37 {
38 /* the parent window is known after wxFrame::SetMenu() */
39 m_needParent = FALSE;
40
41 PreCreation( (wxWindow *) NULL, -1, wxDefaultPosition, wxDefaultSize, style, "menu" );
42
43 m_menus.DeleteContents( TRUE );
44
45 /* GTK 1.2.0 doesn't have gtk_item_factory_get_item(), but GTK 1.2.1 has. */
46 #if (GTK_MINOR_VERSION > 0) && (GTK_MICRO_VERSION > 0)
47 m_accel = gtk_accel_group_new();
48 m_factory = gtk_item_factory_new( GTK_TYPE_MENU_BAR, "<main>", m_accel );
49 m_menubar = gtk_item_factory_get_widget( m_factory, "<main>" );
50 #else
51 m_menubar = gtk_menu_bar_new();
52 #endif
53
54 if (style & wxMB_DOCKABLE)
55 {
56 m_widget = gtk_handle_box_new();
57 gtk_container_add( GTK_CONTAINER(m_widget), GTK_WIDGET(m_menubar) );
58 gtk_widget_show( GTK_WIDGET(m_menubar) );
59 }
60 else
61 {
62 m_widget = GTK_WIDGET(m_menubar);
63 }
64
65 PostCreation();
66
67 Show( TRUE );
68 }
69
70 wxMenuBar::wxMenuBar()
71 {
72 /* the parent window is known after wxFrame::SetMenu() */
73 m_needParent = FALSE;
74
75 PreCreation( (wxWindow *) NULL, -1, wxDefaultPosition, wxDefaultSize, 0, "menu" );
76
77 m_menus.DeleteContents( TRUE );
78
79 /* GTK 1.2.0 doesn't have gtk_item_factory_get_item(), but GTK 1.2.1 has. */
80 #if (GTK_MINOR_VERSION > 0) && (GTK_MICRO_VERSION > 0)
81 m_accel = gtk_accel_group_new();
82 m_factory = gtk_item_factory_new( GTK_TYPE_MENU_BAR, "<main>", m_accel );
83 m_menubar = gtk_item_factory_get_widget( m_factory, "<main>" );
84 #else
85 m_menubar = gtk_menu_bar_new();
86 #endif
87
88 m_widget = GTK_WIDGET(m_menubar);
89
90 PostCreation();
91
92 Show( TRUE );
93 }
94
95 wxMenuBar::~wxMenuBar()
96 {
97 // how to destroy a GtkItemFactory ?
98 }
99
100 void wxMenuBar::Append( wxMenu *menu, const wxString &title )
101 {
102 m_menus.Append( menu );
103
104 /* GTK 1.2 wants to have "_" instead of "&" for accelerators */
105 wxString str;
106 for ( const wxChar *pc = title; *pc != _T('\0'); pc++ )
107 {
108 if (*pc == _T('&'))
109 {
110 #if (GTK_MINOR_VERSION > 0) && (GTK_MICRO_VERSION > 0)
111 str << _T('_');
112 } else
113 if (*pc == _T('/'))
114 {
115 str << _T('\\');
116 #endif
117 }
118 else
119 str << *pc;
120 }
121
122 /* this doesn't have much effect right now */
123 menu->SetTitle( str );
124
125 /* GTK 1.2.0 doesn't have gtk_item_factory_get_item(), but GTK 1.2.1 has. */
126 #if (GTK_MINOR_VERSION > 0) && (GTK_MICRO_VERSION > 0)
127
128 /* local buffer in multibyte form */
129 char buf[200];
130 strcpy( buf, "/" );
131 strcat( buf, str.mb_str() );
132
133 GtkItemFactoryEntry entry;
134 entry.path = buf;
135 entry.accelerator = (gchar*) NULL;
136 entry.callback = (GtkItemFactoryCallback) NULL;
137 entry.callback_action = 0;
138 entry.item_type = "<Branch>";
139
140 gtk_item_factory_create_item( m_factory, &entry, (gpointer) this, 2 ); /* what is 2 ? */
141
142 /* in order to get the pointer to the item we need the item text _without_ underscores */
143 wxString tmp = _T("<main>/");
144 for ( const wxChar *pc = str; *pc != _T('\0'); pc++ )
145 {
146 if (*pc == _T('_')) pc++; /* skip it */
147 tmp << *pc;
148 }
149
150 menu->m_owner = gtk_item_factory_get_item( m_factory, tmp.mb_str() );
151
152 gtk_menu_item_set_submenu( GTK_MENU_ITEM(menu->m_owner), menu->m_menu );
153
154 #else
155
156 menu->m_owner = gtk_menu_item_new_with_label( str.mb_str() );
157 gtk_widget_show( menu->m_owner );
158 gtk_menu_item_set_submenu( GTK_MENU_ITEM(menu->m_owner), menu->m_menu );
159
160 gtk_menu_bar_append( GTK_MENU_BAR(m_menubar), menu->m_owner );
161
162 #endif
163 }
164
165 static int FindMenuItemRecursive( const wxMenu *menu, const wxString &menuString, const wxString &itemString )
166 {
167 if (menu->GetTitle() == menuString)
168 {
169 int res = menu->FindItem( itemString );
170 if (res != wxNOT_FOUND)
171 return res;
172 }
173
174 wxNode *node = ((wxMenu *)menu)->GetItems().First(); // const_cast
175 while (node)
176 {
177 wxMenuItem *item = (wxMenuItem*)node->Data();
178 if (item->IsSubMenu())
179 return FindMenuItemRecursive(item->GetSubMenu(), menuString, itemString);
180
181 node = node->Next();
182 }
183
184 return wxNOT_FOUND;
185 }
186
187 wxMenuItem *wxMenuBar::FindItemForId(int itemId, wxMenu **menuForItem ) const
188 {
189 if ( menuForItem )
190 {
191 // TODO return the pointer to the menu
192
193 *menuForItem = NULL;
194 }
195
196 return FindItem(itemId);
197 }
198
199 int wxMenuBar::FindMenuItem( const wxString &menuString, const wxString &itemString ) const
200 {
201 wxNode *node = m_menus.First();
202 while (node)
203 {
204 wxMenu *menu = (wxMenu*)node->Data();
205 int res = FindMenuItemRecursive( menu, menuString, itemString);
206 if (res != -1) return res;
207 node = node->Next();
208 }
209 return -1;
210 }
211
212 // Find a wxMenuItem using its id. Recurses down into sub-menus
213 static wxMenuItem* FindMenuItemByIdRecursive(const wxMenu* menu, int id)
214 {
215 wxMenuItem* result = menu->FindItem(id);
216
217 wxNode *node = ((wxMenu *)menu)->GetItems().First(); // const_cast
218 while ( node && result == NULL )
219 {
220 wxMenuItem *item = (wxMenuItem*)node->Data();
221 if (item->IsSubMenu())
222 {
223 result = FindMenuItemByIdRecursive( item->GetSubMenu(), id );
224 }
225 node = node->Next();
226 }
227
228 return result;
229 }
230
231 wxMenuItem* wxMenuBar::FindItem( int id ) const
232 {
233 wxMenuItem* result = 0;
234 wxNode *node = m_menus.First();
235 while (node && result == 0)
236 {
237 wxMenu *menu = (wxMenu*)node->Data();
238 result = FindMenuItemByIdRecursive( menu, id );
239 node = node->Next();
240 }
241
242 return result;
243 }
244
245 void wxMenuBar::Check( int id, bool check )
246 {
247 wxMenuItem* item = FindMenuItemById( id );
248
249 wxCHECK_RET( item, _T("wxMenuBar::Check: no such item") );
250
251 item->Check(check);
252 }
253
254 bool wxMenuBar::IsChecked( int id ) const
255 {
256 wxMenuItem* item = FindMenuItemById( id );
257
258 wxCHECK_MSG( item, FALSE, _T("wxMenuBar::IsChecked: no such item") );
259
260 return item->IsChecked();
261 }
262
263 void wxMenuBar::Enable( int id, bool enable )
264 {
265 wxMenuItem* item = FindMenuItemById( id );
266
267 wxCHECK_RET( item, _T("wxMenuBar::Enable: no such item") );
268
269 item->Enable(enable);
270 }
271
272 bool wxMenuBar::IsEnabled( int id ) const
273 {
274 wxMenuItem* item = FindMenuItemById( id );
275
276 wxCHECK_MSG( item, FALSE, _T("wxMenuBar::IsEnabled: no such item") );
277
278 return item->IsEnabled();
279 }
280
281 wxString wxMenuBar::GetLabel( int id ) const
282 {
283 wxMenuItem* item = FindMenuItemById( id );
284
285 wxCHECK_MSG( item, _T(""), _T("wxMenuBar::GetLabel: no such item") );
286
287 return item->GetText();
288 }
289
290 void wxMenuBar::SetLabel( int id, const wxString &label )
291 {
292 wxMenuItem* item = FindMenuItemById( id );
293
294 wxCHECK_RET( item, _T("wxMenuBar::SetLabel: no such item") );
295
296 item->SetText( label );
297 }
298
299 void wxMenuBar::EnableTop( int pos, bool flag )
300 {
301 wxNode *node = m_menus.Nth( pos );
302
303 wxCHECK_RET( node, _T("menu not found") );
304
305 wxMenu* menu = (wxMenu*)node->Data();
306
307 if (menu->m_owner)
308 gtk_widget_set_sensitive( menu->m_owner, flag );
309 }
310
311 wxString wxMenuBar::GetLabelTop( int pos ) const
312 {
313 wxNode *node = m_menus.Nth( pos );
314
315 wxCHECK_MSG( node, _T("invalid"), _T("menu not found") );
316
317 wxMenu* menu = (wxMenu*)node->Data();
318
319 return menu->GetTitle();
320 }
321
322 void wxMenuBar::SetLabelTop( int pos, const wxString& label )
323 {
324 wxNode *node = m_menus.Nth( pos );
325
326 wxCHECK_RET( node, _T("menu not found") );
327
328 wxMenu* menu = (wxMenu*)node->Data();
329
330 menu->SetTitle( label );
331 }
332
333 void wxMenuBar::SetHelpString( int id, const wxString& helpString )
334 {
335 wxMenuItem* item = FindMenuItemById( id );
336
337 wxCHECK_RET( item, _T("wxMenuBar::SetHelpString: no such item") );
338
339 item->SetHelp( helpString );
340 }
341
342 wxString wxMenuBar::GetHelpString( int id ) const
343 {
344 wxMenuItem* item = FindMenuItemById( id );
345
346 wxCHECK_MSG( item, _T(""), _T("wxMenuBar::GetHelpString: no such item") );
347
348 return item->GetHelp();
349 }
350
351 //-----------------------------------------------------------------------------
352 // "activate"
353 //-----------------------------------------------------------------------------
354
355 static void gtk_menu_clicked_callback( GtkWidget *widget, wxMenu *menu )
356 {
357 if (g_isIdle) wxapp_install_idle_handler();
358
359 int id = menu->FindMenuIdByMenuItem(widget);
360
361 /* should find it for normal (not popup) menu */
362 wxASSERT( (id != -1) || (menu->GetInvokingWindow() != NULL) );
363
364 if (!menu->IsEnabled(id))
365 return;
366
367 wxMenuItem* item = menu->FindItem( id );
368 wxCHECK_RET( item, _T("error in menu item callback") );
369
370 if (item->IsCheckable())
371 {
372 if (item->GetCheckedFlag() == item->IsChecked())
373 {
374 /* the menu item has been checked by calling wxMenuItem->Check() */
375 return;
376 }
377 else
378 {
379 /* the user pressed on the menu item -> report */
380 item->SetCheckedFlag(item->IsChecked()); /* make consistent again */
381 }
382 }
383
384 wxCommandEvent event( wxEVT_COMMAND_MENU_SELECTED, id );
385 event.SetEventObject( menu );
386 event.SetInt(id );
387
388 if (menu->GetCallback())
389 {
390 (void) (*(menu->GetCallback())) (*menu, event);
391 return;
392 }
393
394 if (menu->GetEventHandler()->ProcessEvent(event))
395 return;
396
397 wxWindow *win = menu->GetInvokingWindow();
398 if (win)
399 win->GetEventHandler()->ProcessEvent( event );
400 }
401
402 //-----------------------------------------------------------------------------
403 // "select"
404 //-----------------------------------------------------------------------------
405
406 static void gtk_menu_hilight_callback( GtkWidget *widget, wxMenu *menu )
407 {
408 if (g_isIdle) wxapp_install_idle_handler();
409
410 int id = menu->FindMenuIdByMenuItem(widget);
411
412 wxASSERT( id != -1 ); // should find it!
413
414 if (!menu->IsEnabled(id))
415 return;
416
417 wxMenuEvent event( wxEVT_MENU_HIGHLIGHT, id );
418 event.SetEventObject( menu );
419
420 /* wxMSW doesn't call callback here either
421
422 if (menu->m_callback)
423 {
424 (void) (*(menu->m_callback)) (*menu, event);
425 return;
426 }
427 */
428
429 if (menu->GetEventHandler()->ProcessEvent(event))
430 return;
431
432 wxWindow *win = menu->GetInvokingWindow();
433 if (win) win->GetEventHandler()->ProcessEvent( event );
434 }
435
436 //-----------------------------------------------------------------------------
437 // "deselect"
438 //-----------------------------------------------------------------------------
439
440 static void gtk_menu_nolight_callback( GtkWidget *widget, wxMenu *menu )
441 {
442 if (g_isIdle) wxapp_install_idle_handler();
443
444 int id = menu->FindMenuIdByMenuItem(widget);
445
446 wxASSERT( id != -1 ); // should find it!
447
448 if (!menu->IsEnabled(id))
449 return;
450
451 wxMenuEvent event( wxEVT_MENU_HIGHLIGHT, -1 );
452 event.SetEventObject( menu );
453
454 if (menu->GetEventHandler()->ProcessEvent(event))
455 return;
456
457 wxWindow *win = menu->GetInvokingWindow();
458 if (win)
459 win->GetEventHandler()->ProcessEvent( event );
460 }
461
462 //-----------------------------------------------------------------------------
463 // wxMenuItem
464 //-----------------------------------------------------------------------------
465
466 IMPLEMENT_DYNAMIC_CLASS(wxMenuItem,wxObject)
467
468 wxMenuItem::wxMenuItem()
469 {
470 m_id = ID_SEPARATOR;
471 m_isCheckMenu = FALSE;
472 m_isChecked = FALSE;
473 m_isEnabled = TRUE;
474 m_subMenu = (wxMenu *) NULL;
475 m_menuItem = (GtkWidget *) NULL;
476 }
477
478 // it's valid for this function to be called even if m_menuItem == NULL
479 void wxMenuItem::SetName( const wxString& str )
480 {
481 /* '\t' is the deliminator indicating a hot key */
482 m_text = _T("");
483 const wxChar *pc = str;
484 for (; (*pc != _T('\0')) && (*pc != _T('\t')); pc++ )
485 {
486 if (*pc == _T('&'))
487 {
488 #if (GTK_MINOR_VERSION > 0)
489 m_text << _T('_');
490 } else
491 if (*pc == _T('/')) /* we have to filter out slashes ... */
492 {
493 m_text << _T('\\'); /* ... and replace them with back slashes */
494 #endif
495 }
496 else
497 m_text << *pc;
498 }
499
500 /* only GTK 1.2 knows about hot keys */
501 m_hotKey = _T("");
502 #if (GTK_MINOR_VERSION > 0)
503 if(*pc == _T('\t'))
504 {
505 pc++;
506 m_hotKey = pc;
507 }
508 #endif
509
510 if (m_menuItem)
511 {
512 GtkLabel *label = GTK_LABEL( GTK_BIN(m_menuItem)->child );
513 gtk_label_set( label, m_text.mb_str());
514 }
515 }
516
517 void wxMenuItem::Check( bool check )
518 {
519 wxCHECK_RET( m_menuItem, _T("invalid menu item") );
520
521 wxCHECK_RET( IsCheckable(), _T("Can't check uncheckable item!") )
522
523 if (check == m_isChecked) return;
524
525 m_isChecked = check;
526 gtk_check_menu_item_set_state( (GtkCheckMenuItem*)m_menuItem, (gint)check );
527 }
528
529 void wxMenuItem::Enable( bool enable )
530 {
531 wxCHECK_RET( m_menuItem, _T("invalid menu item") );
532
533 gtk_widget_set_sensitive( m_menuItem, enable );
534 m_isEnabled = enable;
535 }
536
537 bool wxMenuItem::IsChecked() const
538 {
539 wxCHECK_MSG( m_menuItem, FALSE, _T("invalid menu item") );
540
541 wxCHECK( IsCheckable(), FALSE ); // can't get state of uncheckable item!
542
543 bool bIsChecked = ((GtkCheckMenuItem*)m_menuItem)->active != 0;
544
545 return bIsChecked;
546 }
547
548 //-----------------------------------------------------------------------------
549 // wxMenu
550 //-----------------------------------------------------------------------------
551
552 IMPLEMENT_DYNAMIC_CLASS(wxMenu,wxEvtHandler)
553
554 wxMenu::wxMenu( const wxString& title, const wxFunction func )
555 {
556 m_title = title;
557 m_items.DeleteContents( TRUE );
558 m_invokingWindow = (wxWindow *) NULL;
559
560 #if (GTK_MINOR_VERSION > 0)
561 m_accel = gtk_accel_group_new();
562 m_factory = gtk_item_factory_new( GTK_TYPE_MENU, "<main>", m_accel );
563 m_menu = gtk_item_factory_get_widget( m_factory, "<main>" );
564 #else
565 m_menu = gtk_menu_new(); // Do not show!
566 #endif
567
568 m_callback = func;
569 m_eventHandler = this;
570 m_clientData = (void*) NULL;
571
572 if (m_title.IsNull()) m_title = _T("");
573 if (m_title != _T(""))
574 {
575 Append(-2, m_title);
576 AppendSeparator();
577 }
578
579 m_owner = (GtkWidget*) NULL;
580 }
581
582 wxMenu::~wxMenu()
583 {
584 /* how do we delete an item-factory ? */
585 }
586
587 void wxMenu::SetTitle( const wxString& title )
588 {
589 // TODO Waiting for something better
590 m_title = title;
591 }
592
593 const wxString wxMenu::GetTitle() const
594 {
595 return m_title;
596 }
597
598 void wxMenu::AppendSeparator()
599 {
600 wxMenuItem *mitem = new wxMenuItem();
601 mitem->SetId(ID_SEPARATOR);
602
603 #if (GTK_MINOR_VERSION > 0)
604 GtkItemFactoryEntry entry;
605 entry.path = "/sep";
606 entry.callback = (GtkItemFactoryCallback) NULL;
607 entry.callback_action = 0;
608 entry.item_type = "<Separator>";
609 entry.accelerator = (gchar*) NULL;
610
611 gtk_item_factory_create_item( m_factory, &entry, (gpointer) this, 2 ); /* what is 2 ? */
612
613 /* this will be wrong for more than one separator. do we care? */
614 GtkWidget *menuItem = gtk_item_factory_get_widget( m_factory, "<main>/sep" );
615 #else
616 GtkWidget *menuItem = gtk_menu_item_new();
617 gtk_menu_append( GTK_MENU(m_menu), menuItem );
618 gtk_widget_show( menuItem );
619 #endif
620
621 mitem->SetMenuItem(menuItem);
622 m_items.Append( mitem );
623 }
624
625 static char* GetHotKey( const wxString &hotkey, char *hotbuf )
626 {
627 if (hotkey.IsEmpty()) return (char*) NULL;
628
629 switch (hotkey[0])
630 {
631 case _T('a'): /* Alt */
632 case _T('A'):
633 case _T('m'): /* Meta */
634 case _T('M'):
635 {
636 strcpy( hotbuf, "<alt>" );
637 wxString last = hotkey.Right(1);
638 strcat( hotbuf, last.mb_str() );
639 return hotbuf;
640 }
641 case _T('c'): /* Ctrl */
642 case _T('C'):
643 case _T('s'): /* Strg, yeah man, I'm German */
644 case _T('S'):
645 {
646 strcpy( hotbuf, "<control>" );
647 wxString last = hotkey.Right(1);
648 strcat( hotbuf, last.mb_str() );
649 return hotbuf;
650 }
651 case _T('F'): /* function keys */
652 {
653 strcpy( hotbuf, hotkey.mb_str() );
654 return hotbuf;
655 }
656 default:
657 {
658 }
659 }
660 return (char*) NULL;
661 }
662
663 void wxMenu::Append( int id, const wxString &item, const wxString &helpStr, bool checkable )
664 {
665 wxMenuItem *mitem = new wxMenuItem();
666 mitem->SetId(id);
667 mitem->SetText(item);
668 mitem->SetHelp(helpStr);
669 mitem->SetCheckable(checkable);
670
671 #if (GTK_MINOR_VERSION > 0)
672 /* text has "_" instead of "&" after mitem->SetText() */
673 wxString text( mitem->GetText() );
674
675 /* local buffer in multibyte form */
676 char buf[200];
677 strcpy( buf, "/" );
678 strcat( buf, text.mb_str() );
679
680 GtkItemFactoryEntry entry;
681 entry.path = buf;
682 entry.callback = (GtkItemFactoryCallback) gtk_menu_clicked_callback;
683 entry.callback_action = 0;
684 if (checkable)
685 entry.item_type = "<CheckItem>";
686 else
687 entry.item_type = "<Item>";
688
689 char hotbuf[50];
690 entry.accelerator = GetHotKey( mitem->GetHotKey(), hotbuf );
691
692 gtk_item_factory_create_item( m_factory, &entry, (gpointer) this, 2 ); /* what is 2 ? */
693
694 /* in order to get the pointer to the item we need the item text _without_ underscores */
695 wxString s = _T("<main>/");
696 for ( const wxChar *pc = text; *pc != _T('\0'); pc++ )
697 {
698 if (*pc == _T('_')) pc++; /* skip it */
699 s << *pc;
700 }
701
702 GtkWidget *menuItem = gtk_item_factory_get_widget( m_factory, s.mb_str() );
703
704 #else
705
706 GtkWidget *menuItem = checkable ? gtk_check_menu_item_new_with_label( mitem->GetText().mb_str() )
707 : gtk_menu_item_new_with_label( mitem->GetText().mb_str() );
708
709 gtk_signal_connect( GTK_OBJECT(menuItem), "activate",
710 GTK_SIGNAL_FUNC(gtk_menu_clicked_callback),
711 (gpointer)this );
712
713 gtk_menu_append( GTK_MENU(m_menu), menuItem );
714 gtk_widget_show( menuItem );
715
716 #endif
717
718 gtk_signal_connect( GTK_OBJECT(menuItem), "select",
719 GTK_SIGNAL_FUNC(gtk_menu_hilight_callback),
720 (gpointer)this );
721
722 gtk_signal_connect( GTK_OBJECT(menuItem), "deselect",
723 GTK_SIGNAL_FUNC(gtk_menu_nolight_callback),
724 (gpointer)this );
725
726 mitem->SetMenuItem(menuItem);
727
728 m_items.Append( mitem );
729 }
730
731 void wxMenu::Append( int id, const wxString &item, wxMenu *subMenu, const wxString &helpStr )
732 {
733 wxMenuItem *mitem = new wxMenuItem();
734 mitem->SetId(id);
735 mitem->SetText(item);
736 mitem->SetHelp(helpStr);
737
738 #if (GTK_MINOR_VERSION > 0)
739 /* text has "_" instead of "&" after mitem->SetText() */
740 wxString text( mitem->GetText() );
741
742 /* local buffer in multibyte form */
743 char buf[200];
744 strcpy( buf, "/" );
745 strcat( buf, text.mb_str() );
746
747 GtkItemFactoryEntry entry;
748 entry.path = buf;
749 entry.callback = (GtkItemFactoryCallback) 0;
750 entry.callback_action = 0;
751 entry.item_type = "<Branch>";
752
753 gtk_item_factory_create_item( m_factory, &entry, (gpointer) this, 2 ); /* what is 2 ? */
754
755 /* in order to get the pointer to the item we need the item text _without_ underscores */
756 wxString s = _T("<main>/");
757 for ( const wxChar *pc = text; *pc != _T('\0'); pc++ )
758 {
759 if (*pc == _T('_')) pc++; /* skip it */
760 s << *pc;
761 }
762
763 GtkWidget *menuItem = gtk_item_factory_get_item( m_factory, s.mb_str() );
764
765 #else
766
767 GtkWidget *menuItem = gtk_menu_item_new_with_label(mitem->GetText().mbc_str());
768
769 gtk_menu_append( GTK_MENU(m_menu), menuItem );
770 gtk_widget_show( menuItem );
771
772 #endif
773
774 gtk_signal_connect( GTK_OBJECT(menuItem), "select",
775 GTK_SIGNAL_FUNC(gtk_menu_hilight_callback),
776 (gpointer*)this );
777
778 gtk_signal_connect( GTK_OBJECT(menuItem), "deselect",
779 GTK_SIGNAL_FUNC(gtk_menu_nolight_callback),
780 (gpointer*)this );
781
782 gtk_menu_item_set_submenu( GTK_MENU_ITEM(menuItem), subMenu->m_menu );
783
784 mitem->SetMenuItem(menuItem);
785 mitem->SetSubMenu(subMenu);
786
787 m_items.Append( mitem );
788 }
789
790 void wxMenu::Append( wxMenuItem *item )
791 {
792 m_items.Append( item );
793
794 GtkWidget *menuItem = (GtkWidget*) NULL;
795
796 if (item->IsSeparator())
797 menuItem = gtk_menu_item_new();
798 else if (item->IsSubMenu())
799 menuItem = gtk_menu_item_new_with_label(item->GetText().mbc_str());
800 else
801 menuItem = item->IsCheckable() ? gtk_check_menu_item_new_with_label(item->GetText().mbc_str())
802 : gtk_menu_item_new_with_label(item->GetText().mbc_str());
803
804 if (!item->IsSeparator())
805 {
806 gtk_signal_connect( GTK_OBJECT(menuItem), "select",
807 GTK_SIGNAL_FUNC(gtk_menu_hilight_callback),
808 (gpointer*)this );
809
810 gtk_signal_connect( GTK_OBJECT(menuItem), "deselect",
811 GTK_SIGNAL_FUNC(gtk_menu_nolight_callback),
812 (gpointer*)this );
813
814 if (!item->IsSubMenu())
815 {
816 gtk_signal_connect( GTK_OBJECT(menuItem), "activate",
817 GTK_SIGNAL_FUNC(gtk_menu_clicked_callback),
818 (gpointer*)this );
819 }
820 }
821
822 gtk_menu_append( GTK_MENU(m_menu), menuItem );
823 gtk_widget_show( menuItem );
824 item->SetMenuItem(menuItem);
825 }
826
827 int wxMenu::FindItem( const wxString itemString ) const
828 {
829 wxString s = _T("");
830 for ( const wxChar *pc = itemString; *pc != _T('\0'); pc++ )
831 {
832 if (*pc == _T('&'))
833 {
834 pc++; /* skip it */
835 #if (GTK_MINOR_VERSION > 0)
836 s << _T('_');
837 #endif
838 }
839 s << *pc;
840 }
841
842 wxNode *node = m_items.First();
843 while (node)
844 {
845 wxMenuItem *item = (wxMenuItem*)node->Data();
846 if (item->GetText() == s)
847 {
848 return item->GetId();
849 }
850 node = node->Next();
851 }
852
853 return wxNOT_FOUND;
854 }
855
856 void wxMenu::Enable( int id, bool enable )
857 {
858 wxMenuItem *item = FindItem(id);
859
860 wxCHECK_RET( item, _T("wxMenu::Enable: no such item") );
861
862 item->Enable(enable);
863 }
864
865 bool wxMenu::IsEnabled( int id ) const
866 {
867 wxMenuItem *item = FindItem(id);
868
869 wxCHECK_MSG( item, FALSE, _T("wxMenu::IsEnabled: no such item") );
870
871 return item->IsEnabled();
872 }
873
874 void wxMenu::Check( int id, bool enable )
875 {
876 wxMenuItem *item = FindItem(id);
877
878 wxCHECK_RET( item, _T("wxMenu::Check: no such item") );
879
880 item->Check(enable);
881 }
882
883 bool wxMenu::IsChecked( int id ) const
884 {
885 wxMenuItem *item = FindItem(id);
886
887 wxCHECK_MSG( item, FALSE, _T("wxMenu::IsChecked: no such item") );
888
889 return item->IsChecked();
890 }
891
892 void wxMenu::SetLabel( int id, const wxString &label )
893 {
894 wxMenuItem *item = FindItem(id);
895
896 wxCHECK_RET( item, _T("wxMenu::SetLabel: no such item") );
897
898 item->SetText(label);
899 }
900
901 wxString wxMenu::GetLabel( int id ) const
902 {
903 wxMenuItem *item = FindItem(id);
904
905 wxCHECK_MSG( item, _T(""), _T("wxMenu::GetLabel: no such item") );
906
907 return item->GetText();
908 }
909
910 void wxMenu::SetHelpString( int id, const wxString& helpString )
911 {
912 wxMenuItem *item = FindItem(id);
913
914 wxCHECK_RET( item, _T("wxMenu::SetHelpString: no such item") );
915
916 item->SetHelp( helpString );
917 }
918
919 wxString wxMenu::GetHelpString( int id ) const
920 {
921 wxMenuItem *item = FindItem(id);
922
923 wxCHECK_MSG( item, _T(""), _T("wxMenu::GetHelpString: no such item") );
924
925 return item->GetHelp();
926 }
927
928 int wxMenu::FindMenuIdByMenuItem( GtkWidget *menuItem ) const
929 {
930 wxNode *node = m_items.First();
931 while (node)
932 {
933 wxMenuItem *item = (wxMenuItem*)node->Data();
934 if (item->GetMenuItem() == menuItem)
935 return item->GetId();
936 node = node->Next();
937 }
938
939 return wxNOT_FOUND;
940 }
941
942 wxMenuItem *wxMenu::FindItem(int id) const
943 {
944 wxNode *node = m_items.First();
945 while (node)
946 {
947 wxMenuItem *item = (wxMenuItem*)node->Data();
948 if (item->GetId() == id)
949 {
950 return item;
951 }
952 node = node->Next();
953 }
954
955 /* Not finding anything here can be correct
956 * when search the entire menu system for
957 * an entry -> no error message. */
958
959 return (wxMenuItem *) NULL;
960 }
961
962 void wxMenu::SetInvokingWindow( wxWindow *win )
963 {
964 m_invokingWindow = win;
965 }
966
967 wxWindow *wxMenu::GetInvokingWindow()
968 {
969 return m_invokingWindow;
970 }
971
972 // Update a menu and all submenus recursively. source is the object that has
973 // the update event handlers defined for it. If NULL, the menu or associated
974 // window will be used.
975 void wxMenu::UpdateUI(wxEvtHandler* source)
976 {
977 if (!source && GetInvokingWindow())
978 source = GetInvokingWindow()->GetEventHandler();
979 if (!source)
980 source = GetEventHandler();
981 if (!source)
982 source = this;
983
984 wxNode* node = GetItems().First();
985 while (node)
986 {
987 wxMenuItem* item = (wxMenuItem*) node->Data();
988 if ( !item->IsSeparator() )
989 {
990 wxWindowID id = item->GetId();
991 wxUpdateUIEvent event(id);
992 event.SetEventObject( source );
993
994 if (source->ProcessEvent(event))
995 {
996 if (event.GetSetText())
997 SetLabel(id, event.GetText());
998 if (event.GetSetChecked())
999 Check(id, event.GetChecked());
1000 if (event.GetSetEnabled())
1001 Enable(id, event.GetEnabled());
1002 }
1003
1004 if (item->GetSubMenu())
1005 item->GetSubMenu()->UpdateUI(source);
1006 }
1007 node = node->Next();
1008 }
1009 }
1010