src/osx/menu_osx.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/osx/menu_osx.cpp
   3 // Purpose:     wxMenu, wxMenuBar, wxMenuItem
   4 // Author:      Stefan Csomor
   5 // Modified by:
   6 // Created:     1998-01-01
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Stefan Csomor
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // headers & declarations
  14 // ============================================================================
  15
  16 // wxWidgets headers
  17 // -----------------
  18
  19 #include "wx/wxprec.h"
  20
  21 #if wxUSE_MENUS
  22
  23 #include "wx/menu.h"
  24
  25 #ifndef WX_PRECOMP
  26     #include "wx/log.h"
  27     #include "wx/app.h"
  28     #include "wx/utils.h"
  29     #include "wx/frame.h"
  30     #include "wx/dialog.h"
  31     #include "wx/menuitem.h"
  32 #endif
  33
  34 #include "wx/osx/private.h"
  35
  36 // other standard headers
  37 // ----------------------
  38 #include <string.h>
  39
  40 IMPLEMENT_ABSTRACT_CLASS( wxMenuImpl , wxObject )
  41
  42 wxMenuImpl::~wxMenuImpl()
  43 {
  44 }
  45
  46 IMPLEMENT_DYNAMIC_CLASS(wxMenu, wxEvtHandler)
  47 IMPLEMENT_DYNAMIC_CLASS(wxMenuBar, wxEvtHandler)
  48
  49 // the (popup) menu title has this special id
  50 static const int idMenuTitle = -3;
  51
  52 // ============================================================================
  53 // implementation
  54 // ============================================================================
  55
  56 // Menus
  57
  58 // Construct a menu with optional title (then use append)
  59
  60 static
  61 wxMenu *
  62 _wxMenuAt(const wxMenuList &menuList, size_t pos)
  63 {
  64     wxMenuList::compatibility_iterator menuIter = menuList.GetFirst();
  65
  66     while (pos-- > 0)
  67         menuIter = menuIter->GetNext();
  68
  69     return menuIter->GetData() ;
  70 }
  71
  72 void wxMenu::Init()
  73 {
  74     m_doBreak = false;
  75     m_startRadioGroup = -1;
  76     m_allowRearrange = true;
  77     m_noEventsMode = false;
  78
  79     m_peer = wxMenuImpl::Create( this, wxStripMenuCodes(m_title) );
  80
  81
  82     // if we have a title, insert it in the beginning of the menu
  83     if ( !m_title.empty() )
  84     {
  85         Append(idMenuTitle, m_title) ;
  86         AppendSeparator() ;
  87     }
  88 }
  89
  90 wxMenu::~wxMenu()
  91 {
  92     delete m_peer;
  93 }
  94
  95 WXHMENU wxMenu::GetHMenu() const
  96 {
  97     if ( m_peer )
  98         return m_peer->GetHMenu();
  99     return NULL;
 100 }
 101
 102 void wxMenu::Break()
 103 {
 104     // not available on the mac platform
 105 }
 106
 107 void wxMenu::Attach(wxMenuBarBase *menubar)
 108 {
 109     wxMenuBase::Attach(menubar);
 110
 111     EndRadioGroup();
 112 }
 113
 114 void wxMenu::SetAllowRearrange( bool allow )
 115 {
 116     m_allowRearrange = allow;
 117 }
 118
 119 void wxMenu::SetNoEventsMode( bool noEvents )
 120 {
 121     m_noEventsMode = noEvents;
 122 }
 123
 124 // function appends a new item or submenu to the menu
 125 // append a new item or submenu to the menu
 126 bool wxMenu::DoInsertOrAppend(wxMenuItem *pItem, size_t pos)
 127 {
 128     wxASSERT_MSG( pItem != NULL, wxT("can't append NULL item to the menu") );
 129     m_peer->InsertOrAppend( pItem, pos );
 130
 131     if ( pItem->IsSeparator() )
 132     {
 133         // nothing to do here
 134     }
 135     else
 136     {
 137         wxMenu *pSubMenu = pItem->GetSubMenu() ;
 138         if ( pSubMenu != NULL )
 139         {
 140             wxASSERT_MSG( pSubMenu->GetHMenu() != NULL , wxT("invalid submenu added"));
 141             pSubMenu->m_menuParent = this ;
 142
 143             pSubMenu->DoRearrange();
 144         }
 145         else
 146         {
 147             if ( pItem->GetId() == idMenuTitle )
 148                 pItem->GetMenu()->Enable( idMenuTitle, false );
 149         }
 150     }
 151
 152     // if we're already attached to the menubar, we must update it
 153     if ( IsAttached() && GetMenuBar()->IsAttached() )
 154         GetMenuBar()->Refresh();
 155
 156     return true ;
 157 }
 158
 159 void wxMenu::EndRadioGroup()
 160 {
 161     // we're not inside a radio group any longer
 162     m_startRadioGroup = -1;
 163 }
 164
 165 wxMenuItem* wxMenu::DoAppend(wxMenuItem *item)
 166 {
 167     wxCHECK_MSG( item, NULL, wxT("NULL item in wxMenu::DoAppend") );
 168
 169     bool check = false;
 170
 171     if ( item->GetKind() == wxITEM_RADIO )
 172     {
 173         int count = GetMenuItemCount();
 174
 175         if ( m_startRadioGroup == -1 )
 176         {
 177             // start a new radio group
 178             m_startRadioGroup = count;
 179
 180             // for now it has just one element
 181             item->SetAsRadioGroupStart();
 182             item->SetRadioGroupEnd(m_startRadioGroup);
 183
 184             // ensure that we have a checked item in the radio group
 185             check = true;
 186         }
 187         else // extend the current radio group
 188         {
 189             // we need to update its end item
 190             item->SetRadioGroupStart(m_startRadioGroup);
 191             wxMenuItemList::compatibility_iterator node = GetMenuItems().Item(m_startRadioGroup);
 192
 193             if ( node )
 194             {
 195                 node->GetData()->SetRadioGroupEnd(count);
 196             }
 197             else
 198             {
 199                 wxFAIL_MSG( wxT("where is the radio group start item?") );
 200             }
 201         }
 202     }
 203     else // not a radio item
 204     {
 205         EndRadioGroup();
 206     }
 207
 208     if ( !wxMenuBase::DoAppend(item) || !DoInsertOrAppend(item) )
 209         return NULL;
 210
 211     if ( check )
 212         // check the item initially
 213         item->Check(true);
 214
 215     return item;
 216 }
 217
 218 wxMenuItem* wxMenu::DoInsert(size_t pos, wxMenuItem *item)
 219 {
 220     if (wxMenuBase::DoInsert(pos, item) && DoInsertOrAppend(item, pos))
 221         return item;
 222
 223     return NULL;
 224 }
 225
 226 wxMenuItem *wxMenu::DoRemove(wxMenuItem *item)
 227 {
 228 /*
 229     // we need to find the items position in the child list
 230     size_t pos;
 231     wxMenuItemList::compatibility_iterator node = GetMenuItems().GetFirst();
 232
 233     for ( pos = 0; node; pos++ )
 234     {
 235         if ( node->GetData() == item )
 236             break;
 237
 238         node = node->GetNext();
 239     }
 240
 241     // DoRemove() (unlike Remove) can only be called for existing item!
 242     wxCHECK_MSG( node, NULL, wxT("bug in wxMenu::Remove logic") );
 243
 244     wxOSXMenuRemoveItem(m_hMenu , pos );
 245     */
 246     m_peer->Remove( item );
 247     // and from internal data structures
 248     return wxMenuBase::DoRemove(item);
 249 }
 250
 251 void wxMenu::SetTitle(const wxString& label)
 252 {
 253     m_title = label ;
 254     m_peer->SetTitle( wxStripMenuCodes( label ) );
 255 }
 256
 257 bool wxMenu::ProcessCommand(wxCommandEvent & event)
 258 {
 259     bool processed = false;
 260
 261     // Try the menu's event handler
 262     if ( /* !processed && */ GetEventHandler())
 263         processed = GetEventHandler()->SafelyProcessEvent(event);
 264
 265     // Try the window the menu was popped up from
 266     // (and up through the hierarchy)
 267     wxWindow *win = GetWindow();
 268     if ( !processed && win )
 269         processed = win->HandleWindowEvent(event);
 270
 271     return processed;
 272 }
 273
 274 // ---------------------------------------------------------------------------
 275 // other
 276 // ---------------------------------------------------------------------------
 277
 278 // MacOS needs to know about submenus somewhere within this menu
 279 // before it can be displayed, also hide special menu items
 280 // like preferences that are handled by the OS
 281 void wxMenu::DoRearrange()
 282 {
 283     if ( !AllowRearrange() )
 284         return;
 285
 286     wxMenuItem* previousItem = NULL ;
 287     size_t pos ;
 288     wxMenuItemList::compatibility_iterator node;
 289     wxMenuItem *item;
 290
 291     for (pos = 0, node = GetMenuItems().GetFirst(); node; node = node->GetNext(), pos++)
 292     {
 293         item = (wxMenuItem *)node->GetData();
 294         wxMenu* subMenu = item->GetSubMenu() ;
 295         if (subMenu)
 296         {
 297             // already done
 298         }
 299         else // normal item
 300         {
 301             // what we do here is to hide the special items which are
 302             // shown in the application menu anyhow -- it doesn't make
 303             // sense to show them in their normal place as well
 304             if ( item->GetId() == wxApp::s_macAboutMenuItemId ||
 305                     item->GetId() == wxApp::s_macPreferencesMenuItemId ||
 306                     item->GetId() == wxApp::s_macExitMenuItemId )
 307
 308             {
 309                 item->GetPeer()->Hide( true );
 310
 311                 // also check for a separator which was used just to
 312                 // separate this item from the others, so don't leave
 313                 // separator at the menu start or end nor 2 consecutive
 314                 // separators
 315                 wxMenuItemList::compatibility_iterator nextNode = node->GetNext();
 316                 wxMenuItem *next = nextNode ? nextNode->GetData() : NULL;
 317
 318                 wxMenuItem *sepToHide = 0;
 319                 if ( !previousItem && next && next->IsSeparator() )
 320                 {
 321                     // next (i.e. second as we must be first) item is
 322                     // the separator to hide
 323                     wxASSERT_MSG( pos == 0, wxT("should be the menu start") );
 324                     sepToHide = next;
 325                 }
 326                 else if ( GetMenuItems().GetCount() == pos + 1 &&
 327                             previousItem != NULL &&
 328                                 previousItem->IsSeparator() )
 329                 {
 330                     // prev item is a trailing separator we want to hide
 331                     sepToHide = previousItem;
 332                 }
 333                 else if ( previousItem && previousItem->IsSeparator() &&
 334                             next && next->IsSeparator() )
 335                 {
 336                     // two consecutive separators, this is one too many
 337                     sepToHide = next;
 338                 }
 339
 340                 if ( sepToHide )
 341                 {
 342                     // hide the separator as well
 343                     sepToHide->GetPeer()->Hide( true );
 344                 }
 345             }
 346         }
 347
 348         previousItem = item ;
 349     }
 350 }
 351
 352
 353 bool wxMenu::HandleCommandUpdateStatus( wxMenuItem* item, wxWindow* senderWindow )
 354 {
 355     int id = item ? item->GetId() : 0;
 356     wxUpdateUIEvent event(id);
 357     event.SetEventObject( this );
 358
 359     bool processed = false;
 360
 361     // Try the menu's event handler
 362     {
 363         wxEvtHandler *handler = GetEventHandler();
 364         if ( handler )
 365             processed = handler->ProcessEvent(event);
 366     }
 367
 368     // Try the window the menu was popped up from
 369     // (and up through the hierarchy)
 370     if ( !processed )
 371     {
 372         wxWindow *win = GetWindow();
 373         if ( win )
 374             processed = win->HandleWindowEvent(event);
 375     }
 376
 377     if ( !processed && senderWindow != NULL)
 378     {
 379         processed = senderWindow->HandleWindowEvent(event);
 380     }
 381
 382     if ( processed )
 383     {
 384         // if anything changed, update the changed attribute
 385         if (event.GetSetText())
 386             SetLabel(id, event.GetText());
 387         if (event.GetSetChecked())
 388             Check(id, event.GetChecked());
 389         if (event.GetSetEnabled())
 390             Enable(id, event.GetEnabled());
 391     }
 392     else
 393     {
 394 #if wxOSX_USE_CARBON
 395         // these two items are also managed by the Carbon Menu Manager, therefore we must
 396         // always reset them ourselves
 397         UInt32 cmd = 0;
 398
 399         if ( id == wxApp::s_macExitMenuItemId )
 400         {
 401             cmd = kHICommandQuit;
 402         }
 403         else if (id == wxApp::s_macPreferencesMenuItemId )
 404         {
 405             cmd = kHICommandPreferences;
 406         }
 407
 408         if ( cmd != 0 )
 409         {
 410             if ( !item->IsEnabled() || wxDialog::OSXHasModalDialogsOpen() )
 411                 DisableMenuCommand( NULL , cmd ) ;
 412             else
 413                 EnableMenuCommand( NULL , cmd ) ;
 414
 415         }
 416 #endif
 417     }
 418
 419     return processed;
 420 }
 421
 422 bool wxMenu::HandleCommandProcess( wxMenuItem* item, wxWindow* senderWindow )
 423 {
 424     int id = item ? item->GetId() : 0;
 425     bool processed = false;
 426     if (item->IsCheckable())
 427         item->Check( !item->IsChecked() ) ;
 428
 429     if ( SendEvent( id , item->IsCheckable() ? item->IsChecked() : -1 ) )
 430         processed = true ;
 431     else
 432     {
 433         if ( senderWindow != NULL )
 434         {
 435             wxCommandEvent event(wxEVT_COMMAND_MENU_SELECTED , id);
 436             event.SetEventObject(senderWindow);
 437             event.SetInt(item->IsCheckable() ? item->IsChecked() : -1);
 438
 439             if ( senderWindow->HandleWindowEvent(event) )
 440                 processed = true ;
 441         }
 442     }
 443     return processed;
 444 }
 445
 446 void wxMenu::HandleMenuItemHighlighted( wxMenuItem* item )
 447 {
 448     int id = item ? item->GetId() : 0;
 449     wxMenuEvent wxevent(wxEVT_MENU_HIGHLIGHT, id, this);
 450     DoHandleMenuEvent( wxevent );
 451 }
 452
 453 void wxMenu::HandleMenuOpened()
 454 {
 455     wxMenuEvent wxevent(wxEVT_MENU_OPEN, 0, this);
 456     DoHandleMenuEvent( wxevent );
 457 }
 458
 459 void wxMenu::HandleMenuClosed()
 460 {
 461     wxMenuEvent wxevent(wxEVT_MENU_CLOSE, 0, this);
 462     DoHandleMenuEvent( wxevent );
 463 }
 464
 465 bool wxMenu::DoHandleMenuEvent(wxEvent& wxevent)
 466 {
 467     wxevent.SetEventObject(this);
 468     wxEvtHandler* handler = GetEventHandler();
 469     if (handler && handler->ProcessEvent(wxevent))
 470     {
 471         return true;
 472     }
 473     else
 474     {
 475         wxWindow *win = GetWindow();
 476         if (win)
 477         {
 478             if ( win->HandleWindowEvent(wxevent) )
 479                 return true;
 480         }
 481     }
 482     return false;
 483 }
 484
 485 // Menu Bar
 486
 487 /*
 488
 489 Mac Implementation note :
 490
 491 The Mac has only one global menubar, so we attempt to install the currently
 492 active menubar from a frame, we currently don't take into account mdi-frames
 493 which would ask for menu-merging
 494
 495 Secondly there is no mac api for changing a menubar that is not the current
 496 menubar, so we have to wait for preparing the actual menubar until the
 497 wxMenubar is to be used
 498
 499 We can in subsequent versions use MacInstallMenuBar to provide some sort of
 500 auto-merge for MDI in case this will be necessary
 501
 502 */
 503
 504 wxMenuBar* wxMenuBar::s_macInstalledMenuBar = NULL ;
 505 wxMenuBar* wxMenuBar::s_macCommonMenuBar = NULL ;
 506 bool     wxMenuBar::s_macAutoWindowMenu = true ;
 507 WXHMENU  wxMenuBar::s_macWindowMenuHandle = NULL ;
 508
 509 void wxMenuBar::Init()
 510 {
 511     m_eventHandler = this;
 512     m_menuBarFrame = NULL;
 513     m_rootMenu = new wxMenu();
 514     m_rootMenu->Attach(this);
 515
 516     m_appleMenu = new wxMenu();
 517     m_appleMenu->SetAllowRearrange(false);
 518
 519     // Create standard items unless the application explicitly disabled this by
 520     // setting the corresponding ids to wxID_NONE: although this is not
 521     // recommended, sometimes these items really don't make sense.
 522     if ( wxApp::s_macAboutMenuItemId != wxID_NONE )
 523     {
 524         wxString aboutLabel("About");
 525         if ( wxTheApp )
 526             aboutLabel << ' ' << wxTheApp->GetAppDisplayName();
 527         else
 528             aboutLabel << "...";
 529         m_appleMenu->Append( wxApp::s_macAboutMenuItemId, aboutLabel);
 530         m_appleMenu->AppendSeparator();
 531     }
 532
 533 #if !wxOSX_USE_CARBON
 534     if ( wxApp::s_macPreferencesMenuItemId != wxID_NONE )
 535     {
 536         m_appleMenu->Append( wxApp::s_macPreferencesMenuItemId, "Preferences..." );
 537         m_appleMenu->AppendSeparator();
 538     }
 539
 540     // Do always add "Quit" item unconditionally however, it can't be disabled.
 541     m_appleMenu->Append( wxApp::s_macExitMenuItemId, "Quit\tCtrl+Q" );
 542 #endif // !wxOSX_USE_CARBON
 543
 544     m_rootMenu->AppendSubMenu(m_appleMenu, "\x14") ;
 545 }
 546
 547 wxMenuBar::wxMenuBar()
 548 {
 549     Init();
 550 }
 551
 552 wxMenuBar::wxMenuBar( long WXUNUSED(style) )
 553 {
 554     Init();
 555 }
 556
 557 wxMenuBar::wxMenuBar(size_t count, wxMenu *menus[], const wxString titles[], long WXUNUSED(style))
 558 {
 559     Init();
 560
 561     m_titles.Alloc(count);
 562
 563     for ( size_t i = 0; i < count; i++ )
 564     {
 565         m_menus.Append(menus[i]);
 566         m_titles.Add(titles[i]);
 567
 568         menus[i]->Attach(this);
 569         Append( menus[i], titles[i] );
 570     }
 571 }
 572
 573 wxMenuBar::~wxMenuBar()
 574 {
 575     if (s_macCommonMenuBar == this)
 576         s_macCommonMenuBar = NULL;
 577
 578     if (s_macInstalledMenuBar == this)
 579     {
 580         s_macInstalledMenuBar = NULL;
 581     }
 582 }
 583
 584 void wxMenuBar::Refresh(bool WXUNUSED(eraseBackground), const wxRect *WXUNUSED(rect))
 585 {
 586     wxCHECK_RET( IsAttached(), wxT("can't refresh unatteched menubar") );
 587 }
 588
 589 void wxMenuBar::MacInstallMenuBar()
 590 {
 591     if ( s_macInstalledMenuBar == this )
 592         return ;
 593
 594     m_rootMenu->GetPeer()->MakeRoot();
 595
 596 #if 0
 597
 598     MenuBarHandle menubar = NULL ;
 599
 600     menubar = NewHandleClear( 6 /* sizeof( MenuBarHeader ) */ ) ;
 601
 602     ::SetMenuBar( menubar ) ;
 603     DisposeMenuBar( menubar ) ;
 604     MenuHandle appleMenu = NULL ;
 605
 606     verify_noerr( CreateNewMenu( kwxMacAppleMenuId , 0 , &appleMenu ) ) ;
 607     verify_noerr( SetMenuTitleWithCFString( appleMenu , CFSTR( "\x14" ) ) );
 608
 609     // Add About/Preferences separator only on OS X
 610     // KH/RN: Separator is always present on 10.3 but not on 10.2
 611     // However, the change from 10.2 to 10.3 suggests it is preferred
 612     InsertMenuItemTextWithCFString( appleMenu,
 613                 CFSTR(""), 0, kMenuItemAttrSeparator, 0);
 614     InsertMenuItemTextWithCFString( appleMenu,
 615                 CFSTR("About..."), 0, 0, 0);
 616     MacInsertMenu( appleMenu , 0 ) ;
 617
 618     // if we have a mac help menu, clean it up before adding new items
 619     MenuHandle helpMenuHandle ;
 620     MenuItemIndex firstUserHelpMenuItem ;
 621
 622     if ( UMAGetHelpMenuDontCreate( &helpMenuHandle , &firstUserHelpMenuItem) == noErr )
 623     {
 624         for ( int i = CountMenuItems( helpMenuHandle ) ; i >= firstUserHelpMenuItem ; --i )
 625             DeleteMenuItem( helpMenuHandle , i ) ;
 626     }
 627     else
 628     {
 629         helpMenuHandle = NULL ;
 630     }
 631
 632     if ( wxApp::s_macPreferencesMenuItemId)
 633     {
 634         wxMenuItem *item = FindItem( wxApp::s_macPreferencesMenuItemId , NULL ) ;
 635         if ( item == NULL || !(item->IsEnabled()) )
 636             DisableMenuCommand( NULL , kHICommandPreferences ) ;
 637         else
 638             EnableMenuCommand( NULL , kHICommandPreferences ) ;
 639     }
 640
 641     // Unlike preferences which may or may not exist, the Quit item should be always
 642     // enabled unless it is added by the application and then disabled, otherwise
 643     // a program would be required to add an item with wxID_EXIT in order to get the
 644     // Quit menu item to be enabled, which seems a bit burdensome.
 645     if ( wxApp::s_macExitMenuItemId)
 646     {
 647         wxMenuItem *item = FindItem( wxApp::s_macExitMenuItemId , NULL ) ;
 648         if ( item != NULL && !(item->IsEnabled()) )
 649             DisableMenuCommand( NULL , kHICommandQuit ) ;
 650         else
 651             EnableMenuCommand( NULL , kHICommandQuit ) ;
 652     }
 653
 654     wxString strippedHelpMenuTitle = wxStripMenuCodes( wxApp::s_macHelpMenuTitleName ) ;
 655     wxString strippedTranslatedHelpMenuTitle = wxStripMenuCodes( wxString( _("&Help") ) ) ;
 656     wxMenuList::compatibility_iterator menuIter = m_menus.GetFirst();
 657     for (size_t i = 0; i < m_menus.GetCount(); i++, menuIter = menuIter->GetNext())
 658     {
 659         wxMenuItemList::compatibility_iterator node;
 660         wxMenuItem *item;
 661         wxMenu* menu = menuIter->GetData() , *subMenu = NULL ;
 662         wxString strippedMenuTitle = wxStripMenuCodes(m_titles[i]);
 663
 664         if ( strippedMenuTitle == wxT("?") || strippedMenuTitle == strippedHelpMenuTitle || strippedMenuTitle == strippedTranslatedHelpMenuTitle )
 665         {
 666             for (node = menu->GetMenuItems().GetFirst(); node; node = node->GetNext())
 667             {
 668                 item = (wxMenuItem *)node->GetData();
 669                 subMenu = item->GetSubMenu() ;
 670                 if (subMenu)
 671                 {
 672                     UMAAppendMenuItem(mh, wxStripMenuCodes(item->GetText()) , wxFont::GetDefaultEncoding() );
 673                     MenuItemIndex position = CountMenuItems(mh);
 674                     ::SetMenuItemHierarchicalMenu(mh, position, MAC_WXHMENU(subMenu->GetHMenu()));
 675                 }
 676                 else
 677                 {
 678                     if ( item->GetId() != wxApp::s_macAboutMenuItemId )
 679                     {
 680                         // we have found a user help menu and an item other than the about item,
 681                         // so we can create the mac help menu now, if we haven't created it yet
 682                         if ( helpMenuHandle == NULL )
 683                         {
 684                             if ( UMAGetHelpMenu( &helpMenuHandle , &firstUserHelpMenuItem) != noErr )
 685                             {
 686                                 helpMenuHandle = NULL ;
 687                                 break ;
 688                             }
 689                         }
 690                     }
 691
 692                     if ( item->IsSeparator() )
 693                     {
 694                         if ( helpMenuHandle )
 695                             AppendMenuItemTextWithCFString( helpMenuHandle,
 696                                 CFSTR(""), kMenuItemAttrSeparator, 0,NULL);
 697                     }
 698                     else
 699                     {
 700                         wxAcceleratorEntry*
 701                             entry = wxAcceleratorEntry::Create( item->GetItemLabel() ) ;
 702
 703                         if ( item->GetId() == wxApp::s_macAboutMenuItemId )
 704                         {
 705                             // this will be taken care of below
 706                         }
 707                         else
 708                         {
 709                             if ( helpMenuHandle )
 710                             {
 711                                 UMAAppendMenuItem(helpMenuHandle, wxStripMenuCodes(item->GetItemLabel()) , wxFont::GetDefaultEncoding(), entry);
 712                                 SetMenuItemCommandID( helpMenuHandle , CountMenuItems(helpMenuHandle) , wxIdToMacCommand ( item->GetId() ) ) ;
 713                                 SetMenuItemRefCon( helpMenuHandle , CountMenuItems(helpMenuHandle) , (URefCon) item ) ;
 714                             }
 715                         }
 716
 717                         delete entry ;
 718                     }
 719                 }
 720             }
 721         }
 722
 723         else if ( ( m_titles[i] == wxT("Window") || m_titles[i] == wxT("&Window") )
 724                 && GetAutoWindowMenu() )
 725         {
 726             if ( MacGetWindowMenuHMenu() == NULL )
 727             {
 728                 CreateStandardWindowMenu( 0 , (MenuHandle*) &s_macWindowMenuHandle ) ;
 729             }
 730
 731             MenuRef wm = (MenuRef)MacGetWindowMenuHMenu();
 732             if ( wm == NULL )
 733                 break;
 734
 735             // get the insertion point in the standard menu
 736             MenuItemIndex winListStart;
 737             GetIndMenuItemWithCommandID(wm,
 738                         kHICommandWindowListSeparator, 1, NULL, &winListStart);
 739
 740             // add a separator so that the standard items and the custom items
 741             // aren't mixed together, but only if this is the first run
 742             OSStatus err = GetIndMenuItemWithCommandID(wm,
 743                         'WXWM', 1, NULL, NULL);
 744
 745             if ( err == menuItemNotFoundErr )
 746             {
 747                 InsertMenuItemTextWithCFString( wm,
 748                         CFSTR(""), winListStart-1, kMenuItemAttrSeparator, 'WXWM');
 749             }
 750
 751             wxInsertMenuItemsInMenu(menu, wm, winListStart);
 752         }
 753         else
 754         {
 755             UMASetMenuTitle( MAC_WXHMENU(menu->GetHMenu()) , m_titles[i], GetFont().GetEncoding()  ) ;
 756             menu->MacBeforeDisplay(false) ;
 757
 758             ::InsertMenu(MAC_WXHMENU(_wxMenuAt(m_menus, i)->GetHMenu()), 0);
 759         }
 760     }
 761
 762     // take care of the about menu item wherever it is
 763     {
 764         wxMenu* aboutMenu ;
 765         wxMenuItem *aboutMenuItem = FindItem(wxApp::s_macAboutMenuItemId , &aboutMenu) ;
 766         if ( aboutMenuItem )
 767         {
 768             wxAcceleratorEntry*
 769                 entry = wxAcceleratorEntry::Create( aboutMenuItem->GetItemLabel() ) ;
 770             UMASetMenuItemText( GetMenuHandle( kwxMacAppleMenuId ) , 1 , wxStripMenuCodes ( aboutMenuItem->GetItemLabel() ) , wxFont::GetDefaultEncoding() );
 771             UMAEnableMenuItem( GetMenuHandle( kwxMacAppleMenuId ) , 1 , true );
 772             SetMenuItemCommandID( GetMenuHandle( kwxMacAppleMenuId ) , 1 , kHICommandAbout ) ;
 773             SetMenuItemRefCon(GetMenuHandle( kwxMacAppleMenuId ) , 1 , (URefCon)aboutMenuItem ) ;
 774             UMASetMenuItemShortcut( GetMenuHandle( kwxMacAppleMenuId ) , 1 , entry ) ;
 775             delete entry;
 776         }
 777     }
 778
 779     if ( GetAutoWindowMenu() )
 780     {
 781         if ( MacGetWindowMenuHMenu() == NULL )
 782             CreateStandardWindowMenu( 0 , (MenuHandle*) &s_macWindowMenuHandle ) ;
 783
 784         InsertMenu( (MenuHandle) MacGetWindowMenuHMenu() , 0 ) ;
 785     }
 786
 787     ::DrawMenuBar() ;
 788 #endif
 789
 790     s_macInstalledMenuBar = this;
 791 }
 792
 793 void wxMenuBar::EnableTop(size_t pos, bool enable)
 794 {
 795     wxCHECK_RET( IsAttached(), wxT("doesn't work with unattached menubars") );
 796
 797     m_rootMenu->FindItemByPosition( pos )->Enable(enable);
 798
 799     Refresh();
 800 }
 801
 802 bool wxMenuBar::Enable(bool enable)
 803 {
 804     wxCHECK_MSG( IsAttached(), false, wxT("doesn't work with unattached menubars") );
 805
 806     size_t i;
 807     for (i = 0; i < GetMenuCount(); i++)
 808         EnableTop(i, enable);
 809
 810     return true;
 811 }
 812
 813 void wxMenuBar::SetMenuLabel(size_t pos, const wxString& label)
 814 {
 815     wxCHECK_RET( pos < GetMenuCount(), wxT("invalid menu index") );
 816
 817     m_titles[pos] = label;
 818
 819     if ( !IsAttached() )
 820         return;
 821
 822     _wxMenuAt(m_menus, pos)->SetTitle( label ) ;
 823 }
 824
 825 wxString wxMenuBar::GetMenuLabel(size_t pos) const
 826 {
 827     wxCHECK_MSG( pos < GetMenuCount(), wxEmptyString,
 828                  wxT("invalid menu index in wxMenuBar::GetMenuLabel") );
 829
 830     return m_titles[pos];
 831 }
 832
 833 int wxMenuBar::FindMenu(const wxString& title)
 834 {
 835     wxString menuTitle = wxStripMenuCodes(title);
 836
 837     size_t count = GetMenuCount();
 838     for ( size_t i = 0; i < count; i++ )
 839     {
 840         wxString title = wxStripMenuCodes(m_titles[i]);
 841         if ( menuTitle == title )
 842             return i;
 843     }
 844
 845     return wxNOT_FOUND;
 846 }
 847
 848 // ---------------------------------------------------------------------------
 849 // wxMenuBar construction
 850 // ---------------------------------------------------------------------------
 851
 852 const int firstMenuPos = 1; // to account for the 0th application menu on mac
 853
 854 wxMenu *wxMenuBar::Replace(size_t pos, wxMenu *menu, const wxString& title)
 855 {
 856     wxMenu *menuOld = wxMenuBarBase::Replace(pos, menu, title);
 857     if ( !menuOld )
 858         return NULL;
 859
 860     m_titles[pos] = title;
 861
 862     wxMenuItem* item = m_rootMenu->FindItemByPosition(pos+firstMenuPos);
 863     m_rootMenu->Remove(item);
 864     m_rootMenu->Insert( pos+firstMenuPos, wxMenuItem::New( m_rootMenu, wxID_ANY, title, "", wxITEM_NORMAL, menu ) );
 865
 866     return menuOld;
 867 }
 868
 869 bool wxMenuBar::Insert(size_t pos, wxMenu *menu, const wxString& title)
 870 {
 871     if ( !wxMenuBarBase::Insert(pos, menu, title) )
 872         return false;
 873
 874     m_titles.Insert(title, pos);
 875
 876     m_rootMenu->Insert( pos+firstMenuPos, wxMenuItem::New( m_rootMenu, wxID_ANY, title, "", wxITEM_NORMAL, menu ) );
 877
 878     return true;
 879 }
 880
 881 wxMenu *wxMenuBar::Remove(size_t pos)
 882 {
 883     wxMenu *menu = wxMenuBarBase::Remove(pos);
 884     if ( !menu )
 885         return NULL;
 886
 887     wxMenuItem* item = m_rootMenu->FindItemByPosition(pos+firstMenuPos);
 888     m_rootMenu->Remove(item);
 889
 890     m_titles.RemoveAt(pos);
 891
 892     return menu;
 893 }
 894
 895 bool wxMenuBar::Append(wxMenu *menu, const wxString& title)
 896 {
 897     WXHMENU submenu = menu ? menu->GetHMenu() : 0;
 898         wxCHECK_MSG( submenu, false, wxT("can't append invalid menu to menubar") );
 899
 900     if ( !wxMenuBarBase::Append(menu, title) )
 901         return false;
 902
 903     m_titles.Add(title);
 904
 905     m_rootMenu->AppendSubMenu(menu, title);
 906
 907     return true;
 908 }
 909
 910 void wxMenuBar::Detach()
 911 {
 912     wxMenuBarBase::Detach() ;
 913 }
 914
 915 void wxMenuBar::Attach(wxFrame *frame)
 916 {
 917     wxMenuBarBase::Attach( frame ) ;
 918 }
 919
 920 // ---------------------------------------------------------------------------
 921 // wxMenuBar searching for menu items
 922 // ---------------------------------------------------------------------------
 923
 924 // Find the itemString in menuString, and return the item id or wxNOT_FOUND
 925 int wxMenuBar::FindMenuItem(const wxString& menuString,
 926                             const wxString& itemString) const
 927 {
 928     wxString menuLabel = wxStripMenuCodes(menuString);
 929     size_t count = GetMenuCount();
 930     for ( size_t i = 0; i < count; i++ )
 931     {
 932         wxString title = wxStripMenuCodes(m_titles[i]);
 933         if ( menuLabel == title )
 934             return _wxMenuAt(m_menus, i)->FindItem(itemString);
 935     }
 936
 937     return wxNOT_FOUND;
 938 }
 939
 940 wxMenuItem *wxMenuBar::FindItem(int id, wxMenu **itemMenu) const
 941 {
 942     if ( itemMenu )
 943         *itemMenu = NULL;
 944
 945     wxMenuItem *item = NULL;
 946     size_t count = GetMenuCount();
 947     for ( size_t i = 0; !item && (i < count); i++ )
 948         item = _wxMenuAt(m_menus, i)->FindItem(id, itemMenu);
 949
 950     return item;
 951 }
 952
 953 #endif