]> 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
Comment out direction aware code for now.
[wxWidgets.git] / src / gtk1 / menu.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: src/gtk1/menu.cpp
3// Purpose:
4// Author: Robert Roebling
5// Id: $Id$
6// Copyright: (c) 1998 Robert Roebling
7// Licence: wxWindows licence
8/////////////////////////////////////////////////////////////////////////////
9
10// For compilers that support precompilation, includes "wx.h".
11#include "wx/wxprec.h"
12
13#include "wx/menu.h"
14
15#ifndef WX_PRECOMP
16 #include "wx/intl.h"
17 #include "wx/log.h"
18 #include "wx/app.h"
19 #include "wx/bitmap.h"
20#endif
21
22#if wxUSE_ACCEL
23 #include "wx/accel.h"
24#endif // wxUSE_ACCEL
25
26#include "wx/gtk1/private.h"
27
28#include <gdk/gdkkeysyms.h>
29
30#define ACCEL_OBJECT GtkObject
31#define ACCEL_OBJECTS(a) (a)->attach_objects
32#define ACCEL_OBJ_CAST(obj) GTK_OBJECT(obj)
33
34// we use normal item but with a special id for the menu title
35static const int wxGTK_TITLE_ID = -3;
36
37// defined in window.cpp
38extern guint32 wxGtkTimeLastClick;
39
40//-----------------------------------------------------------------------------
41// idle system
42//-----------------------------------------------------------------------------
43
44extern void wxapp_install_idle_handler();
45extern bool g_isIdle;
46
47#if wxUSE_ACCEL
48static wxString GetGtkHotKey( const wxMenuItem& item );
49#endif
50
51//-----------------------------------------------------------------------------
52// idle system
53//-----------------------------------------------------------------------------
54
55static wxString wxReplaceUnderscore( const wxString& title )
56{
57 const wxChar *pc;
58
59 // GTK 1.2 wants to have "_" instead of "&" for accelerators
60 wxString str;
61 pc = title;
62 while (*pc != wxT('\0'))
63 {
64 if ((*pc == wxT('&')) && (*(pc+1) == wxT('&')))
65 {
66 // "&" is doubled to indicate "&" instead of accelerator
67 ++pc;
68 str << wxT('&');
69 }
70 else if (*pc == wxT('&'))
71 {
72 str << wxT('_');
73 }
74 else
75 {
76 if ( *pc == wxT('_') )
77 {
78 // underscores must be doubled to prevent them from being
79 // interpreted as accelerator character prefix by GTK
80 str << *pc;
81 }
82
83 str << *pc;
84 }
85 ++pc;
86 }
87
88 // wxPrintf( wxT("before %s after %s\n"), title.c_str(), str.c_str() );
89
90 return str;
91}
92
93//-----------------------------------------------------------------------------
94// activate message from GTK
95//-----------------------------------------------------------------------------
96
97static void DoCommonMenuCallbackCode(wxMenu *menu, wxMenuEvent& event)
98{
99 if (g_isIdle)
100 wxapp_install_idle_handler();
101
102 event.SetEventObject( menu );
103
104 wxEvtHandler* handler = menu->GetEventHandler();
105 if (handler && handler->ProcessEvent(event))
106 return;
107
108 wxWindow *win = menu->GetInvokingWindow();
109 if (win)
110 win->GetEventHandler()->ProcessEvent( event );
111}
112
113extern "C" {
114
115static void gtk_menu_open_callback( GtkWidget *widget, wxMenu *menu )
116{
117 wxMenuEvent event(wxEVT_MENU_OPEN, -1, menu);
118
119 DoCommonMenuCallbackCode(menu, event);
120}
121
122static void gtk_menu_close_callback( GtkWidget *widget, wxMenuBar *menubar )
123{
124 if ( !menubar->GetMenuCount() )
125 {
126 // if menubar is empty we can't call GetMenu(0) below
127 return;
128 }
129
130 wxMenuEvent event( wxEVT_MENU_CLOSE, -1, NULL );
131
132 DoCommonMenuCallbackCode(menubar->GetMenu(0), event);
133}
134
135}
136
137//-----------------------------------------------------------------------------
138// wxMenuBar
139//-----------------------------------------------------------------------------
140
141IMPLEMENT_DYNAMIC_CLASS(wxMenuBar,wxWindow)
142
143void wxMenuBar::Init(size_t n, wxMenu *menus[], const wxString titles[], long style)
144{
145 // the parent window is known after wxFrame::SetMenu()
146 m_needParent = false;
147 m_style = style;
148 m_invokingWindow = (wxWindow*) NULL;
149
150 if (!PreCreation( (wxWindow*) NULL, wxDefaultPosition, wxDefaultSize ) ||
151 !CreateBase( (wxWindow*) NULL, -1, wxDefaultPosition, wxDefaultSize, style, wxDefaultValidator, wxT("menubar") ))
152 {
153 wxFAIL_MSG( wxT("wxMenuBar creation failed") );
154 return;
155 }
156
157 m_menubar = gtk_menu_bar_new();
158 m_accel = gtk_accel_group_new();
159
160 if (style & wxMB_DOCKABLE)
161 {
162 m_widget = gtk_handle_box_new();
163 gtk_container_add( GTK_CONTAINER(m_widget), GTK_WIDGET(m_menubar) );
164 gtk_widget_show( GTK_WIDGET(m_menubar) );
165 }
166 else
167 {
168 m_widget = GTK_WIDGET(m_menubar);
169 }
170
171 PostCreation();
172
173 ApplyWidgetStyle();
174
175 for (size_t i = 0; i < n; ++i )
176 Append(menus[i], titles[i]);
177
178 // VZ: for some reason connecting to menus "deactivate" doesn't work (we
179 // don't get it when the menu is dismissed by clicking outside the
180 // toolbar) so we connect to the global one, even if it means that we
181 // can't pass the menu which was closed in wxMenuEvent object
182 gtk_signal_connect( GTK_OBJECT(GTK_MENU_SHELL(m_menubar)),
183 "deactivate",
184 GTK_SIGNAL_FUNC(gtk_menu_close_callback),
185 (gpointer)this );
186
187}
188
189wxMenuBar::wxMenuBar(size_t n, wxMenu *menus[], const wxString titles[], long style)
190{
191 Init(n, menus, titles, style);
192}
193
194wxMenuBar::wxMenuBar(long style)
195{
196 Init(0, NULL, NULL, style);
197}
198
199wxMenuBar::wxMenuBar()
200{
201 Init(0, NULL, NULL, 0);
202}
203
204wxMenuBar::~wxMenuBar()
205{
206}
207
208static void wxMenubarUnsetInvokingWindow( wxMenu *menu, wxWindow *win )
209{
210 menu->SetInvokingWindow( (wxWindow*) NULL );
211
212 wxWindow *top_frame = win;
213 while (top_frame->GetParent() && !(top_frame->IsTopLevel()))
214 top_frame = top_frame->GetParent();
215
216 // support for native hot keys
217 gtk_accel_group_detach( menu->m_accel, ACCEL_OBJ_CAST(top_frame->m_widget) );
218
219 wxMenuItemList::compatibility_iterator node = menu->GetMenuItems().GetFirst();
220 while (node)
221 {
222 wxMenuItem *menuitem = node->GetData();
223 if (menuitem->IsSubMenu())
224 wxMenubarUnsetInvokingWindow( menuitem->GetSubMenu(), win );
225 node = node->GetNext();
226 }
227}
228
229static void wxMenubarSetInvokingWindow( wxMenu *menu, wxWindow *win )
230{
231 menu->SetInvokingWindow( win );
232
233 wxWindow *top_frame = win;
234 while (top_frame->GetParent() && !(top_frame->IsTopLevel()))
235 top_frame = top_frame->GetParent();
236
237 // support for native hot keys
238 ACCEL_OBJECT *obj = ACCEL_OBJ_CAST(top_frame->m_widget);
239 if ( !g_slist_find( ACCEL_OBJECTS(menu->m_accel), obj ) )
240 gtk_accel_group_attach( menu->m_accel, obj );
241
242 wxMenuItemList::compatibility_iterator node = menu->GetMenuItems().GetFirst();
243 while (node)
244 {
245 wxMenuItem *menuitem = node->GetData();
246 if (menuitem->IsSubMenu())
247 wxMenubarSetInvokingWindow( menuitem->GetSubMenu(), win );
248 node = node->GetNext();
249 }
250}
251
252void wxMenuBar::SetInvokingWindow( wxWindow *win )
253{
254 m_invokingWindow = win;
255 wxWindow *top_frame = win;
256 while (top_frame->GetParent() && !(top_frame->IsTopLevel()))
257 top_frame = top_frame->GetParent();
258
259 // support for native key accelerators indicated by underscroes
260 ACCEL_OBJECT *obj = ACCEL_OBJ_CAST(top_frame->m_widget);
261 if ( !g_slist_find( ACCEL_OBJECTS(m_accel), obj ) )
262 gtk_accel_group_attach( m_accel, obj );
263
264 wxMenuList::compatibility_iterator node = m_menus.GetFirst();
265 while (node)
266 {
267 wxMenu *menu = node->GetData();
268 wxMenubarSetInvokingWindow( menu, win );
269 node = node->GetNext();
270 }
271}
272
273void wxMenuBar::UnsetInvokingWindow( wxWindow *win )
274{
275 m_invokingWindow = (wxWindow*) NULL;
276 wxWindow *top_frame = win;
277 while (top_frame->GetParent() && !(top_frame->IsTopLevel()))
278 top_frame = top_frame->GetParent();
279
280 // support for native key accelerators indicated by underscroes
281 gtk_accel_group_detach( m_accel, ACCEL_OBJ_CAST(top_frame->m_widget) );
282
283 wxMenuList::compatibility_iterator node = m_menus.GetFirst();
284 while (node)
285 {
286 wxMenu *menu = node->GetData();
287 wxMenubarUnsetInvokingWindow( menu, win );
288 node = node->GetNext();
289 }
290}
291
292bool wxMenuBar::Append( wxMenu *menu, const wxString &title )
293{
294 if ( !wxMenuBarBase::Append( menu, title ) )
295 return false;
296
297 return GtkAppend(menu, title);
298}
299
300bool wxMenuBar::GtkAppend(wxMenu *menu, const wxString& title, int pos)
301{
302 wxString str( wxReplaceUnderscore( title ) );
303
304 // This doesn't have much effect right now.
305 menu->SetTitle( str );
306
307 // The "m_owner" is the "menu item"
308 menu->m_owner = gtk_menu_item_new_with_label( wxGTK_CONV( str ) );
309 GtkLabel *label = GTK_LABEL( GTK_BIN(menu->m_owner)->child );
310 // set new text
311 gtk_label_set_text( label, wxGTK_CONV( str ) );
312 // reparse key accel
313 guint accel_key = gtk_label_parse_uline (GTK_LABEL(label), wxGTK_CONV( str ) );
314 if (accel_key != GDK_VoidSymbol)
315 {
316 gtk_widget_add_accelerator (menu->m_owner,
317 "activate_item",
318 m_accel, //gtk_menu_ensure_uline_accel_group(GTK_MENU(m_menubar)),
319 accel_key,
320 GDK_MOD1_MASK,
321 GTK_ACCEL_LOCKED);
322 }
323
324 gtk_widget_show( menu->m_owner );
325
326 gtk_menu_item_set_submenu( GTK_MENU_ITEM(menu->m_owner), menu->m_menu );
327
328 if (pos == -1)
329 gtk_menu_shell_append( GTK_MENU_SHELL(m_menubar), menu->m_owner );
330 else
331 gtk_menu_shell_insert( GTK_MENU_SHELL(m_menubar), menu->m_owner, pos );
332
333 gtk_signal_connect( GTK_OBJECT(menu->m_owner), "activate",
334 GTK_SIGNAL_FUNC(gtk_menu_open_callback),
335 (gpointer)menu );
336
337 // m_invokingWindow is set after wxFrame::SetMenuBar(). This call enables
338 // addings menu later on.
339 if (m_invokingWindow)
340 {
341 wxMenubarSetInvokingWindow( menu, m_invokingWindow );
342
343 // OPTIMISE ME: we should probably cache this, or pass it
344 // directly, but for now this is a minimal
345 // change to validate the new dynamic sizing.
346 // see (and refactor :) similar code in Remove
347 // below.
348
349 wxFrame *frame = wxDynamicCast( m_invokingWindow, wxFrame );
350
351 if( frame )
352 frame->UpdateMenuBarSize();
353 }
354
355 return true;
356}
357
358bool wxMenuBar::Insert(size_t pos, wxMenu *menu, const wxString& title)
359{
360 if ( !wxMenuBarBase::Insert(pos, menu, title) )
361 return false;
362
363 // TODO
364
365 if ( !GtkAppend(menu, title, (int)pos) )
366 return false;
367
368 return true;
369}
370
371wxMenu *wxMenuBar::Replace(size_t pos, wxMenu *menu, const wxString& title)
372{
373 // remove the old item and insert a new one
374 wxMenu *menuOld = Remove(pos);
375 if ( menuOld && !Insert(pos, menu, title) )
376 {
377 return (wxMenu*) NULL;
378 }
379
380 // either Insert() succeeded or Remove() failed and menuOld is NULL
381 return menuOld;
382}
383
384wxMenu *wxMenuBar::Remove(size_t pos)
385{
386 wxMenu *menu = wxMenuBarBase::Remove(pos);
387 if ( !menu )
388 return (wxMenu*) NULL;
389
390 gtk_menu_item_remove_submenu( GTK_MENU_ITEM(menu->m_owner) );
391 gtk_container_remove(GTK_CONTAINER(m_menubar), menu->m_owner);
392
393 gtk_widget_destroy( menu->m_owner );
394 menu->m_owner = NULL;
395
396 if (m_invokingWindow)
397 {
398 // OPTIMISE ME: see comment in GtkAppend
399 wxFrame *frame = wxDynamicCast( m_invokingWindow, wxFrame );
400
401 if( frame )
402 frame->UpdateMenuBarSize();
403 }
404
405 return menu;
406}
407
408static int FindMenuItemRecursive( const wxMenu *menu, const wxString &menuString, const wxString &itemString )
409{
410 if (wxMenuItem::GetLabelFromText(menu->GetTitle()) == wxMenuItem::GetLabelFromText(menuString))
411 {
412 int res = menu->FindItem( itemString );
413 if (res != wxNOT_FOUND)
414 return res;
415 }
416
417 wxMenuItemList::compatibility_iterator node = menu->GetMenuItems().GetFirst();
418 while (node)
419 {
420 wxMenuItem *item = node->GetData();
421 if (item->IsSubMenu())
422 return FindMenuItemRecursive(item->GetSubMenu(), menuString, itemString);
423
424 node = node->GetNext();
425 }
426
427 return wxNOT_FOUND;
428}
429
430int wxMenuBar::FindMenuItem( const wxString &menuString, const wxString &itemString ) const
431{
432 wxMenuList::compatibility_iterator node = m_menus.GetFirst();
433 while (node)
434 {
435 wxMenu *menu = node->GetData();
436 int res = FindMenuItemRecursive( menu, menuString, itemString);
437 if (res != -1)
438 return res;
439 node = node->GetNext();
440 }
441
442 return wxNOT_FOUND;
443}
444
445// Find a wxMenuItem using its id. Recurses down into sub-menus
446static wxMenuItem* FindMenuItemByIdRecursive(const wxMenu* menu, int id)
447{
448 wxMenuItem* result = menu->FindChildItem(id);
449
450 wxMenuItemList::compatibility_iterator node = menu->GetMenuItems().GetFirst();
451 while ( node && result == NULL )
452 {
453 wxMenuItem *item = node->GetData();
454 if (item->IsSubMenu())
455 {
456 result = FindMenuItemByIdRecursive( item->GetSubMenu(), id );
457 }
458 node = node->GetNext();
459 }
460
461 return result;
462}
463
464wxMenuItem* wxMenuBar::FindItem( int id, wxMenu **menuForItem ) const
465{
466 wxMenuItem* result = 0;
467 wxMenuList::compatibility_iterator node = m_menus.GetFirst();
468 while (node && result == 0)
469 {
470 wxMenu *menu = node->GetData();
471 result = FindMenuItemByIdRecursive( menu, id );
472 node = node->GetNext();
473 }
474
475 if ( menuForItem )
476 {
477 *menuForItem = result ? result->GetMenu() : (wxMenu *)NULL;
478 }
479
480 return result;
481}
482
483void wxMenuBar::EnableTop( size_t pos, bool flag )
484{
485 wxMenuList::compatibility_iterator node = m_menus.Item( pos );
486
487 wxCHECK_RET( node, wxT("menu not found") );
488
489 wxMenu* menu = node->GetData();
490
491 if (menu->m_owner)
492 gtk_widget_set_sensitive( menu->m_owner, flag );
493}
494
495wxString wxMenuBar::GetLabelTop( size_t pos ) const
496{
497 wxMenuList::compatibility_iterator node = m_menus.Item( pos );
498
499 wxCHECK_MSG( node, wxT("invalid"), wxT("menu not found") );
500
501 wxMenu* menu = node->GetData();
502
503 wxString label;
504 wxString text( menu->GetTitle() );
505 for ( const wxChar *pc = text.c_str(); *pc; pc++ )
506 {
507 if ( *pc == wxT('_') )
508 {
509 // '_' is the escape character for GTK+
510 continue;
511 }
512
513 // don't remove ampersands '&' since if we have them in the menu title
514 // it means that they were doubled to indicate "&" instead of accelerator
515
516 label += *pc;
517 }
518
519 return label;
520}
521
522void wxMenuBar::SetLabelTop( size_t pos, const wxString& label )
523{
524 wxMenuList::compatibility_iterator node = m_menus.Item( pos );
525
526 wxCHECK_RET( node, wxT("menu not found") );
527
528 wxMenu* menu = node->GetData();
529
530 const wxString str( wxReplaceUnderscore( label ) );
531
532 menu->SetTitle( str );
533
534 if (menu->m_owner)
535 {
536 GtkLabel *glabel = GTK_LABEL( GTK_BIN(menu->m_owner)->child );
537
538 /* set new text */
539 gtk_label_set( glabel, wxGTK_CONV( str ) );
540
541 /* reparse key accel */
542 (void)gtk_label_parse_uline (GTK_LABEL(glabel), wxGTK_CONV( str ) );
543 gtk_accel_label_refetch( GTK_ACCEL_LABEL(glabel) );
544 }
545
546}
547
548//-----------------------------------------------------------------------------
549// "activate"
550//-----------------------------------------------------------------------------
551
552extern "C" {
553static void gtk_menu_clicked_callback( GtkWidget *widget, wxMenu *menu )
554{
555 if (g_isIdle)
556 wxapp_install_idle_handler();
557
558 int id = menu->FindMenuIdByMenuItem(widget);
559
560 /* should find it for normal (not popup) menu */
561 wxASSERT_MSG( (id != -1) || (menu->GetInvokingWindow() != NULL),
562 _T("menu item not found in gtk_menu_clicked_callback") );
563
564 if (!menu->IsEnabled(id))
565 return;
566
567 wxMenuItem* item = menu->FindChildItem( id );
568 wxCHECK_RET( item, wxT("error in menu item callback") );
569
570 if ( item->GetId() == wxGTK_TITLE_ID )
571 {
572 // ignore events from the menu title
573 return;
574 }
575
576 if (item->IsCheckable())
577 {
578 bool isReallyChecked = item->IsChecked(),
579 isInternallyChecked = item->wxMenuItemBase::IsChecked();
580
581 // ensure that the internal state is always consistent with what is
582 // shown on the screen
583 item->wxMenuItemBase::Check(isReallyChecked);
584
585 // we must not report the events for the radio button going up nor the
586 // events resulting from the calls to wxMenuItem::Check()
587 if ( (item->GetKind() == wxITEM_RADIO && !isReallyChecked) ||
588 (isInternallyChecked == isReallyChecked) )
589 {
590 return;
591 }
592 }
593
594
595 // Is this menu on a menubar? (possibly nested)
596 wxFrame* frame = NULL;
597 if(menu->IsAttached())
598 frame = menu->GetMenuBar()->GetFrame();
599
600 // FIXME: why do we have to call wxFrame::GetEventHandler() directly here?
601 // normally wxMenu::SendEvent() should be enough, if it doesn't work
602 // in wxGTK then we have a bug in wxMenu::GetInvokingWindow() which
603 // should be fixed instead of working around it here...
604 if (frame)
605 {
606 // If it is attached then let the frame send the event.
607 // Don't call frame->ProcessCommand(id) because it toggles
608 // checkable items and we've already done that above.
609 wxCommandEvent commandEvent(wxEVT_COMMAND_MENU_SELECTED, id);
610 commandEvent.SetEventObject(frame);
611 if (item->IsCheckable())
612 commandEvent.SetInt(item->IsChecked());
613 commandEvent.SetEventObject(menu);
614
615 frame->GetEventHandler()->ProcessEvent(commandEvent);
616 }
617 else
618 {
619 // otherwise let the menu have it
620 menu->SendEvent(id, item->IsCheckable() ? item->IsChecked() : -1);
621 }
622}
623}
624
625//-----------------------------------------------------------------------------
626// "select"
627//-----------------------------------------------------------------------------
628
629extern "C" {
630static void gtk_menu_hilight_callback( GtkWidget *widget, wxMenu *menu )
631{
632 if (g_isIdle) wxapp_install_idle_handler();
633
634 int id = menu->FindMenuIdByMenuItem(widget);
635
636 wxASSERT( id != -1 ); // should find it!
637
638 if (!menu->IsEnabled(id))
639 return;
640
641 wxMenuEvent event( wxEVT_MENU_HIGHLIGHT, id );
642 event.SetEventObject( menu );
643
644 wxEvtHandler* handler = menu->GetEventHandler();
645 if (handler && handler->ProcessEvent(event))
646 return;
647
648 wxWindow *win = menu->GetInvokingWindow();
649 if (win) win->GetEventHandler()->ProcessEvent( event );
650}
651}
652
653//-----------------------------------------------------------------------------
654// "deselect"
655//-----------------------------------------------------------------------------
656
657extern "C" {
658static void gtk_menu_nolight_callback( GtkWidget *widget, wxMenu *menu )
659{
660 if (g_isIdle) wxapp_install_idle_handler();
661
662 int id = menu->FindMenuIdByMenuItem(widget);
663
664 wxASSERT( id != -1 ); // should find it!
665
666 if (!menu->IsEnabled(id))
667 return;
668
669 wxMenuEvent event( wxEVT_MENU_HIGHLIGHT, -1 );
670 event.SetEventObject( menu );
671
672 wxEvtHandler* handler = menu->GetEventHandler();
673 if (handler && handler->ProcessEvent(event))
674 return;
675
676 wxWindow *win = menu->GetInvokingWindow();
677 if (win)
678 win->GetEventHandler()->ProcessEvent( event );
679}
680}
681
682//-----------------------------------------------------------------------------
683// wxMenuItem
684//-----------------------------------------------------------------------------
685
686IMPLEMENT_DYNAMIC_CLASS(wxMenuItem, wxObject)
687
688wxMenuItem *wxMenuItemBase::New(wxMenu *parentMenu,
689 int id,
690 const wxString& name,
691 const wxString& help,
692 wxItemKind kind,
693 wxMenu *subMenu)
694{
695 return new wxMenuItem(parentMenu, id, name, help, kind, subMenu);
696}
697
698wxMenuItem::wxMenuItem(wxMenu *parentMenu,
699 int id,
700 const wxString& text,
701 const wxString& help,
702 wxItemKind kind,
703 wxMenu *subMenu)
704 : wxMenuItemBase(parentMenu, id, text, help, kind, subMenu)
705{
706 Init(text);
707}
708
709wxMenuItem::wxMenuItem(wxMenu *parentMenu,
710 int id,
711 const wxString& text,
712 const wxString& help,
713 bool isCheckable,
714 wxMenu *subMenu)
715 : wxMenuItemBase(parentMenu, id, text, help,
716 isCheckable ? wxITEM_CHECK : wxITEM_NORMAL, subMenu)
717{
718 Init(text);
719}
720
721void wxMenuItem::Init(const wxString& text)
722{
723 m_labelWidget = (GtkWidget *) NULL;
724 m_menuItem = (GtkWidget *) NULL;
725
726 DoSetText(text);
727}
728
729wxMenuItem::~wxMenuItem()
730{
731 // don't delete menu items, the menus take care of that
732}
733
734// return the menu item text without any menu accels
735/* static */
736wxString wxMenuItemBase::GetLabelFromText(const wxString& text)
737{
738 wxString label;
739
740 for ( const wxChar *pc = text.c_str(); *pc; pc++ )
741 {
742 if ( *pc == wxT('\t'))
743 break;
744
745 if ( *pc == wxT('_') )
746 {
747 // GTK 1.2 escapes "xxx_xxx" to "xxx__xxx"
748 pc++;
749 label += *pc;
750 continue;
751 }
752
753 if ( (*pc == wxT('&')) && (*(pc+1) != wxT('&')) )
754 {
755 // wxMSW escapes "&"
756 // "&" is doubled to indicate "&" instead of accelerator
757 continue;
758 }
759
760 label += *pc;
761 }
762
763 // wxPrintf( wxT("GetLabelFromText(): text %s label %s\n"), text.c_str(), label.c_str() );
764
765 return label;
766}
767
768void wxMenuItem::SetText( const wxString& str )
769{
770 // Some optimization to avoid flicker
771 wxString oldLabel = m_text;
772 oldLabel = wxStripMenuCodes(oldLabel);
773 oldLabel.Replace(wxT("_"), wxEmptyString);
774 wxString label1 = wxStripMenuCodes(str);
775 wxString oldhotkey = GetHotKey(); // Store the old hotkey in Ctrl-foo format
776 wxCharBuffer oldbuf = wxGTK_CONV( GetGtkHotKey(*this) ); // and as <control>foo
777
778 DoSetText(str);
779
780 if (oldLabel == label1 &&
781 oldhotkey == GetHotKey()) // Make sure we can change a hotkey even if the label is unaltered
782 return;
783
784 if (m_menuItem)
785 {
786 GtkLabel *label;
787 if (m_labelWidget)
788 label = (GtkLabel*) m_labelWidget;
789 else
790 label = GTK_LABEL( GTK_BIN(m_menuItem)->child );
791
792 // set new text
793 gtk_label_set( label, wxGTK_CONV( m_text ) );
794
795 // reparse key accel
796 (void)gtk_label_parse_uline (GTK_LABEL(label), wxGTK_CONV(m_text) );
797 gtk_accel_label_refetch( GTK_ACCEL_LABEL(label) );
798 }
799
800 guint accel_key;
801 GdkModifierType accel_mods;
802 gtk_accelerator_parse( (const char*) oldbuf, &accel_key, &accel_mods);
803 if (accel_key != 0)
804 {
805 gtk_widget_remove_accelerator( GTK_WIDGET(m_menuItem),
806 m_parentMenu->m_accel,
807 accel_key,
808 accel_mods );
809 }
810
811 wxCharBuffer buf = wxGTK_CONV( GetGtkHotKey(*this) );
812 gtk_accelerator_parse( (const char*) buf, &accel_key, &accel_mods);
813 if (accel_key != 0)
814 {
815 gtk_widget_add_accelerator( GTK_WIDGET(m_menuItem),
816 "activate",
817 m_parentMenu->m_accel,
818 accel_key,
819 accel_mods,
820 GTK_ACCEL_VISIBLE);
821 }
822}
823
824// it's valid for this function to be called even if m_menuItem == NULL
825void wxMenuItem::DoSetText( const wxString& str )
826{
827 // '\t' is the deliminator indicating a hot key
828 m_text.Empty();
829 const wxChar *pc = str;
830 while ( (*pc != wxT('\0')) && (*pc != wxT('\t')) )
831 {
832 if ((*pc == wxT('&')) && (*(pc+1) == wxT('&')))
833 {
834 // "&" is doubled to indicate "&" instead of accelerator
835 ++pc;
836 m_text << wxT('&');
837 }
838 else if (*pc == wxT('&'))
839 {
840 m_text << wxT('_');
841 }
842 else if ( *pc == wxT('_') ) // escape underscores
843 {
844 m_text << wxT("__");
845 }
846 else
847 {
848 m_text << *pc;
849 }
850 ++pc;
851 }
852
853 m_hotKey = wxEmptyString;
854
855 if(*pc == wxT('\t'))
856 {
857 pc++;
858 m_hotKey = pc;
859 }
860
861 // wxPrintf( wxT("DoSetText(): str %s m_text %s hotkey %s\n"), str.c_str(), m_text.c_str(), m_hotKey.c_str() );
862}
863
864#if wxUSE_ACCEL
865
866wxAcceleratorEntry *wxMenuItem::GetAccel() const
867{
868 if ( !GetHotKey() )
869 {
870 // nothing
871 return (wxAcceleratorEntry *)NULL;
872 }
873
874 // as wxGetAccelFromString() looks for TAB, insert a dummy one here
875 wxString label;
876 label << wxT('\t') << GetHotKey();
877
878 return wxGetAccelFromString(label);
879}
880
881#endif // wxUSE_ACCEL
882
883void wxMenuItem::Check( bool check )
884{
885 wxCHECK_RET( m_menuItem, wxT("invalid menu item") );
886
887 if (check == m_isChecked)
888 return;
889
890 wxMenuItemBase::Check( check );
891
892 switch ( GetKind() )
893 {
894 case wxITEM_CHECK:
895 case wxITEM_RADIO:
896 gtk_check_menu_item_set_state( (GtkCheckMenuItem*)m_menuItem, (gint)check );
897 break;
898
899 default:
900 wxFAIL_MSG( _T("can't check this item") );
901 }
902}
903
904void wxMenuItem::Enable( bool enable )
905{
906 wxCHECK_RET( m_menuItem, wxT("invalid menu item") );
907
908 gtk_widget_set_sensitive( m_menuItem, enable );
909 wxMenuItemBase::Enable( enable );
910}
911
912bool wxMenuItem::IsChecked() const
913{
914 wxCHECK_MSG( m_menuItem, false, wxT("invalid menu item") );
915
916 wxCHECK_MSG( IsCheckable(), false,
917 wxT("can't get state of uncheckable item!") );
918
919 return ((GtkCheckMenuItem*)m_menuItem)->active != 0;
920}
921
922//-----------------------------------------------------------------------------
923// wxMenu
924//-----------------------------------------------------------------------------
925
926IMPLEMENT_DYNAMIC_CLASS(wxMenu,wxEvtHandler)
927
928void wxMenu::Init()
929{
930 m_accel = gtk_accel_group_new();
931 m_menu = gtk_menu_new();
932 // NB: keep reference to the menu so that it is not destroyed behind
933 // our back by GTK+ e.g. when it is removed from menubar:
934 gtk_widget_ref(m_menu);
935
936 m_owner = (GtkWidget*) NULL;
937
938 // Tearoffs are entries, just like separators. So if we want this
939 // menu to be a tear-off one, we just append a tearoff entry
940 // immediately.
941 if ( m_style & wxMENU_TEAROFF )
942 {
943 GtkWidget *tearoff = gtk_tearoff_menu_item_new();
944
945 gtk_menu_append(GTK_MENU(m_menu), tearoff);
946 }
947
948 m_prevRadio = NULL;
949
950 // append the title as the very first entry if we have it
951 if ( !m_title.empty() )
952 {
953 Append(wxGTK_TITLE_ID, m_title);
954 AppendSeparator();
955 }
956}
957
958wxMenu::~wxMenu()
959{
960 WX_CLEAR_LIST(wxMenuItemList, m_items);
961
962 if ( GTK_IS_WIDGET( m_menu ))
963 {
964 // see wxMenu::Init
965 gtk_widget_unref( m_menu );
966 // if the menu is inserted in another menu at this time, there was
967 // one more reference to it:
968 if ( m_owner )
969 gtk_widget_destroy( m_menu );
970 }
971}
972
973bool wxMenu::GtkAppend(wxMenuItem *mitem, int pos)
974{
975 GtkWidget *menuItem;
976
977 wxString text;
978 GtkLabel* label = NULL;
979
980 if ( mitem->IsSeparator() )
981 {
982 // TODO
983 menuItem = gtk_menu_item_new();
984 }
985 else if (mitem->GetBitmap().Ok())
986 {
987 text = mitem->GetText();
988 const wxBitmap *bitmap = &mitem->GetBitmap();
989
990 // TODO
991 wxUnusedVar(bitmap);
992 menuItem = gtk_menu_item_new_with_label( wxGTK_CONV( text ) );
993 label = GTK_LABEL( GTK_BIN(menuItem)->child );
994
995 m_prevRadio = NULL;
996 }
997 else // a normal item
998 {
999 // text has "_" instead of "&" after mitem->SetText() so don't use it
1000 text = mitem->GetText() ;
1001
1002 switch ( mitem->GetKind() )
1003 {
1004 case wxITEM_CHECK:
1005 {
1006 menuItem = gtk_check_menu_item_new_with_label( wxGTK_CONV( text ) );
1007 label = GTK_LABEL( GTK_BIN(menuItem)->child );
1008 // set new text
1009 gtk_label_set_text( label, wxGTK_CONV( text ) );
1010 m_prevRadio = NULL;
1011 break;
1012 }
1013
1014 case wxITEM_RADIO:
1015 {
1016 GSList *group = NULL;
1017 if ( m_prevRadio == NULL )
1018 {
1019 // start of a new radio group
1020 m_prevRadio = menuItem = gtk_radio_menu_item_new_with_label( group, wxGTK_CONV( text ) );
1021 label = GTK_LABEL( GTK_BIN(menuItem)->child );
1022 // set new text
1023 gtk_label_set_text( label, wxGTK_CONV( text ) );
1024 }
1025 else // continue the radio group
1026 {
1027 group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (m_prevRadio));
1028 m_prevRadio = menuItem = gtk_radio_menu_item_new_with_label( group, wxGTK_CONV( text ) );
1029 label = GTK_LABEL( GTK_BIN(menuItem)->child );
1030 }
1031 break;
1032 }
1033
1034 default:
1035 wxFAIL_MSG( _T("unexpected menu item kind") );
1036 // fall through
1037
1038 case wxITEM_NORMAL:
1039 {
1040 menuItem = gtk_menu_item_new_with_label( wxGTK_CONV( text ) );
1041 label = GTK_LABEL( GTK_BIN(menuItem)->child );
1042 m_prevRadio = NULL;
1043 break;
1044 }
1045 }
1046
1047 }
1048
1049 guint accel_key;
1050 GdkModifierType accel_mods;
1051 wxCharBuffer buf = wxGTK_CONV( GetGtkHotKey(*mitem) );
1052
1053 // wxPrintf( wxT("item: %s hotkey %s\n"), mitem->GetText().c_str(), GetGtkHotKey(*mitem).c_str() );
1054 gtk_accelerator_parse( (const char*) buf, &accel_key, &accel_mods);
1055 if (accel_key != 0)
1056 {
1057 gtk_widget_add_accelerator (GTK_WIDGET(menuItem),
1058 "activate",
1059 m_accel,
1060 accel_key,
1061 accel_mods,
1062 GTK_ACCEL_VISIBLE);
1063 }
1064
1065 if (pos == -1)
1066 gtk_menu_shell_append(GTK_MENU_SHELL(m_menu), menuItem);
1067 else
1068 gtk_menu_shell_insert(GTK_MENU_SHELL(m_menu), menuItem, pos);
1069
1070 gtk_widget_show( menuItem );
1071
1072 if ( !mitem->IsSeparator() )
1073 {
1074 wxASSERT_MSG( menuItem, wxT("invalid menuitem") );
1075
1076 gtk_signal_connect( GTK_OBJECT(menuItem), "select",
1077 GTK_SIGNAL_FUNC(gtk_menu_hilight_callback),
1078 (gpointer)this );
1079
1080 gtk_signal_connect( GTK_OBJECT(menuItem), "deselect",
1081 GTK_SIGNAL_FUNC(gtk_menu_nolight_callback),
1082 (gpointer)this );
1083
1084 if ( mitem->IsSubMenu() && mitem->GetKind() != wxITEM_RADIO && mitem->GetKind() != wxITEM_CHECK )
1085 {
1086 gtk_menu_item_set_submenu( GTK_MENU_ITEM(menuItem), mitem->GetSubMenu()->m_menu );
1087
1088 gtk_widget_show( mitem->GetSubMenu()->m_menu );
1089
1090 // if adding a submenu to a menu already existing in the menu bar, we
1091 // must set invoking window to allow processing events from this
1092 // submenu
1093 if ( m_invokingWindow )
1094 wxMenubarSetInvokingWindow(mitem->GetSubMenu(), m_invokingWindow);
1095 }
1096 else
1097 {
1098 gtk_signal_connect( GTK_OBJECT(menuItem), "activate",
1099 GTK_SIGNAL_FUNC(gtk_menu_clicked_callback),
1100 (gpointer)this );
1101 }
1102
1103 guint accel_key = gtk_label_parse_uline (GTK_LABEL(label), wxGTK_CONV( text ) );
1104 if (accel_key != GDK_VoidSymbol)
1105 {
1106 gtk_widget_add_accelerator (menuItem,
1107 "activate_item",
1108 gtk_menu_ensure_uline_accel_group(GTK_MENU(m_menu)),
1109 accel_key,
1110 GDK_MOD1_MASK,
1111 GTK_ACCEL_LOCKED);
1112 }
1113 }
1114
1115 mitem->SetMenuItem(menuItem);
1116
1117 if (ms_locked)
1118 {
1119 // This doesn't even exist!
1120 // gtk_widget_lock_accelerators(mitem->GetMenuItem());
1121 }
1122
1123 return true;
1124}
1125
1126wxMenuItem* wxMenu::DoAppend(wxMenuItem *mitem)
1127{
1128 if (!GtkAppend(mitem))
1129 return NULL;
1130
1131 return wxMenuBase::DoAppend(mitem);
1132}
1133
1134wxMenuItem* wxMenu::DoInsert(size_t pos, wxMenuItem *item)
1135{
1136 if ( !wxMenuBase::DoInsert(pos, item) )
1137 return NULL;
1138
1139 // TODO
1140 if ( !GtkAppend(item, (int)pos) )
1141 return NULL;
1142
1143 return item;
1144}
1145
1146wxMenuItem *wxMenu::DoRemove(wxMenuItem *item)
1147{
1148 if ( !wxMenuBase::DoRemove(item) )
1149 return (wxMenuItem *)NULL;
1150
1151 // TODO: this code doesn't delete the item factory item and this seems
1152 // impossible as of GTK 1.2.6.
1153 gtk_widget_destroy( item->GetMenuItem() );
1154
1155 return item;
1156}
1157
1158int wxMenu::FindMenuIdByMenuItem( GtkWidget *menuItem ) const
1159{
1160 wxMenuItemList::compatibility_iterator node = m_items.GetFirst();
1161 while (node)
1162 {
1163 wxMenuItem *item = node->GetData();
1164 if (item->GetMenuItem() == menuItem)
1165 return item->GetId();
1166 node = node->GetNext();
1167 }
1168
1169 return wxNOT_FOUND;
1170}
1171
1172// ----------------------------------------------------------------------------
1173// helpers
1174// ----------------------------------------------------------------------------
1175
1176#if wxUSE_ACCEL
1177
1178static wxString GetGtkHotKey( const wxMenuItem& item )
1179{
1180 wxString hotkey;
1181
1182 wxAcceleratorEntry *accel = item.GetAccel();
1183 if ( accel )
1184 {
1185 int flags = accel->GetFlags();
1186 if ( flags & wxACCEL_ALT )
1187 hotkey += wxT("<alt>");
1188 if ( flags & wxACCEL_CTRL )
1189 hotkey += wxT("<control>");
1190 if ( flags & wxACCEL_SHIFT )
1191 hotkey += wxT("<shift>");
1192
1193 int code = accel->GetKeyCode();
1194 switch ( code )
1195 {
1196 case WXK_F1:
1197 case WXK_F2:
1198 case WXK_F3:
1199 case WXK_F4:
1200 case WXK_F5:
1201 case WXK_F6:
1202 case WXK_F7:
1203 case WXK_F8:
1204 case WXK_F9:
1205 case WXK_F10:
1206 case WXK_F11:
1207 case WXK_F12:
1208 case WXK_F13:
1209 case WXK_F14:
1210 case WXK_F15:
1211 case WXK_F16:
1212 case WXK_F17:
1213 case WXK_F18:
1214 case WXK_F19:
1215 case WXK_F20:
1216 case WXK_F21:
1217 case WXK_F22:
1218 case WXK_F23:
1219 case WXK_F24:
1220 hotkey += wxString::Format(wxT("F%d"), code - WXK_F1 + 1);
1221 break;
1222
1223 // TODO: we should use gdk_keyval_name() (a.k.a.
1224 // XKeysymToString) here as well as hardcoding the keysym
1225 // names this might be not portable
1226 case WXK_INSERT:
1227 hotkey << wxT("Insert" );
1228 break;
1229 case WXK_DELETE:
1230 hotkey << wxT("Delete" );
1231 break;
1232 case WXK_UP:
1233 hotkey << wxT("Up" );
1234 break;
1235 case WXK_DOWN:
1236 hotkey << wxT("Down" );
1237 break;
1238 case WXK_PAGEUP:
1239 hotkey << wxT("PgUp" );
1240 break;
1241 case WXK_PAGEDOWN:
1242 hotkey << wxT("PgDn" );
1243 break;
1244 case WXK_LEFT:
1245 hotkey << wxT("Left" );
1246 break;
1247 case WXK_RIGHT:
1248 hotkey << wxT("Right" );
1249 break;
1250 case WXK_HOME:
1251 hotkey << wxT("Home" );
1252 break;
1253 case WXK_END:
1254 hotkey << wxT("End" );
1255 break;
1256 case WXK_RETURN:
1257 hotkey << wxT("Return" );
1258 break;
1259 case WXK_BACK:
1260 hotkey << wxT("BackSpace" );
1261 break;
1262 case WXK_TAB:
1263 hotkey << wxT("Tab" );
1264 break;
1265 case WXK_ESCAPE:
1266 hotkey << wxT("Esc" );
1267 break;
1268 case WXK_SPACE:
1269 hotkey << wxT("space" );
1270 break;
1271 case WXK_MULTIPLY:
1272 hotkey << wxT("Multiply" );
1273 break;
1274 case WXK_ADD:
1275 hotkey << wxT("Add" );
1276 break;
1277 case WXK_SEPARATOR:
1278 hotkey << wxT("Separator" );
1279 break;
1280 case WXK_SUBTRACT:
1281 hotkey << wxT("Subtract" );
1282 break;
1283 case WXK_DECIMAL:
1284 hotkey << wxT("Decimal" );
1285 break;
1286 case WXK_DIVIDE:
1287 hotkey << wxT("Divide" );
1288 break;
1289 case WXK_CANCEL:
1290 hotkey << wxT("Cancel" );
1291 break;
1292 case WXK_CLEAR:
1293 hotkey << wxT("Clear" );
1294 break;
1295 case WXK_MENU:
1296 hotkey << wxT("Menu" );
1297 break;
1298 case WXK_PAUSE:
1299 hotkey << wxT("Pause" );
1300 break;
1301 case WXK_CAPITAL:
1302 hotkey << wxT("Capital" );
1303 break;
1304 case WXK_SELECT:
1305 hotkey << wxT("Select" );
1306 break;
1307 case WXK_PRINT:
1308 hotkey << wxT("Print" );
1309 break;
1310 case WXK_EXECUTE:
1311 hotkey << wxT("Execute" );
1312 break;
1313 case WXK_SNAPSHOT:
1314 hotkey << wxT("Snapshot" );
1315 break;
1316 case WXK_HELP:
1317 hotkey << wxT("Help" );
1318 break;
1319 case WXK_NUMLOCK:
1320 hotkey << wxT("Num_Lock" );
1321 break;
1322 case WXK_SCROLL:
1323 hotkey << wxT("Scroll_Lock" );
1324 break;
1325 case WXK_NUMPAD_INSERT:
1326 hotkey << wxT("KP_Insert" );
1327 break;
1328 case WXK_NUMPAD_DELETE:
1329 hotkey << wxT("KP_Delete" );
1330 break;
1331 case WXK_NUMPAD_SPACE:
1332 hotkey << wxT("KP_Space" );
1333 break;
1334 case WXK_NUMPAD_TAB:
1335 hotkey << wxT("KP_Tab" );
1336 break;
1337 case WXK_NUMPAD_ENTER:
1338 hotkey << wxT("KP_Enter" );
1339 break;
1340 case WXK_NUMPAD_F1: case WXK_NUMPAD_F2: case WXK_NUMPAD_F3:
1341 case WXK_NUMPAD_F4:
1342 hotkey += wxString::Format(wxT("KP_F%d"), code - WXK_NUMPAD_F1 + 1);
1343 break;
1344 case WXK_NUMPAD_HOME:
1345 hotkey << wxT("KP_Home" );
1346 break;
1347 case WXK_NUMPAD_LEFT:
1348 hotkey << wxT("KP_Left" );
1349 break;
1350 case WXK_NUMPAD_UP:
1351 hotkey << wxT("KP_Up" );
1352 break;
1353 case WXK_NUMPAD_RIGHT:
1354 hotkey << wxT("KP_Right" );
1355 break;
1356 case WXK_NUMPAD_DOWN:
1357 hotkey << wxT("KP_Down" );
1358 break;
1359 case WXK_NUMPAD_PAGEUP:
1360 hotkey << wxT("KP_PgUp" );
1361 break;
1362 case WXK_NUMPAD_PAGEDOWN:
1363 hotkey << wxT("KP_PgDn" );
1364 break;
1365 case WXK_NUMPAD_END:
1366 hotkey << wxT("KP_End" );
1367 break;
1368 case WXK_NUMPAD_BEGIN:
1369 hotkey << wxT("KP_Begin" );
1370 break;
1371 case WXK_NUMPAD_EQUAL:
1372 hotkey << wxT("KP_Equal" );
1373 break;
1374 case WXK_NUMPAD_MULTIPLY:
1375 hotkey << wxT("KP_Multiply" );
1376 break;
1377 case WXK_NUMPAD_ADD:
1378 hotkey << wxT("KP_Add" );
1379 break;
1380 case WXK_NUMPAD_SEPARATOR:
1381 hotkey << wxT("KP_Separator" );
1382 break;
1383 case WXK_NUMPAD_SUBTRACT:
1384 hotkey << wxT("KP_Subtract" );
1385 break;
1386 case WXK_NUMPAD_DECIMAL:
1387 hotkey << wxT("KP_Decimal" );
1388 break;
1389 case WXK_NUMPAD_DIVIDE:
1390 hotkey << wxT("KP_Divide" );
1391 break;
1392 case WXK_NUMPAD0: case WXK_NUMPAD1: case WXK_NUMPAD2:
1393 case WXK_NUMPAD3: case WXK_NUMPAD4: case WXK_NUMPAD5:
1394 case WXK_NUMPAD6: case WXK_NUMPAD7: case WXK_NUMPAD8: case WXK_NUMPAD9:
1395 hotkey += wxString::Format(wxT("KP_%d"), code - WXK_NUMPAD0);
1396 break;
1397 case WXK_WINDOWS_LEFT:
1398 hotkey << wxT("Super_L" );
1399 break;
1400 case WXK_WINDOWS_RIGHT:
1401 hotkey << wxT("Super_R" );
1402 break;
1403 case WXK_WINDOWS_MENU:
1404 hotkey << wxT("Menu" );
1405 break;
1406 case WXK_COMMAND:
1407 hotkey << wxT("Command" );
1408 break;
1409 /* These probably wouldn't work as there is no SpecialX in gdk/keynames.txt
1410 case WXK_SPECIAL1: case WXK_SPECIAL2: case WXK_SPECIAL3: case WXK_SPECIAL4:
1411 case WXK_SPECIAL5: case WXK_SPECIAL6: case WXK_SPECIAL7: case WXK_SPECIAL8:
1412 case WXK_SPECIAL9: case WXK_SPECIAL10: case WXK_SPECIAL11: case WXK_SPECIAL12:
1413 case WXK_SPECIAL13: case WXK_SPECIAL14: case WXK_SPECIAL15: case WXK_SPECIAL16:
1414 case WXK_SPECIAL17: case WXK_SPECIAL18: case WXK_SPECIAL19: case WXK_SPECIAL20:
1415 hotkey += wxString::Format(wxT("Special%d"), code - WXK_SPECIAL1 + 1);
1416 break;
1417 */
1418 // if there are any other keys wxGetAccelFromString() may
1419 // return, we should process them here
1420
1421 default:
1422 if ( code < 127 )
1423 {
1424 wxString name = wxGTK_CONV_BACK( gdk_keyval_name((guint)code) );
1425 if ( name )
1426 {
1427 hotkey << name;
1428 break;
1429 }
1430 }
1431
1432 wxFAIL_MSG( wxT("unknown keyboard accel") );
1433 }
1434
1435 delete accel;
1436 }
1437
1438 return hotkey;
1439}
1440
1441#endif // wxUSE_ACCEL
1442
1443// ----------------------------------------------------------------------------
1444// Pop-up menu stuff
1445// ----------------------------------------------------------------------------
1446
1447#if wxUSE_MENUS_NATIVE
1448
1449extern "C" WXDLLIMPEXP_CORE
1450void gtk_pop_hide_callback( GtkWidget *WXUNUSED(widget), bool* is_waiting )
1451{
1452 *is_waiting = false;
1453}
1454
1455WXDLLIMPEXP_CORE void SetInvokingWindow( wxMenu *menu, wxWindow* win )
1456{
1457 menu->SetInvokingWindow( win );
1458
1459 wxMenuItemList::compatibility_iterator node = menu->GetMenuItems().GetFirst();
1460 while (node)
1461 {
1462 wxMenuItem *menuitem = node->GetData();
1463 if (menuitem->IsSubMenu())
1464 {
1465 SetInvokingWindow( menuitem->GetSubMenu(), win );
1466 }
1467
1468 node = node->GetNext();
1469 }
1470}
1471
1472extern "C" WXDLLIMPEXP_CORE
1473void wxPopupMenuPositionCallback( GtkMenu *menu,
1474 gint *x, gint *y,
1475 gpointer user_data )
1476{
1477 // ensure that the menu appears entirely on screen
1478 GtkRequisition req;
1479 gtk_widget_get_child_requisition(GTK_WIDGET(menu), &req);
1480
1481 wxSize sizeScreen = wxGetDisplaySize();
1482 wxPoint *pos = (wxPoint*)user_data;
1483
1484 gint xmax = sizeScreen.x - req.width,
1485 ymax = sizeScreen.y - req.height;
1486
1487 *x = pos->x < xmax ? pos->x : xmax;
1488 *y = pos->y < ymax ? pos->y : ymax;
1489}
1490
1491bool wxWindowGTK::DoPopupMenu( wxMenu *menu, int x, int y )
1492{
1493 wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
1494
1495 wxCHECK_MSG( menu != NULL, false, wxT("invalid popup-menu") );
1496
1497 // NOTE: if you change this code, you need to update
1498 // the same code in taskbar.cpp as well. This
1499 // is ugly code duplication, I know.
1500
1501 SetInvokingWindow( menu, this );
1502
1503 menu->UpdateUI();
1504
1505 bool is_waiting = true;
1506
1507 gulong handler = gtk_signal_connect( GTK_OBJECT(menu->m_menu),
1508 "hide",
1509 GTK_SIGNAL_FUNC(gtk_pop_hide_callback),
1510 (gpointer)&is_waiting );
1511
1512 wxPoint pos;
1513 gpointer userdata;
1514 GtkMenuPositionFunc posfunc;
1515 if ( x == -1 && y == -1 )
1516 {
1517 // use GTK's default positioning algorithm
1518 userdata = NULL;
1519 posfunc = NULL;
1520 }
1521 else
1522 {
1523 pos = ClientToScreen(wxPoint(x, y));
1524 userdata = &pos;
1525 posfunc = wxPopupMenuPositionCallback;
1526 }
1527
1528 wxMenuEvent eventOpen(wxEVT_MENU_OPEN, -1, menu);
1529 DoCommonMenuCallbackCode(menu, eventOpen);
1530
1531 gtk_menu_popup(
1532 GTK_MENU(menu->m_menu),
1533 (GtkWidget *) NULL, // parent menu shell
1534 (GtkWidget *) NULL, // parent menu item
1535 posfunc, // function to position it
1536 userdata, // client data
1537 0, // button used to activate it
1538 wxGtkTimeLastClick // the time of activation
1539 );
1540
1541 while (is_waiting)
1542 {
1543 gtk_main_iteration();
1544 }
1545
1546 gtk_signal_disconnect(GTK_OBJECT(menu->m_menu), handler);
1547
1548 wxMenuEvent eventClose(wxEVT_MENU_CLOSE, -1, menu);
1549 DoCommonMenuCallbackCode(menu, eventClose);
1550
1551 return true;
1552}
1553
1554#endif // wxUSE_MENUS_NATIVE
wxWidgets (Impactor)