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