src/gtk/menu.cpp

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