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: menu.cpp 54129 2008-06-11 19:30:52Z SC $
   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     m_appleMenu->Append( wxApp::s_macAboutMenuItemId, "About..." );
 519     m_appleMenu->AppendSeparator();
 520 #if !wxOSX_USE_CARBON
 521     m_appleMenu->Append( wxApp::s_macPreferencesMenuItemId, "Preferences..." );
 522     m_appleMenu->AppendSeparator();
 523     m_appleMenu->Append( wxApp::s_macExitMenuItemId, "Quit\tCtrl+Q" );
 524 #endif
 525
 526     m_rootMenu->AppendSubMenu(m_appleMenu, "\x14") ;
 527 }
 528
 529 wxMenuBar::wxMenuBar()
 530 {
 531     Init();
 532 }
 533
 534 wxMenuBar::wxMenuBar( long WXUNUSED(style) )
 535 {
 536     Init();
 537 }
 538
 539 wxMenuBar::wxMenuBar(size_t count, wxMenu *menus[], const wxString titles[], long WXUNUSED(style))
 540 {
 541     Init();
 542
 543     m_titles.Alloc(count);
 544
 545     for ( size_t i = 0; i < count; i++ )
 546     {
 547         m_menus.Append(menus[i]);
 548         m_titles.Add(titles[i]);
 549
 550         menus[i]->Attach(this);
 551         Append( menus[i], titles[i] );
 552     }
 553 }
 554
 555 wxMenuBar::~wxMenuBar()
 556 {
 557     if (s_macCommonMenuBar == this)
 558         s_macCommonMenuBar = NULL;
 559
 560     if (s_macInstalledMenuBar == this)
 561     {
 562         s_macInstalledMenuBar = NULL;
 563     }
 564 }
 565
 566 void wxMenuBar::Refresh(bool WXUNUSED(eraseBackground), const wxRect *WXUNUSED(rect))
 567 {
 568     wxCHECK_RET( IsAttached(), wxT("can't refresh unatteched menubar") );
 569 }
 570
 571 void wxMenuBar::MacInstallMenuBar()
 572 {
 573     if ( s_macInstalledMenuBar == this )
 574         return ;
 575
 576     m_rootMenu->GetPeer()->MakeRoot();
 577
 578 #if 0
 579
 580     MenuBarHandle menubar = NULL ;
 581
 582     menubar = NewHandleClear( 6 /* sizeof( MenuBarHeader ) */ ) ;
 583
 584     ::SetMenuBar( menubar ) ;
 585     DisposeMenuBar( menubar ) ;
 586     MenuHandle appleMenu = NULL ;
 587
 588     verify_noerr( CreateNewMenu( kwxMacAppleMenuId , 0 , &appleMenu ) ) ;
 589     verify_noerr( SetMenuTitleWithCFString( appleMenu , CFSTR( "\x14" ) ) );
 590
 591     // Add About/Preferences separator only on OS X
 592     // KH/RN: Separator is always present on 10.3 but not on 10.2
 593     // However, the change from 10.2 to 10.3 suggests it is preferred
 594     InsertMenuItemTextWithCFString( appleMenu,
 595                 CFSTR(""), 0, kMenuItemAttrSeparator, 0);
 596     InsertMenuItemTextWithCFString( appleMenu,
 597                 CFSTR("About..."), 0, 0, 0);
 598     MacInsertMenu( appleMenu , 0 ) ;
 599
 600     // if we have a mac help menu, clean it up before adding new items
 601     MenuHandle helpMenuHandle ;
 602     MenuItemIndex firstUserHelpMenuItem ;
 603
 604     if ( UMAGetHelpMenuDontCreate( &helpMenuHandle , &firstUserHelpMenuItem) == noErr )
 605     {
 606         for ( int i = CountMenuItems( helpMenuHandle ) ; i >= firstUserHelpMenuItem ; --i )
 607             DeleteMenuItem( helpMenuHandle , i ) ;
 608     }
 609     else
 610     {
 611         helpMenuHandle = NULL ;
 612     }
 613
 614     if ( wxApp::s_macPreferencesMenuItemId)
 615     {
 616         wxMenuItem *item = FindItem( wxApp::s_macPreferencesMenuItemId , NULL ) ;
 617         if ( item == NULL || !(item->IsEnabled()) )
 618             DisableMenuCommand( NULL , kHICommandPreferences ) ;
 619         else
 620             EnableMenuCommand( NULL , kHICommandPreferences ) ;
 621     }
 622
 623     // Unlike preferences which may or may not exist, the Quit item should be always
 624     // enabled unless it is added by the application and then disabled, otherwise
 625     // a program would be required to add an item with wxID_EXIT in order to get the
 626     // Quit menu item to be enabled, which seems a bit burdensome.
 627     if ( wxApp::s_macExitMenuItemId)
 628     {
 629         wxMenuItem *item = FindItem( wxApp::s_macExitMenuItemId , NULL ) ;
 630         if ( item != NULL && !(item->IsEnabled()) )
 631             DisableMenuCommand( NULL , kHICommandQuit ) ;
 632         else
 633             EnableMenuCommand( NULL , kHICommandQuit ) ;
 634     }
 635
 636     wxString strippedHelpMenuTitle = wxStripMenuCodes( wxApp::s_macHelpMenuTitleName ) ;
 637     wxString strippedTranslatedHelpMenuTitle = wxStripMenuCodes( wxString( _("&Help") ) ) ;
 638     wxMenuList::compatibility_iterator menuIter = m_menus.GetFirst();
 639     for (size_t i = 0; i < m_menus.GetCount(); i++, menuIter = menuIter->GetNext())
 640     {
 641         wxMenuItemList::compatibility_iterator node;
 642         wxMenuItem *item;
 643         wxMenu* menu = menuIter->GetData() , *subMenu = NULL ;
 644         wxString strippedMenuTitle = wxStripMenuCodes(m_titles[i]);
 645
 646         if ( strippedMenuTitle == wxT("?") || strippedMenuTitle == strippedHelpMenuTitle || strippedMenuTitle == strippedTranslatedHelpMenuTitle )
 647         {
 648             for (node = menu->GetMenuItems().GetFirst(); node; node = node->GetNext())
 649             {
 650                 item = (wxMenuItem *)node->GetData();
 651                 subMenu = item->GetSubMenu() ;
 652                 if (subMenu)
 653                 {
 654                     UMAAppendMenuItem(mh, wxStripMenuCodes(item->GetText()) , wxFont::GetDefaultEncoding() );
 655                     MenuItemIndex position = CountMenuItems(mh);
 656                     ::SetMenuItemHierarchicalMenu(mh, position, MAC_WXHMENU(subMenu->GetHMenu()));
 657                 }
 658                 else
 659                 {
 660                     if ( item->GetId() != wxApp::s_macAboutMenuItemId )
 661                     {
 662                         // we have found a user help menu and an item other than the about item,
 663                         // so we can create the mac help menu now, if we haven't created it yet
 664                         if ( helpMenuHandle == NULL )
 665                         {
 666                             if ( UMAGetHelpMenu( &helpMenuHandle , &firstUserHelpMenuItem) != noErr )
 667                             {
 668                                 helpMenuHandle = NULL ;
 669                                 break ;
 670                             }
 671                         }
 672                     }
 673
 674                     if ( item->IsSeparator() )
 675                     {
 676                         if ( helpMenuHandle )
 677                             AppendMenuItemTextWithCFString( helpMenuHandle,
 678                                 CFSTR(""), kMenuItemAttrSeparator, 0,NULL);
 679                     }
 680                     else
 681                     {
 682                         wxAcceleratorEntry*
 683                             entry = wxAcceleratorEntry::Create( item->GetItemLabel() ) ;
 684
 685                         if ( item->GetId() == wxApp::s_macAboutMenuItemId )
 686                         {
 687                             // this will be taken care of below
 688                         }
 689                         else
 690                         {
 691                             if ( helpMenuHandle )
 692                             {
 693                                 UMAAppendMenuItem(helpMenuHandle, wxStripMenuCodes(item->GetItemLabel()) , wxFont::GetDefaultEncoding(), entry);
 694                                 SetMenuItemCommandID( helpMenuHandle , CountMenuItems(helpMenuHandle) , wxIdToMacCommand ( item->GetId() ) ) ;
 695                                 SetMenuItemRefCon( helpMenuHandle , CountMenuItems(helpMenuHandle) , (URefCon) item ) ;
 696                             }
 697                         }
 698
 699                         delete entry ;
 700                     }
 701                 }
 702             }
 703         }
 704
 705         else if ( ( m_titles[i] == wxT("Window") || m_titles[i] == wxT("&Window") )
 706                 && GetAutoWindowMenu() )
 707         {
 708             if ( MacGetWindowMenuHMenu() == NULL )
 709             {
 710                 CreateStandardWindowMenu( 0 , (MenuHandle*) &s_macWindowMenuHandle ) ;
 711             }
 712
 713             MenuRef wm = (MenuRef)MacGetWindowMenuHMenu();
 714             if ( wm == NULL )
 715                 break;
 716
 717             // get the insertion point in the standard menu
 718             MenuItemIndex winListStart;
 719             GetIndMenuItemWithCommandID(wm,
 720                         kHICommandWindowListSeparator, 1, NULL, &winListStart);
 721
 722             // add a separator so that the standard items and the custom items
 723             // aren't mixed together, but only if this is the first run
 724             OSStatus err = GetIndMenuItemWithCommandID(wm,
 725                         'WXWM', 1, NULL, NULL);
 726
 727             if ( err == menuItemNotFoundErr )
 728             {
 729                 InsertMenuItemTextWithCFString( wm,
 730                         CFSTR(""), winListStart-1, kMenuItemAttrSeparator, 'WXWM');
 731             }
 732
 733             wxInsertMenuItemsInMenu(menu, wm, winListStart);
 734         }
 735         else
 736         {
 737             UMASetMenuTitle( MAC_WXHMENU(menu->GetHMenu()) , m_titles[i], GetFont().GetEncoding()  ) ;
 738             menu->MacBeforeDisplay(false) ;
 739
 740             ::InsertMenu(MAC_WXHMENU(_wxMenuAt(m_menus, i)->GetHMenu()), 0);
 741         }
 742     }
 743
 744     // take care of the about menu item wherever it is
 745     {
 746         wxMenu* aboutMenu ;
 747         wxMenuItem *aboutMenuItem = FindItem(wxApp::s_macAboutMenuItemId , &aboutMenu) ;
 748         if ( aboutMenuItem )
 749         {
 750             wxAcceleratorEntry*
 751                 entry = wxAcceleratorEntry::Create( aboutMenuItem->GetItemLabel() ) ;
 752             UMASetMenuItemText( GetMenuHandle( kwxMacAppleMenuId ) , 1 , wxStripMenuCodes ( aboutMenuItem->GetItemLabel() ) , wxFont::GetDefaultEncoding() );
 753             UMAEnableMenuItem( GetMenuHandle( kwxMacAppleMenuId ) , 1 , true );
 754             SetMenuItemCommandID( GetMenuHandle( kwxMacAppleMenuId ) , 1 , kHICommandAbout ) ;
 755             SetMenuItemRefCon(GetMenuHandle( kwxMacAppleMenuId ) , 1 , (URefCon)aboutMenuItem ) ;
 756             UMASetMenuItemShortcut( GetMenuHandle( kwxMacAppleMenuId ) , 1 , entry ) ;
 757             delete entry;
 758         }
 759     }
 760
 761     if ( GetAutoWindowMenu() )
 762     {
 763         if ( MacGetWindowMenuHMenu() == NULL )
 764             CreateStandardWindowMenu( 0 , (MenuHandle*) &s_macWindowMenuHandle ) ;
 765
 766         InsertMenu( (MenuHandle) MacGetWindowMenuHMenu() , 0 ) ;
 767     }
 768
 769     ::DrawMenuBar() ;
 770 #endif
 771
 772     s_macInstalledMenuBar = this;
 773 }
 774
 775 void wxMenuBar::EnableTop(size_t pos, bool enable)
 776 {
 777     wxCHECK_RET( IsAttached(), wxT("doesn't work with unattached menubars") );
 778
 779     m_rootMenu->FindItemByPosition( pos )->Enable(enable);
 780
 781     Refresh();
 782 }
 783
 784 bool wxMenuBar::Enable(bool enable)
 785 {
 786     wxCHECK_MSG( IsAttached(), false, wxT("doesn't work with unattached menubars") );
 787
 788     size_t i;
 789     for (i = 0; i < GetMenuCount(); i++)
 790         EnableTop(i, enable);
 791
 792     return true;
 793 }
 794
 795 void wxMenuBar::SetMenuLabel(size_t pos, const wxString& label)
 796 {
 797     wxCHECK_RET( pos < GetMenuCount(), wxT("invalid menu index") );
 798
 799     m_titles[pos] = label;
 800
 801     if ( !IsAttached() )
 802         return;
 803
 804     _wxMenuAt(m_menus, pos)->SetTitle( label ) ;
 805 }
 806
 807 wxString wxMenuBar::GetMenuLabel(size_t pos) const
 808 {
 809     wxCHECK_MSG( pos < GetMenuCount(), wxEmptyString,
 810                  wxT("invalid menu index in wxMenuBar::GetMenuLabel") );
 811
 812     return m_titles[pos];
 813 }
 814
 815 int wxMenuBar::FindMenu(const wxString& title)
 816 {
 817     wxString menuTitle = wxStripMenuCodes(title);
 818
 819     size_t count = GetMenuCount();
 820     for ( size_t i = 0; i < count; i++ )
 821     {
 822         wxString title = wxStripMenuCodes(m_titles[i]);
 823         if ( menuTitle == title )
 824             return i;
 825     }
 826
 827     return wxNOT_FOUND;
 828 }
 829
 830 // ---------------------------------------------------------------------------
 831 // wxMenuBar construction
 832 // ---------------------------------------------------------------------------
 833
 834 const int firstMenuPos = 1; // to account for the 0th application menu on mac
 835
 836 wxMenu *wxMenuBar::Replace(size_t pos, wxMenu *menu, const wxString& title)
 837 {
 838     wxMenu *menuOld = wxMenuBarBase::Replace(pos, menu, title);
 839     if ( !menuOld )
 840         return NULL;
 841
 842     m_titles[pos] = title;
 843
 844     wxMenuItem* item = m_rootMenu->FindItemByPosition(pos+firstMenuPos);
 845     m_rootMenu->Remove(item);
 846     m_rootMenu->Insert( pos+firstMenuPos, wxMenuItem::New( m_rootMenu, wxID_ANY, title, "", wxITEM_NORMAL, menu ) );
 847
 848     return menuOld;
 849 }
 850
 851 bool wxMenuBar::Insert(size_t pos, wxMenu *menu, const wxString& title)
 852 {
 853     if ( !wxMenuBarBase::Insert(pos, menu, title) )
 854         return false;
 855
 856     m_titles.Insert(title, pos);
 857
 858     m_rootMenu->Insert( pos+firstMenuPos, wxMenuItem::New( m_rootMenu, wxID_ANY, title, "", wxITEM_NORMAL, menu ) );
 859
 860     return true;
 861 }
 862
 863 wxMenu *wxMenuBar::Remove(size_t pos)
 864 {
 865     wxMenu *menu = wxMenuBarBase::Remove(pos);
 866     if ( !menu )
 867         return NULL;
 868
 869     wxMenuItem* item = m_rootMenu->FindItemByPosition(pos+firstMenuPos);
 870     m_rootMenu->Remove(item);
 871
 872     m_titles.RemoveAt(pos);
 873
 874     return menu;
 875 }
 876
 877 bool wxMenuBar::Append(wxMenu *menu, const wxString& title)
 878 {
 879     WXHMENU submenu = menu ? menu->GetHMenu() : 0;
 880         wxCHECK_MSG( submenu, false, wxT("can't append invalid menu to menubar") );
 881
 882     if ( !wxMenuBarBase::Append(menu, title) )
 883         return false;
 884
 885     m_titles.Add(title);
 886
 887     m_rootMenu->AppendSubMenu(menu, title);
 888
 889     return true;
 890 }
 891
 892 void wxMenuBar::Detach()
 893 {
 894     wxMenuBarBase::Detach() ;
 895 }
 896
 897 void wxMenuBar::Attach(wxFrame *frame)
 898 {
 899     wxMenuBarBase::Attach( frame ) ;
 900 }
 901
 902 // ---------------------------------------------------------------------------
 903 // wxMenuBar searching for menu items
 904 // ---------------------------------------------------------------------------
 905
 906 // Find the itemString in menuString, and return the item id or wxNOT_FOUND
 907 int wxMenuBar::FindMenuItem(const wxString& menuString,
 908                             const wxString& itemString) const
 909 {
 910     wxString menuLabel = wxStripMenuCodes(menuString);
 911     size_t count = GetMenuCount();
 912     for ( size_t i = 0; i < count; i++ )
 913     {
 914         wxString title = wxStripMenuCodes(m_titles[i]);
 915         if ( menuLabel == title )
 916             return _wxMenuAt(m_menus, i)->FindItem(itemString);
 917     }
 918
 919     return wxNOT_FOUND;
 920 }
 921
 922 wxMenuItem *wxMenuBar::FindItem(int id, wxMenu **itemMenu) const
 923 {
 924     if ( itemMenu )
 925         *itemMenu = NULL;
 926
 927     wxMenuItem *item = NULL;
 928     size_t count = GetMenuCount();
 929     for ( size_t i = 0; !item && (i < count); i++ )
 930         item = _wxMenuAt(m_menus, i)->FindItem(id, itemMenu);
 931
 932     return item;
 933 }
 934
 935 #endif