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 #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, wxFont::GetDefaultEncoding() );
  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() == GetMenuBar())
 128             {
 129                 pSubMenu->MacBeforeDisplay( true ) ;
 130              }
 131
 132             if ( pos == (size_t)-1 )
 133                 UMAAppendSubMenuItem(MAC_WXHMENU(m_hMenu), pItem->GetText(), wxFont::GetDefaultEncoding() , pSubMenu->m_macMenuId);
 134             else
 135                 UMAInsertSubMenuItem(MAC_WXHMENU(m_hMenu), pItem->GetText(), wxFont::GetDefaultEncoding()  , 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") , wxFont::GetDefaultEncoding() );
 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"), wxFont::GetDefaultEncoding(), 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         GetMenuBar()->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         GetMenuBar()->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 , wxFont::GetDefaultEncoding() ) ;
 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 ( GetMenuBar() != NULL)
 307         return (wxWindow *) GetMenuBar()->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() , wxFont::GetDefaultEncoding() );
 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()  , wxFont::GetDefaultEncoding(), 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], m_font.GetEncoding()  ) ;
 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 bool wxMenuBar::Enable( bool enable)
 621 {
 622     wxCHECK_MSG( IsAttached(), false, wxT("doesn't work with unattached menubars") );
 623     size_t i;
 624     for (i = 0; i < GetMenuCount(); i++)
 625     {
 626         EnableTop(i, enable);
 627     }
 628     return true;
 629 }
 630
 631 void wxMenuBar::SetLabelTop(size_t pos, const wxString& label)
 632 {
 633     wxCHECK_RET( pos < GetMenuCount(), wxT("invalid menu index") );
 634
 635     m_titles[pos] = label;
 636
 637     if ( !IsAttached() )
 638     {
 639         return;
 640     }
 641
 642     m_menus[pos]->SetTitle( label ) ;
 643     if (wxMenuBar::s_macInstalledMenuBar == this) // are we currently installed ?
 644     {
 645         ::SetMenuBar( GetMenuBar() ) ;
 646         ::InvalMenuBar() ;
 647     }
 648 }
 649
 650 wxString wxMenuBar::GetLabelTop(size_t pos) const
 651 {
 652     wxCHECK_MSG( pos < GetMenuCount(), wxEmptyString,
 653                  wxT("invalid menu index in wxMenuBar::GetLabelTop") );
 654
 655     return m_titles[pos];
 656 }
 657
 658 int wxMenuBar::FindMenu(const wxString& title)
 659 {
 660     wxString menuTitle = wxStripMenuCodes(title);
 661
 662     size_t count = GetMenuCount();
 663     for ( size_t i = 0; i < count; i++ )
 664     {
 665         wxString title = wxStripMenuCodes(m_titles[i]);
 666         if ( menuTitle == title )
 667             return i;
 668     }
 669
 670     return wxNOT_FOUND;
 671
 672 }
 673
 674
 675 // ---------------------------------------------------------------------------
 676 // wxMenuBar construction
 677 // ---------------------------------------------------------------------------
 678
 679 // ---------------------------------------------------------------------------
 680 // wxMenuBar construction
 681 // ---------------------------------------------------------------------------
 682
 683 wxMenu *wxMenuBar::Replace(size_t pos, wxMenu *menu, const wxString& title)
 684 {
 685     wxMenu *menuOld = wxMenuBarBase::Replace(pos, menu, title);
 686     if ( !menuOld )
 687         return FALSE;
 688     m_titles[pos] = title;
 689
 690     if ( IsAttached() )
 691     {
 692         if (s_macInstalledMenuBar == this)
 693         {
 694             menuOld->MacAfterDisplay( false ) ;
 695             ::DeleteMenu( menuOld->MacGetMenuId() /* m_menus[pos]->MacGetMenuId() */ ) ;
 696             {
 697                 menu->MacBeforeDisplay( false ) ;
 698                 UMASetMenuTitle( MAC_WXHMENU(menu->GetHMenu()) , title , m_font.GetEncoding() ) ;
 699                 if ( pos == m_menus.GetCount() - 1)
 700                 {
 701                     ::InsertMenu( MAC_WXHMENU(menu->GetHMenu()) , 0 ) ;
 702                 }
 703                 else
 704                 {
 705                     ::InsertMenu( MAC_WXHMENU(menu->GetHMenu()) , m_menus[pos+1]->MacGetMenuId() ) ;
 706                 }
 707             }
 708         }
 709
 710         Refresh();
 711     }
 712
 713     return menuOld;
 714 }
 715
 716 bool wxMenuBar::Insert(size_t pos, wxMenu *menu, const wxString& title)
 717 {
 718     if ( !wxMenuBarBase::Insert(pos, menu, title) )
 719         return FALSE;
 720
 721     m_titles.Insert(title, pos);
 722
 723     UMASetMenuTitle( MAC_WXHMENU(menu->GetHMenu()) , title , m_font.GetEncoding() ) ;
 724
 725     if ( IsAttached() && s_macInstalledMenuBar == this )
 726     {
 727         if (s_macInstalledMenuBar == this)
 728         {
 729             menu->MacBeforeDisplay( false ) ;
 730             if ( pos == (size_t) -1  || pos + 1 == m_menus.GetCount() )
 731             {
 732                 ::InsertMenu( MAC_WXHMENU(menu->GetHMenu()) , 0 ) ;
 733             }
 734             else
 735             {
 736                 ::InsertMenu( MAC_WXHMENU(menu->GetHMenu()) , m_menus[pos+1]->MacGetMenuId() ) ;
 737             }
 738         }
 739         Refresh();
 740     }
 741
 742     return TRUE;
 743 }
 744
 745 wxMenu *wxMenuBar::Remove(size_t pos)
 746 {
 747     wxMenu *menu = wxMenuBarBase::Remove(pos);
 748     if ( !menu )
 749         return NULL;
 750
 751     if ( IsAttached() )
 752     {
 753         if (s_macInstalledMenuBar == this)
 754         {
 755             ::DeleteMenu( menu->MacGetMenuId() /* m_menus[pos]->MacGetMenuId() */ ) ;
 756         }
 757
 758         Refresh();
 759     }
 760
 761     m_titles.RemoveAt(pos);
 762
 763     return menu;
 764 }
 765
 766 bool wxMenuBar::Append(wxMenu *menu, const wxString& title)
 767 {
 768     WXHMENU submenu = menu ? menu->GetHMenu() : 0;
 769     wxCHECK_MSG( submenu, FALSE, wxT("can't append invalid menu to menubar") );
 770
 771     if ( !wxMenuBarBase::Append(menu, title) )
 772         return FALSE;
 773
 774     m_titles.Add(title);
 775
 776     UMASetMenuTitle( MAC_WXHMENU(menu->GetHMenu()) , title , m_font.GetEncoding() ) ;
 777
 778     if ( IsAttached() )
 779     {
 780         if (s_macInstalledMenuBar == this)
 781         {
 782             ::InsertMenu( MAC_WXHMENU(menu->GetHMenu()) , 0 ) ;
 783         }
 784
 785         Refresh();
 786     }
 787
 788    // m_invokingWindow is set after wxFrame::SetMenuBar(). This call enables
 789     // adding menu later on.
 790     if (m_invokingWindow)
 791         wxMenubarSetInvokingWindow( menu, m_invokingWindow );
 792
 793     return TRUE;
 794 }
 795
 796 static void wxMenubarUnsetInvokingWindow( wxMenu *menu )
 797 {
 798     menu->SetInvokingWindow( (wxWindow*) NULL );
 799
 800     wxMenuItemList::Node *node = menu->GetMenuItems().GetFirst();
 801     while (node)
 802     {
 803         wxMenuItem *menuitem = node->GetData();
 804         if (menuitem->IsSubMenu())
 805             wxMenubarUnsetInvokingWindow( menuitem->GetSubMenu() );
 806         node = node->GetNext();
 807     }
 808 }
 809
 810 static void wxMenubarSetInvokingWindow( wxMenu *menu, wxWindow *win )
 811 {
 812     menu->SetInvokingWindow( win );
 813
 814     wxMenuItemList::Node *node = menu->GetMenuItems().GetFirst();
 815     while (node)
 816     {
 817         wxMenuItem *menuitem = node->GetData();
 818         if (menuitem->IsSubMenu())
 819             wxMenubarSetInvokingWindow( menuitem->GetSubMenu() , win );
 820         node = node->GetNext();
 821     }
 822 }
 823
 824 void wxMenuBar::UnsetInvokingWindow()
 825 {
 826     m_invokingWindow = (wxWindow*) NULL;
 827     wxMenuList::Node *node = m_menus.GetFirst();
 828     while (node)
 829     {
 830         wxMenu *menu = node->GetData();
 831         wxMenubarUnsetInvokingWindow( menu );
 832         node = node->GetNext();
 833     }
 834 }
 835
 836 void wxMenuBar::SetInvokingWindow(wxFrame *frame)
 837 {
 838     m_invokingWindow = frame;
 839     wxMenuList::Node *node = m_menus.GetFirst();
 840     while (node)
 841     {
 842         wxMenu *menu = node->GetData();
 843         wxMenubarSetInvokingWindow( menu, frame );
 844         node = node->GetNext();
 845     }
 846 }
 847
 848 void wxMenuBar::Detach()
 849 {
 850     wxMenuBarBase::Detach() ;
 851 }
 852
 853 void wxMenuBar::Attach(wxFrame *frame)
 854 {
 855     wxMenuBarBase::Attach( frame ) ;
 856 }
 857 // ---------------------------------------------------------------------------
 858 // wxMenuBar searching for menu items
 859 // ---------------------------------------------------------------------------
 860
 861 // Find the itemString in menuString, and return the item id or wxNOT_FOUND
 862 int wxMenuBar::FindMenuItem(const wxString& menuString,
 863                             const wxString& itemString) const
 864 {
 865     wxString menuLabel = wxStripMenuCodes(menuString);
 866     size_t count = GetMenuCount();
 867     for ( size_t i = 0; i < count; i++ )
 868     {
 869         wxString title = wxStripMenuCodes(m_titles[i]);
 870         if ( menuString == title )
 871             return m_menus[i]->FindItem(itemString);
 872     }
 873
 874     return wxNOT_FOUND;
 875 }
 876
 877 wxMenuItem *wxMenuBar::FindItem(int id, wxMenu **itemMenu) const
 878 {
 879     if ( itemMenu )
 880         *itemMenu = NULL;
 881
 882     wxMenuItem *item = NULL;
 883     size_t count = GetMenuCount();
 884     for ( size_t i = 0; !item && (i < count); i++ )
 885     {
 886         item = m_menus[i]->FindItem(id, itemMenu);
 887     }
 888
 889     return item;
 890 }
 891
 892