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