src/mac/carbon/menu.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        menu.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 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
  13 #pragma implementation "menu.h"
  14 #pragma implementation "menuitem.h"
  15 #endif
  16
  17 // ============================================================================
  18 // headers & declarations
  19 // ============================================================================
  20
  21 // wxWidgets headers
  22 // -----------------
  23
  24 #include "wx/wxprec.h"
  25
  26 #include "wx/app.h"
  27 #include "wx/menu.h"
  28 #include "wx/menuitem.h"
  29 #include "wx/window.h"
  30 #include "wx/log.h"
  31 #include "wx/utils.h"
  32 #include "wx/frame.h"
  33
  34 #include "wx/mac/uma.h"
  35
  36 // other standard headers
  37 // ----------------------
  38 #include <string.h>
  39
  40 #if !USE_SHARED_LIBRARY
  41 IMPLEMENT_DYNAMIC_CLASS(wxMenu, wxEvtHandler)
  42 IMPLEMENT_DYNAMIC_CLASS(wxMenuBar, wxEvtHandler)
  43 #endif
  44
  45 // the (popup) menu title has this special id
  46 static const int idMenuTitle = -3;
  47 static MenuItemIndex firstUserHelpMenuItem = 0 ;
  48
  49 const short kwxMacMenuBarResource = 1 ;
  50 const short kwxMacAppleMenuId = 1 ;
  51
  52
  53 // Find an item given the Macintosh Menu Reference
  54
  55 #if KEY_wxList_DEPRECATED
  56 wxList wxWinMacMenuList(wxKEY_INTEGER);
  57 wxMenu *wxFindMenuFromMacMenu(MenuRef inMenuRef)
  58 {
  59     wxNode *node = wxWinMacMenuList.Find((long)inMenuRef);
  60     if (!node)
  61         return NULL;
  62     return (wxMenu *)node->GetData();
  63 }
  64
  65 void wxAssociateMenuWithMacMenu(MenuRef inMenuRef, wxMenu *menu) ;
  66 void wxAssociateMenuWithMacMenu(MenuRef inMenuRef, wxMenu *menu)
  67 {
  68     // adding NULL MenuRef is (first) surely a result of an error and
  69     // (secondly) breaks menu command processing
  70     wxCHECK_RET( inMenuRef != (MenuRef) NULL, wxT("attempt to add a NULL MenuRef to menu list") );
  71
  72     if ( !wxWinMacMenuList.Find((long)inMenuRef) )
  73         wxWinMacMenuList.Append((long)inMenuRef, menu);
  74 }
  75
  76 void wxRemoveMacMenuAssociation(wxMenu *menu) ;
  77 void wxRemoveMacMenuAssociation(wxMenu *menu)
  78 {
  79     wxWinMacMenuList.DeleteObject(menu);
  80 }
  81 #else
  82
  83 WX_DECLARE_HASH_MAP(MenuRef, wxMenu*, wxPointerHash, wxPointerEqual, MacMenuMap);
  84
  85 static MacMenuMap wxWinMacMenuList;
  86
  87 wxMenu *wxFindMenuFromMacMenu(MenuRef inMenuRef)
  88 {
  89     MacMenuMap::iterator node = wxWinMacMenuList.find(inMenuRef);
  90
  91     return (node == wxWinMacMenuList.end()) ? NULL : node->second;
  92 }
  93
  94 void wxAssociateMenuWithMacMenu(MenuRef inMenuRef, wxMenu *menu) ;
  95 void wxAssociateMenuWithMacMenu(MenuRef inMenuRef, wxMenu *menu)
  96 {
  97     // adding NULL MenuRef is (first) surely a result of an error and
  98     // (secondly) breaks menu command processing
  99     wxCHECK_RET( inMenuRef != (MenuRef) NULL, wxT("attempt to add a NULL MenuRef to menu list") );
 100
 101     wxWinMacMenuList[inMenuRef] = menu;
 102 }
 103
 104 void wxRemoveMacMenuAssociation(wxMenu *menu) ;
 105 void wxRemoveMacMenuAssociation(wxMenu *menu)
 106 {
 107    // iterate over all the elements in the class
 108     MacMenuMap::iterator it;
 109     for ( it = wxWinMacMenuList.begin(); it != wxWinMacMenuList.end(); ++it )
 110     {
 111         if ( it->second == menu )
 112         {
 113             wxWinMacMenuList.erase(it);
 114             break;
 115         }
 116     }
 117 }
 118 #endif // deprecated wxList
 119
 120 // ============================================================================
 121 // implementation
 122 // ============================================================================
 123 static void wxMenubarUnsetInvokingWindow( wxMenu *menu ) ;
 124 static void wxMenubarSetInvokingWindow( wxMenu *menu, wxWindow *win );
 125
 126 // Menus
 127
 128 // Construct a menu with optional title (then use append)
 129
 130 #ifdef __DARWIN__
 131 short wxMenu::s_macNextMenuId = 3 ;
 132 #else
 133 short wxMenu::s_macNextMenuId = 2 ;
 134 #endif
 135
 136 static
 137 wxMenu *
 138 _wxMenuAt(const wxMenuList &menuList, size_t pos)
 139 {
 140     wxMenuList::compatibility_iterator menuIter = menuList.GetFirst();
 141
 142     while (pos-- > 0) menuIter = menuIter->GetNext();
 143
 144     return menuIter->GetData() ;
 145 }
 146
 147 void wxMenu::Init()
 148 {
 149     m_doBreak = FALSE;
 150     m_startRadioGroup = -1;
 151
 152     // create the menu
 153     m_macMenuId = s_macNextMenuId++;
 154     m_hMenu = UMANewMenu(m_macMenuId, m_title, wxFont::GetDefaultEncoding() );
 155
 156     if ( !m_hMenu )
 157     {
 158         wxLogLastError(wxT("UMANewMenu failed"));
 159     }
 160
 161     wxAssociateMenuWithMacMenu( (MenuRef)m_hMenu , this ) ;
 162
 163     // if we have a title, insert it in the beginning of the menu
 164     if ( !!m_title )
 165     {
 166         Append(idMenuTitle, m_title) ;
 167         AppendSeparator() ;
 168     }
 169 }
 170
 171 wxMenu::~wxMenu()
 172 {
 173     wxRemoveMacMenuAssociation( this ) ;
 174     if (MAC_WXHMENU(m_hMenu))
 175         ::DisposeMenu(MAC_WXHMENU(m_hMenu));
 176 }
 177
 178 void wxMenu::Break()
 179 {
 180     // not available on the mac platform
 181 }
 182
 183 void wxMenu::Attach(wxMenuBarBase *menubar)
 184 {
 185     wxMenuBase::Attach(menubar);
 186
 187     EndRadioGroup();
 188 }
 189
 190 // function appends a new item or submenu to the menu
 191 // append a new item or submenu to the menu
 192 bool wxMenu::DoInsertOrAppend(wxMenuItem *pItem, size_t pos)
 193 {
 194     wxASSERT_MSG( pItem != NULL, wxT("can't append NULL item to the menu") );
 195
 196     if ( pItem->IsSeparator() )
 197     {
 198         if ( pos == (size_t)-1 )
 199             MacAppendMenu(MAC_WXHMENU(m_hMenu), "\p-");
 200         else
 201             MacInsertMenuItem(MAC_WXHMENU(m_hMenu), "\p-" , pos);
 202     }
 203     else
 204     {
 205         wxMenu *pSubMenu = pItem->GetSubMenu() ;
 206         if ( pSubMenu != NULL )
 207         {
 208                wxASSERT_MSG( pSubMenu->m_hMenu != NULL , wxT("invalid submenu added"));
 209             pSubMenu->m_menuParent = this ;
 210
 211             if (wxMenuBar::MacGetInstalledMenuBar() == GetMenuBar())
 212             {
 213                 pSubMenu->MacBeforeDisplay( true ) ;
 214              }
 215
 216             if ( pos == (size_t)-1 )
 217                 UMAAppendSubMenuItem(MAC_WXHMENU(m_hMenu), pItem->GetText(), wxFont::GetDefaultEncoding() , pSubMenu->m_macMenuId);
 218             else
 219                 UMAInsertSubMenuItem(MAC_WXHMENU(m_hMenu), pItem->GetText(), wxFont::GetDefaultEncoding()  , pos, pSubMenu->m_macMenuId);
 220             pItem->UpdateItemBitmap() ;
 221             pItem->UpdateItemStatus() ;
 222         }
 223         else
 224         {
 225             if ( pos == (size_t)-1 )
 226             {
 227                 UMAAppendMenuItem(MAC_WXHMENU(m_hMenu), wxT("a") , wxFont::GetDefaultEncoding() );
 228                 pos = CountMenuItems(MAC_WXHMENU(m_hMenu)) ;
 229             }
 230             else
 231             {
 232                 // MacOS counts menu items from 1 and inserts after, therefore having the
 233                 // same effect as wx 0 based and inserting before, we must correct pos
 234                 // after however for updates to be correct
 235                 UMAInsertMenuItem(MAC_WXHMENU(m_hMenu), wxT("a"), wxFont::GetDefaultEncoding(), pos);
 236                 pos += 1 ;
 237             }
 238
 239             SetMenuItemCommandID( MAC_WXHMENU(m_hMenu) , pos , pItem->GetId() ) ;
 240             SetMenuItemRefCon( MAC_WXHMENU(m_hMenu) , pos , (UInt32) pItem ) ;
 241             pItem->UpdateItemText() ;
 242             pItem->UpdateItemBitmap() ;
 243             pItem->UpdateItemStatus() ;
 244
 245               if ( pItem->GetId() == idMenuTitle )
 246               {
 247                 UMAEnableMenuItem(MAC_WXHMENU(m_hMenu) , pos , false ) ;
 248               }
 249         }
 250     }
 251     // if we're already attached to the menubar, we must update it
 252     if ( IsAttached() )
 253     {
 254         GetMenuBar()->Refresh();
 255     }
 256     return TRUE ;
 257 }
 258
 259 void wxMenu::EndRadioGroup()
 260 {
 261     // we're not inside a radio group any longer
 262     m_startRadioGroup = -1;
 263 }
 264
 265 wxMenuItem* wxMenu::DoAppend(wxMenuItem *item)
 266 {
 267     wxCHECK_MSG( item, NULL, _T("NULL item in wxMenu::DoAppend") );
 268
 269     bool check = FALSE;
 270
 271     if ( item->GetKind() == wxITEM_RADIO )
 272     {
 273         int count = GetMenuItemCount();
 274
 275         if ( m_startRadioGroup == -1 )
 276         {
 277             // start a new radio group
 278             m_startRadioGroup = count;
 279
 280             // for now it has just one element
 281             item->SetAsRadioGroupStart();
 282             item->SetRadioGroupEnd(m_startRadioGroup);
 283
 284             // ensure that we have a checked item in the radio group
 285             check = TRUE;
 286         }
 287         else // extend the current radio group
 288         {
 289             // we need to update its end item
 290             item->SetRadioGroupStart(m_startRadioGroup);
 291             wxMenuItemList::compatibility_iterator node = GetMenuItems().Item(m_startRadioGroup);
 292
 293             if ( node )
 294             {
 295                 node->GetData()->SetRadioGroupEnd(count);
 296             }
 297             else
 298             {
 299                 wxFAIL_MSG( _T("where is the radio group start item?") );
 300             }
 301         }
 302     }
 303     else // not a radio item
 304     {
 305         EndRadioGroup();
 306     }
 307
 308     if ( !wxMenuBase::DoAppend(item) || !DoInsertOrAppend(item) )
 309     {
 310         return NULL;
 311     }
 312
 313     if ( check )
 314     {
 315         // check the item initially
 316         item->Check(TRUE);
 317     }
 318
 319     return item;
 320 }
 321
 322 wxMenuItem* wxMenu::DoInsert(size_t pos, wxMenuItem *item)
 323 {
 324     if (wxMenuBase::DoInsert(pos, item) && DoInsertOrAppend(item, pos))
 325         return item;
 326     else
 327         return NULL;
 328 }
 329
 330 wxMenuItem *wxMenu::DoRemove(wxMenuItem *item)
 331 {
 332     // we need to find the items position in the child list
 333     size_t pos;
 334     wxMenuItemList::compatibility_iterator node = GetMenuItems().GetFirst();
 335     for ( pos = 0; node; pos++ )
 336     {
 337         if ( node->GetData() == item )
 338             break;
 339
 340         node = node->GetNext();
 341     }
 342
 343     // DoRemove() (unlike Remove) can only be called for existing item!
 344     wxCHECK_MSG( node, NULL, wxT("bug in wxMenu::Remove logic") );
 345
 346     ::DeleteMenuItem(MAC_WXHMENU(m_hMenu) , pos + 1);
 347
 348     if ( IsAttached() )
 349     {
 350         // otherwise, the change won't be visible
 351         GetMenuBar()->Refresh();
 352     }
 353
 354     // and from internal data structures
 355     return wxMenuBase::DoRemove(item);
 356 }
 357
 358 void wxMenu::SetTitle(const wxString& label)
 359 {
 360        m_title = label ;
 361     UMASetMenuTitle(MAC_WXHMENU(m_hMenu) , label , wxFont::GetDefaultEncoding() ) ;
 362 }
 363 bool wxMenu::ProcessCommand(wxCommandEvent & event)
 364 {
 365     bool processed = FALSE;
 366
 367     // Try the menu's event handler
 368     if ( !processed && GetEventHandler())
 369     {
 370         processed = GetEventHandler()->ProcessEvent(event);
 371     }
 372
 373     // Try the window the menu was popped up from (and up through the
 374     // hierarchy)
 375     wxWindow *win = GetInvokingWindow();
 376     if ( !processed && win )
 377         processed = win->GetEventHandler()->ProcessEvent(event);
 378
 379     return processed;
 380 }
 381
 382
 383 // ---------------------------------------------------------------------------
 384 // other
 385 // ---------------------------------------------------------------------------
 386
 387 wxWindow *wxMenu::GetWindow() const
 388 {
 389     if ( m_invokingWindow != NULL )
 390         return m_invokingWindow;
 391     else if ( GetMenuBar() != NULL)
 392         return (wxWindow *) GetMenuBar()->GetFrame();
 393
 394     return NULL;
 395 }
 396
 397 // helper functions returning the mac menu position for a certain item, note that this is
 398 // mac-wise 1 - based, i.e. the first item has index 1 whereas on MSWin it has pos 0
 399
 400 int wxMenu::MacGetIndexFromId( int id )
 401 {
 402     size_t pos;
 403     wxMenuItemList::compatibility_iterator node = GetMenuItems().GetFirst();
 404     for ( pos = 0; node; pos++ )
 405     {
 406         if ( node->GetData()->GetId() == id )
 407             break;
 408
 409         node = node->GetNext();
 410     }
 411
 412     if (!node)
 413         return 0;
 414
 415     return pos + 1 ;
 416 }
 417
 418 int wxMenu::MacGetIndexFromItem( wxMenuItem *pItem )
 419 {
 420     size_t pos;
 421     wxMenuItemList::compatibility_iterator node = GetMenuItems().GetFirst();
 422     for ( pos = 0; node; pos++ )
 423     {
 424         if ( node->GetData() == pItem )
 425             break;
 426
 427         node = node->GetNext();
 428     }
 429
 430     if (!node)
 431         return 0;
 432
 433     return pos + 1 ;
 434 }
 435
 436 void wxMenu::MacEnableMenu( bool bDoEnable )
 437 {
 438     UMAEnableMenuItem(MAC_WXHMENU(m_hMenu) , 0 , bDoEnable ) ;
 439
 440     ::DrawMenuBar() ;
 441 }
 442
 443 // MacOS needs to know about submenus somewhere within this menu
 444 // before it can be displayed , also hide special menu items like preferences
 445 // that are handled by the OS
 446 void wxMenu::MacBeforeDisplay( bool isSubMenu )
 447 {
 448     wxMenuItem* previousItem = NULL ;
 449     size_t pos ;
 450     wxMenuItemList::compatibility_iterator node;
 451     wxMenuItem *item;
 452     for (pos = 0, node = GetMenuItems().GetFirst(); node; node = node->GetNext(), pos++)
 453     {
 454         item = (wxMenuItem *)node->GetData();
 455         wxMenu* subMenu = item->GetSubMenu() ;
 456         if (subMenu)
 457         {
 458             subMenu->MacBeforeDisplay( true ) ;
 459         }
 460         else // normal item
 461         {
 462             #if TARGET_CARBON
 463             if ( UMAGetSystemVersion() >= 0x1000 )
 464             {
 465                 // what we do here is to hide the special items which are
 466                 // shown in the application menu anyhow -- it doesn't make
 467                 // sense to show them in their normal place as well
 468                 if ( item->GetId() == wxApp::s_macPreferencesMenuItemId ||
 469                         item->GetId() == wxApp::s_macExitMenuItemId )
 470                 {
 471                     ChangeMenuItemAttributes( MAC_WXHMENU( GetHMenu() ),
 472                                               pos + 1, kMenuItemAttrHidden, 0 );
 473
 474                     // also check for a separator which was used just to
 475                     // separate this item from the others, so don't leave
 476                     // separator at the menu start or end nor 2 consecutive
 477                     // separators
 478                     wxMenuItemList::compatibility_iterator nextNode = node->GetNext();
 479                     wxMenuItem *next = nextNode ? nextNode->GetData() : NULL;
 480
 481                     size_t posSeptoHide;
 482                     if ( !previousItem && next && next->IsSeparator() )
 483                     {
 484                         // next (i.e. second as we must be first) item is
 485                         // the separator to hide
 486                         wxASSERT_MSG( pos == 0, _T("should be the menu start") );
 487                         posSeptoHide = 2;
 488                     }
 489                     else if ( GetMenuItems().GetCount() == pos + 1 &&
 490                                 previousItem != NULL &&
 491                                     previousItem->IsSeparator() )
 492                     {
 493                         // prev item is a trailing separator we want to hide
 494                         posSeptoHide = pos;
 495                     }
 496                     else if ( previousItem && previousItem->IsSeparator() &&
 497                                 next && next->IsSeparator() )
 498                     {
 499                         // two consecutive separators, this is one too many
 500                         posSeptoHide = pos;
 501                     }
 502                     else // no separators to hide
 503                     {
 504                         posSeptoHide = 0;
 505                     }
 506
 507                     if ( posSeptoHide )
 508                     {
 509                         // hide the separator as well
 510                         ChangeMenuItemAttributes( MAC_WXHMENU( GetHMenu() ),
 511                                                   posSeptoHide,
 512                                                   kMenuItemAttrHidden,
 513                                                   0 );
 514                     }
 515                 }
 516             }
 517             #endif // TARGET_CARBON
 518         }
 519         previousItem = item ;
 520     }
 521
 522     if ( isSubMenu )
 523         ::InsertMenu(MAC_WXHMENU( GetHMenu()), -1);
 524
 525 }
 526 // undo all changes from the MacBeforeDisplay call
 527 void wxMenu::MacAfterDisplay( bool isSubMenu )
 528 {
 529     if ( isSubMenu )
 530         ::DeleteMenu(MacGetMenuId());
 531
 532     wxMenuItem* previousItem = NULL ;
 533     int pos ;
 534     wxMenuItemList::compatibility_iterator node;
 535     wxMenuItem *item;
 536     for (pos = 0, node = GetMenuItems().GetFirst(); node; node = node->GetNext(), pos++)
 537     {
 538         item = (wxMenuItem *)node->GetData();
 539         wxMenu* subMenu = item->GetSubMenu() ;
 540         if (subMenu)
 541         {
 542             subMenu->MacAfterDisplay( true ) ;
 543         }
 544         else
 545         {
 546             // no need to undo hidings
 547         }
 548         previousItem = item ;
 549     }
 550 }
 551
 552 // Menu Bar
 553
 554 /*
 555
 556 Mac Implementation note :
 557
 558 The Mac has only one global menubar, so we attempt to install the currently
 559 active menubar from a frame, we currently don't take into account mdi-frames
 560 which would ask for menu-merging
 561
 562 Secondly there is no mac api for changing a menubar that is not the current
 563 menubar, so we have to wait for preparing the actual menubar until the
 564 wxMenubar is to be used
 565
 566 We can in subsequent versions use MacInstallMenuBar to provide some sort of
 567 auto-merge for MDI in case this will be necessary
 568
 569 */
 570
 571 wxMenuBar* wxMenuBar::s_macInstalledMenuBar = NULL ;
 572 wxMenuBar* wxMenuBar::s_macCommonMenuBar = NULL ;
 573
 574 void wxMenuBar::Init()
 575 {
 576     m_eventHandler = this;
 577     m_menuBarFrame = NULL;
 578     m_invokingWindow = (wxWindow*) NULL;
 579 }
 580
 581 wxMenuBar::wxMenuBar()
 582 {
 583     Init();
 584 }
 585
 586 wxMenuBar::wxMenuBar( long WXUNUSED(style) )
 587 {
 588     Init();
 589 }
 590
 591
 592 wxMenuBar::wxMenuBar(size_t count, wxMenu *menus[], const wxString titles[], long WXUNUSED(style))
 593 {
 594     Init();
 595
 596     m_titles.Alloc(count);
 597
 598     for ( size_t i = 0; i < count; i++ )
 599     {
 600         m_menus.Append(menus[i]);
 601         m_titles.Add(titles[i]);
 602
 603         menus[i]->Attach(this);
 604     }
 605 }
 606
 607 wxMenuBar::~wxMenuBar()
 608 {
 609     if (s_macCommonMenuBar == this)
 610         s_macCommonMenuBar = NULL;
 611     if (s_macInstalledMenuBar == this)
 612     {
 613         ::ClearMenuBar();
 614         s_macInstalledMenuBar = NULL;
 615     }
 616
 617 }
 618
 619 void wxMenuBar::Refresh(bool WXUNUSED(eraseBackground), const wxRect *WXUNUSED(rect))
 620 {
 621     wxCHECK_RET( IsAttached(), wxT("can't refresh unatteched menubar") );
 622
 623     DrawMenuBar();
 624 }
 625
 626 void wxMenuBar::MacInstallMenuBar()
 627 {
 628     if ( s_macInstalledMenuBar == this )
 629         return ;
 630
 631     MenuBarHandle menubar = NULL ;
 632 #if TARGET_API_MAC_OSX
 633     menubar = NewHandleClear( 6 /* sizeof( MenuBarHeader ) */ ) ;
 634 #else
 635     menubar = NewHandleClear( 12 ) ;
 636     (*menubar)[3] = 0x0a ;
 637 #endif
 638     ::SetMenuBar( menubar ) ;
 639     DisposeMenuBar( menubar ) ;
 640     MenuHandle appleMenu = NULL ;
 641     char appleMenuTitle[3] = { 01 , kMenuAppleLogoFilledGlyph , 0 } ;
 642
 643     verify_noerr( CreateNewMenu( kwxMacAppleMenuId , 0 , &appleMenu ) ) ;
 644     verify_noerr( SetMenuTitle( appleMenu , (ConstStr255Param) appleMenuTitle ) );
 645
 646     // Add About/Preferences separator only on OS X
 647     // KH/RN: Separator is always present on 10.3 but not on 10.2
 648     // However, the change from 10.2 to 10.3 suggests it is preferred
 649 #if TARGET_API_MAC_OSX
 650     MacInsertMenuItem( appleMenu , "\p-" , 0 ) ;
 651 #endif
 652
 653     MacInsertMenuItem( appleMenu , "\pAbout..." , 0 ) ;
 654     MacInsertMenu( appleMenu , 0 ) ;
 655
 656     // clean-up the help menu before adding new items
 657     MenuHandle mh = NULL ;
 658     if ( UMAGetHelpMenu( &mh , &firstUserHelpMenuItem) == noErr )
 659     {
 660         for ( int i = CountMenuItems( mh ) ; i >= firstUserHelpMenuItem ; --i )
 661         {
 662             DeleteMenuItem( mh , i ) ;
 663         }
 664     }
 665     else
 666     {
 667         mh = NULL ;
 668     }
 669 #if TARGET_CARBON
 670     if ( UMAGetSystemVersion() >= 0x1000 && wxApp::s_macPreferencesMenuItemId)
 671     {
 672         wxMenuItem *item = FindItem( wxApp::s_macPreferencesMenuItemId , NULL ) ;
 673         if ( item == NULL || !(item->IsEnabled()) )
 674             DisableMenuCommand( NULL , kHICommandPreferences ) ;
 675         else
 676             EnableMenuCommand( NULL , kHICommandPreferences ) ;
 677     }
 678     // Unlike preferences which may or may not exist, the Quit item should be always
 679     // enabled unless it is added by the application and then disabled, otherwise
 680     // a program would be required to add an item with wxID_EXIT in order to get the
 681     // Quit menu item to be enabled, which seems a bit burdensome.
 682     if ( UMAGetSystemVersion() >= 0x1000 && wxApp::s_macExitMenuItemId)
 683     {
 684         wxMenuItem *item = FindItem( wxApp::s_macExitMenuItemId , NULL ) ;
 685         if ( item != NULL && !(item->IsEnabled()) )
 686             DisableMenuCommand( NULL , kHICommandQuit ) ;
 687         else
 688             EnableMenuCommand( NULL , kHICommandQuit ) ;
 689     }
 690 #endif
 691        wxMenuList::compatibility_iterator menuIter = m_menus.GetFirst();
 692        //
 693        for (size_t i = 0; i < m_menus.GetCount(); i++, menuIter = menuIter->GetNext())
 694       {
 695         wxMenuItemList::compatibility_iterator node;
 696         wxMenuItem *item;
 697         int pos ;
 698         wxMenu* menu = menuIter->GetData() , *subMenu = NULL ;
 699
 700         if( m_titles[i] == wxT("?") || m_titles[i] == wxT("&?")  || m_titles[i] == wxApp::s_macHelpMenuTitleName )
 701         {
 702             if ( mh == NULL )
 703             {
 704                 continue ;
 705             }
 706
 707               for (pos = 0 , node = menu->GetMenuItems().GetFirst(); node; node = node->GetNext(), pos++)
 708               {
 709                  item = (wxMenuItem *)node->GetData();
 710                  subMenu = item->GetSubMenu() ;
 711                 if (subMenu)
 712                 {
 713                     // we don't support hierarchical menus in the help menu yet
 714                 }
 715                 else
 716                 {
 717                     if ( item->IsSeparator() )
 718                     {
 719                         if ( mh )
 720                             MacAppendMenu(mh, "\p-" );
 721                     }
 722                     else
 723                     {
 724                         wxAcceleratorEntry* entry = wxGetAccelFromString( item->GetText() ) ;
 725
 726                         if ( item->GetId() == wxApp::s_macAboutMenuItemId )
 727                         {
 728                                 UMASetMenuItemText( GetMenuHandle( kwxMacAppleMenuId ) , 1 , item->GetText() , wxFont::GetDefaultEncoding() );
 729                                 UMAEnableMenuItem( GetMenuHandle( kwxMacAppleMenuId ) , 1 , true );
 730                                 SetMenuItemCommandID( GetMenuHandle( kwxMacAppleMenuId ) , 1 , item->GetId() ) ;
 731                                 SetMenuItemRefCon(GetMenuHandle( kwxMacAppleMenuId ) , 1 , (UInt32)item ) ;
 732                                 UMASetMenuItemShortcut( GetMenuHandle( kwxMacAppleMenuId ) , 1 , entry ) ;
 733                          }
 734                         else
 735                         {
 736                             if ( mh )
 737                             {
 738                                 UMAAppendMenuItem(mh, item->GetText()  , wxFont::GetDefaultEncoding(), entry);
 739                                 SetMenuItemCommandID( mh , CountMenuItems(mh) , item->GetId() ) ;
 740                                 SetMenuItemRefCon( mh , CountMenuItems(mh) , (UInt32)item ) ;
 741                             }
 742                         }
 743
 744                         delete entry ;
 745                     }
 746                 }
 747             }
 748         }
 749         else
 750         {
 751             UMASetMenuTitle( MAC_WXHMENU(menu->GetHMenu()) , m_titles[i], m_font.GetEncoding()  ) ;
 752             menu->MacBeforeDisplay(false) ;
 753             ::InsertMenu(MAC_WXHMENU(_wxMenuAt(m_menus, i)->GetHMenu()), 0);
 754         }
 755     }
 756     ::DrawMenuBar() ;
 757     s_macInstalledMenuBar = this;
 758 }
 759
 760 void wxMenuBar::EnableTop(size_t pos, bool enable)
 761 {
 762     wxCHECK_RET( IsAttached(), wxT("doesn't work with unattached menubars") );
 763     _wxMenuAt(m_menus, pos)->MacEnableMenu( enable ) ;
 764     Refresh();
 765 }
 766
 767 bool wxMenuBar::Enable( bool enable)
 768 {
 769     wxCHECK_MSG( IsAttached(), false, wxT("doesn't work with unattached menubars") );
 770     size_t i;
 771     for (i = 0; i < GetMenuCount(); i++)
 772     {
 773         EnableTop(i, enable);
 774     }
 775     return true;
 776 }
 777
 778 void wxMenuBar::SetLabelTop(size_t pos, const wxString& label)
 779 {
 780     wxCHECK_RET( pos < GetMenuCount(), wxT("invalid menu index") );
 781
 782     m_titles[pos] = label;
 783
 784     if ( !IsAttached() )
 785     {
 786         return;
 787     }
 788
 789     _wxMenuAt(m_menus, pos)->SetTitle( label ) ;
 790
 791     if (wxMenuBar::s_macInstalledMenuBar == this) // are we currently installed ?
 792     {
 793         ::SetMenuBar( GetMenuBar() ) ;
 794         ::InvalMenuBar() ;
 795     }
 796 }
 797
 798 wxString wxMenuBar::GetLabelTop(size_t pos) const
 799 {
 800     wxCHECK_MSG( pos < GetMenuCount(), wxEmptyString,
 801                  wxT("invalid menu index in wxMenuBar::GetLabelTop") );
 802
 803     return m_titles[pos];
 804 }
 805
 806 int wxMenuBar::FindMenu(const wxString& title)
 807 {
 808     wxString menuTitle = wxStripMenuCodes(title);
 809
 810     size_t count = GetMenuCount();
 811     for ( size_t i = 0; i < count; i++ )
 812     {
 813         wxString title = wxStripMenuCodes(m_titles[i]);
 814         if ( menuTitle == title )
 815             return i;
 816     }
 817
 818     return wxNOT_FOUND;
 819
 820 }
 821
 822
 823 // ---------------------------------------------------------------------------
 824 // wxMenuBar construction
 825 // ---------------------------------------------------------------------------
 826
 827 wxMenu *wxMenuBar::Replace(size_t pos, wxMenu *menu, const wxString& title)
 828 {
 829     wxMenu *menuOld = wxMenuBarBase::Replace(pos, menu, title);
 830     if ( !menuOld )
 831         return FALSE;
 832     m_titles[pos] = title;
 833
 834     if ( IsAttached() )
 835     {
 836         if (s_macInstalledMenuBar == this)
 837         {
 838             menuOld->MacAfterDisplay( false ) ;
 839             ::DeleteMenu( menuOld->MacGetMenuId() /* m_menus[pos]->MacGetMenuId() */ ) ;
 840             {
 841                 menu->MacBeforeDisplay( false ) ;
 842                 UMASetMenuTitle( MAC_WXHMENU(menu->GetHMenu()) , title , m_font.GetEncoding() ) ;
 843                 if ( pos == m_menus.GetCount() - 1)
 844                 {
 845                     ::InsertMenu( MAC_WXHMENU(menu->GetHMenu()) , 0 ) ;
 846                 }
 847                 else
 848                 {
 849                     ::InsertMenu( MAC_WXHMENU(menu->GetHMenu()) , _wxMenuAt(m_menus, pos+1)->MacGetMenuId() ) ;
 850                 }
 851             }
 852         }
 853
 854         Refresh();
 855     }
 856     if (m_invokingWindow)
 857         wxMenubarSetInvokingWindow( menu, m_invokingWindow );
 858
 859     return menuOld;
 860 }
 861
 862 bool wxMenuBar::Insert(size_t pos, wxMenu *menu, const wxString& title)
 863 {
 864     if ( !wxMenuBarBase::Insert(pos, menu, title) )
 865         return FALSE;
 866
 867     m_titles.Insert(title, pos);
 868
 869     UMASetMenuTitle( MAC_WXHMENU(menu->GetHMenu()) , title , m_font.GetEncoding() ) ;
 870
 871     if ( IsAttached() && s_macInstalledMenuBar == this )
 872     {
 873         if (s_macInstalledMenuBar == this)
 874         {
 875             menu->MacBeforeDisplay( false ) ;
 876             if ( pos == (size_t) -1  || pos + 1 == m_menus.GetCount() )
 877             {
 878                 ::InsertMenu( MAC_WXHMENU(menu->GetHMenu()) , 0 ) ;
 879             }
 880             else
 881             {
 882                 ::InsertMenu( MAC_WXHMENU(menu->GetHMenu()) , _wxMenuAt(m_menus, pos+1)->MacGetMenuId() ) ;
 883             }
 884         }
 885         Refresh();
 886     }
 887     if (m_invokingWindow)
 888         wxMenubarSetInvokingWindow( menu, m_invokingWindow );
 889
 890     return TRUE;
 891 }
 892
 893 wxMenu *wxMenuBar::Remove(size_t pos)
 894 {
 895     wxMenu *menu = wxMenuBarBase::Remove(pos);
 896     if ( !menu )
 897         return NULL;
 898
 899     if ( IsAttached() )
 900     {
 901         if (s_macInstalledMenuBar == this)
 902         {
 903             ::DeleteMenu( menu->MacGetMenuId() /* m_menus[pos]->MacGetMenuId() */ ) ;
 904         }
 905
 906         Refresh();
 907     }
 908
 909     m_titles.RemoveAt(pos);
 910
 911     return menu;
 912 }
 913
 914 bool wxMenuBar::Append(wxMenu *menu, const wxString& title)
 915 {
 916     WXHMENU submenu = menu ? menu->GetHMenu() : 0;
 917     wxCHECK_MSG( submenu, FALSE, wxT("can't append invalid menu to menubar") );
 918
 919     if ( !wxMenuBarBase::Append(menu, title) )
 920         return FALSE;
 921
 922     m_titles.Add(title);
 923
 924     UMASetMenuTitle( MAC_WXHMENU(menu->GetHMenu()) , title , m_font.GetEncoding() ) ;
 925
 926     if ( IsAttached() )
 927     {
 928         if (s_macInstalledMenuBar == this)
 929         {
 930             menu->MacBeforeDisplay( false ) ;
 931             ::InsertMenu( MAC_WXHMENU(menu->GetHMenu()) , 0 ) ;
 932         }
 933
 934         Refresh();
 935     }
 936
 937     // m_invokingWindow is set after wxFrame::SetMenuBar(). This call enables
 938     // adding menu later on.
 939     if (m_invokingWindow)
 940         wxMenubarSetInvokingWindow( menu, m_invokingWindow );
 941
 942     return TRUE;
 943 }
 944
 945 static void wxMenubarUnsetInvokingWindow( wxMenu *menu )
 946 {
 947     menu->SetInvokingWindow( (wxWindow*) NULL );
 948
 949     wxMenuItemList::compatibility_iterator node = menu->GetMenuItems().GetFirst();
 950     while (node)
 951     {
 952         wxMenuItem *menuitem = node->GetData();
 953         if (menuitem->IsSubMenu())
 954             wxMenubarUnsetInvokingWindow( menuitem->GetSubMenu() );
 955         node = node->GetNext();
 956     }
 957 }
 958
 959 static void wxMenubarSetInvokingWindow( wxMenu *menu, wxWindow *win )
 960 {
 961     menu->SetInvokingWindow( win );
 962
 963     wxMenuItemList::compatibility_iterator node = menu->GetMenuItems().GetFirst();
 964     while (node)
 965     {
 966         wxMenuItem *menuitem = node->GetData();
 967         if (menuitem->IsSubMenu())
 968             wxMenubarSetInvokingWindow( menuitem->GetSubMenu() , win );
 969         node = node->GetNext();
 970     }
 971 }
 972
 973 void wxMenuBar::UnsetInvokingWindow()
 974 {
 975     m_invokingWindow = (wxWindow*) NULL;
 976     wxMenuList::compatibility_iterator node = m_menus.GetFirst();
 977     while (node)
 978     {
 979         wxMenu *menu = node->GetData();
 980         wxMenubarUnsetInvokingWindow( menu );
 981         node = node->GetNext();
 982     }
 983 }
 984
 985 void wxMenuBar::SetInvokingWindow(wxFrame *frame)
 986 {
 987     m_invokingWindow = frame;
 988     wxMenuList::compatibility_iterator node = m_menus.GetFirst();
 989     while (node)
 990     {
 991         wxMenu *menu = node->GetData();
 992         wxMenubarSetInvokingWindow( menu, frame );
 993         node = node->GetNext();
 994     }
 995 }
 996
 997 void wxMenuBar::Detach()
 998 {
 999     wxMenuBarBase::Detach() ;
1000 }
1001
1002 void wxMenuBar::Attach(wxFrame *frame)
1003 {
1004     wxMenuBarBase::Attach( frame ) ;
1005 }
1006 // ---------------------------------------------------------------------------
1007 // wxMenuBar searching for menu items
1008 // ---------------------------------------------------------------------------
1009
1010 // Find the itemString in menuString, and return the item id or wxNOT_FOUND
1011 int wxMenuBar::FindMenuItem(const wxString& menuString,
1012                             const wxString& itemString) const
1013 {
1014     wxString menuLabel = wxStripMenuCodes(menuString);
1015     size_t count = GetMenuCount();
1016     for ( size_t i = 0; i < count; i++ )
1017     {
1018         wxString title = wxStripMenuCodes(m_titles[i]);
1019         if ( menuLabel == title )
1020             return _wxMenuAt(m_menus, i)->FindItem(itemString);
1021     }
1022
1023     return wxNOT_FOUND;
1024 }
1025
1026 wxMenuItem *wxMenuBar::FindItem(int id, wxMenu **itemMenu) const
1027 {
1028     if ( itemMenu )
1029         *itemMenu = NULL;
1030
1031     wxMenuItem *item = NULL;
1032     size_t count = GetMenuCount();
1033     for ( size_t i = 0; !item && (i < count); i++ )
1034     {
1035         item = _wxMenuAt(m_menus, i)->FindItem(id, itemMenu);
1036     }
1037
1038     return item;
1039 }
1040
1041