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