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