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