src/gtk/menu.cpp

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