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