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