src/mac/carbon/menu.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        menu.cpp
   3 // Purpose:     wxMenu, wxMenuBar, wxMenuItem
   4 // Author:      AUTHOR
   5 // Modified by:
   6 // Created:     ??/??/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) AUTHOR
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12
  13 // ============================================================================
  14 // headers & declarations
  15 // ============================================================================
  16
  17 // wxWindows headers
  18 // -----------------
  19
  20 #ifdef __GNUG__
  21 #pragma implementation "menu.h"
  22 #pragma implementation "menuitem.h"
  23 #endif
  24
  25 #include "wx/app.h"
  26 #include "wx/menu.h"
  27 #include "wx/menuitem.h"
  28 #include "wx/window.h"
  29 #include "wx/log.h"
  30 #include "wx/utils.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 int formerHelpMenuItems = 0 ;
  46
  47 const short kwxMacMenuBarResource = 1 ;
  48 const short kwxMacAppleMenuId = 1 ;
  49
  50 // ============================================================================
  51 // implementation
  52 // ============================================================================
  53
  54
  55 // Menus
  56
  57 // Construct a menu with optional title (then use append)
  58
  59 #ifdef __UNIX__
  60 short wxMenu::s_macNextMenuId = 3 ;
  61 #else
  62 short wxMenu::s_macNextMenuId = 2 ;
  63 #endif
  64
  65 void wxMenu::Init()
  66 {
  67     m_doBreak = FALSE;
  68
  69     // create the menu
  70         Str255  label;
  71         wxMenuItem::MacBuildMenuString( label, NULL , NULL , m_title , false );
  72         m_macMenuId = s_macNextMenuId++;
  73     wxCHECK_RET( s_macNextMenuId < 236 , "menu ids > 235 cannot be used for submenus on mac" );
  74         m_hMenu = UMANewMenu(m_macMenuId, label);
  75
  76     if ( !m_hMenu )
  77     {
  78         wxLogLastError("CreatePopupMenu");
  79     }
  80
  81     // if we have a title, insert it in the beginning of the menu
  82     if ( !!m_title )
  83     {
  84         Append(idMenuTitle, m_title) ;
  85         AppendSeparator() ;
  86     }
  87 }
  88
  89 wxMenu::~wxMenu()
  90 {
  91         if (m_hMenu)
  92                 UMADisposeMenu(m_hMenu);
  93
  94 #if wxUSE_ACCEL
  95     // delete accels
  96     WX_CLEAR_ARRAY(m_accels);
  97 #endif // wxUSE_ACCEL
  98 }
  99
 100 void wxMenu::Break()
 101 {
 102         // not available on the mac platform
 103 }
 104
 105 #if wxUSE_ACCEL
 106
 107 int wxMenu::FindAccel(int id) const
 108 {
 109     size_t n, count = m_accels.GetCount();
 110     for ( n = 0; n < count; n++ )
 111     {
 112         if ( m_accels[n]->m_command == id )
 113             return n;
 114     }
 115
 116     return wxNOT_FOUND;
 117 }
 118
 119 void wxMenu::UpdateAccel(wxMenuItem *item)
 120 {
 121     // find the (new) accel for this item
 122     wxAcceleratorEntry *accel = wxGetAccelFromString(item->GetText());
 123     if ( accel )
 124         accel->m_command = item->GetId();
 125
 126     // find the old one
 127     int n = FindAccel(item->GetId());
 128     if ( n == wxNOT_FOUND )
 129     {
 130         // no old, add new if any
 131         if ( accel )
 132             m_accels.Add(accel);
 133         else
 134             return;     // skipping RebuildAccelTable() below
 135     }
 136     else
 137     {
 138         // replace old with new or just remove the old one if no new
 139         delete m_accels[n];
 140         if ( accel )
 141             m_accels[n] = accel;
 142         else
 143             m_accels.Remove(n);
 144     }
 145
 146     if ( IsAttached() )
 147     {
 148         m_menuBar->RebuildAccelTable();
 149     }
 150 }
 151
 152 #endif // wxUSE_ACCEL
 153
 154 // function appends a new item or submenu to the menu
 155 // append a new item or submenu to the menu
 156 bool wxMenu::DoInsertOrAppend(wxMenuItem *pItem, size_t pos)
 157 {
 158     wxASSERT_MSG( pItem != NULL, "can't append NULL item to the menu" );
 159 #if wxUSE_ACCEL
 160     UpdateAccel(pItem);
 161 #endif // wxUSE_ACCEL
 162
 163         if ( pItem->IsSeparator() )
 164         {
 165                 if ( pos == (size_t)-1 )
 166                 {
 167                         MacAppendMenu(m_hMenu, "\p-");
 168                 }
 169                 else
 170                 {
 171                         MacInsertMenuItem(m_hMenu, "\p-" , pos);
 172                 }
 173         }
 174         else
 175         {
 176                 wxMenu *pSubMenu = pItem->GetSubMenu() ;
 177                 if ( pSubMenu != NULL )
 178                 {
 179                         Str255 label;
 180                         wxASSERT_MSG( pSubMenu->m_hMenu != NULL , "invalid submenu added");
 181                     pSubMenu->m_menuParent = this ;
 182                         wxMenuItem::MacBuildMenuString( label , NULL , NULL , pItem->GetText() ,false);
 183
 184                         if (wxMenuBar::MacGetInstalledMenuBar() == m_menuBar)
 185                         {
 186                                 UMAInsertMenu( pSubMenu->m_hMenu , -1 ) ;
 187                         }
 188
 189                         if ( pos == (size_t)-1 )
 190                         {
 191                                 UMAAppendSubMenuItem(m_hMenu, label, pSubMenu->m_macMenuId);
 192                         }
 193                         else
 194                         {
 195                                 UMAInsertSubMenuItem(m_hMenu, label , pos, pSubMenu->m_macMenuId);
 196                         }
 197                 }
 198                 else
 199                 {
 200                         Str255 label ;
 201                         UInt8 modifiers ;
 202                         SInt16 key ;
 203                         wxMenuItem::MacBuildMenuString( label, &key  , &modifiers , pItem->GetText(), pItem->GetId() == wxApp::s_macAboutMenuItemId);
 204                         if ( label[0] == 0 )
 205                         {
 206                                 // we cannot add empty menus on mac
 207                                 label[0] = 1 ;
 208                                 label[1] = ' ' ;
 209                         }
 210                         if ( pos == (size_t)-1 )
 211                         {
 212                                 UMAAppendMenuItem(m_hMenu, label,key,modifiers);
 213                         }
 214                         else
 215                         {
 216                                 UMAInsertMenuItem(m_hMenu, label , pos,key,modifiers);
 217                         }
 218                         if ( pItem->GetId() == idMenuTitle )
 219                         {
 220                                 if ( pos == (size_t)-1 )
 221                                 {
 222                                         UMADisableMenuItem( m_hMenu , CountMenuItems( m_hMenu ) ) ;
 223                                 }
 224                                 else
 225                                 {
 226                                         UMADisableMenuItem( m_hMenu , pos + 1 ) ;
 227                                 }
 228                         }
 229                 }
 230         }
 231     // if we're already attached to the menubar, we must update it
 232     if ( IsAttached() )
 233     {
 234         m_menuBar->Refresh();
 235     }
 236         return TRUE ;
 237 }
 238
 239 bool wxMenu::DoAppend(wxMenuItem *item)
 240 {
 241     return wxMenuBase::DoAppend(item) && DoInsertOrAppend(item);
 242 }
 243
 244 bool wxMenu::DoInsert(size_t pos, wxMenuItem *item)
 245 {
 246     return wxMenuBase::DoInsert(pos, item) && DoInsertOrAppend(item, pos);
 247 }
 248
 249 wxMenuItem *wxMenu::DoRemove(wxMenuItem *item)
 250 {
 251     // we need to find the items position in the child list
 252     size_t pos;
 253     wxMenuItemList::Node *node = GetMenuItems().GetFirst();
 254     for ( pos = 0; node; pos++ )
 255     {
 256         if ( node->GetData() == item )
 257             break;
 258
 259         node = node->GetNext();
 260     }
 261
 262     // DoRemove() (unlike Remove) can only be called for existing item!
 263     wxCHECK_MSG( node, NULL, wxT("bug in wxMenu::Remove logic") );
 264
 265 #if wxUSE_ACCEL
 266     // remove the corresponding accel from the accel table
 267     int n = FindAccel(item->GetId());
 268     if ( n != wxNOT_FOUND )
 269     {
 270         delete m_accels[n];
 271
 272         m_accels.Remove(n);
 273     }
 274     //else: this item doesn't have an accel, nothing to do
 275 #endif // wxUSE_ACCEL
 276
 277         ::DeleteMenuItem( m_hMenu , pos + 1);
 278
 279     if ( IsAttached() )
 280     {
 281         // otherwise, the chane won't be visible
 282         m_menuBar->Refresh();
 283     }
 284
 285     // and from internal data structures
 286     return wxMenuBase::DoRemove(item);
 287 }
 288
 289 // ---------------------------------------------------------------------------
 290 // accelerator helpers
 291 // ---------------------------------------------------------------------------
 292
 293 #if wxUSE_ACCEL
 294
 295 // create the wxAcceleratorEntries for our accels and put them into provided
 296 // array - return the number of accels we have
 297 size_t wxMenu::CopyAccels(wxAcceleratorEntry *accels) const
 298 {
 299     size_t count = GetAccelCount();
 300     for ( size_t n = 0; n < count; n++ )
 301     {
 302         *accels++ = *m_accels[n];
 303     }
 304
 305     return count;
 306 }
 307
 308 #endif // wxUSE_ACCEL
 309
 310 void wxMenu::SetTitle(const wxString& label)
 311 {
 312         Str255 title ;
 313     m_title = label ;
 314         wxMenuItem::MacBuildMenuString( title, NULL , NULL , label , false );
 315         UMASetMenuTitle( m_hMenu , title ) ;
 316 }
 317 bool wxMenu::ProcessCommand(wxCommandEvent & event)
 318 {
 319     bool processed = FALSE;
 320
 321 #if WXWIN_COMPATIBILITY
 322     // Try a callback
 323     if (m_callback)
 324     {
 325         (void)(*(m_callback))(*this, event);
 326         processed = TRUE;
 327     }
 328 #endif WXWIN_COMPATIBILITY
 329
 330     // Try the menu's event handler
 331     if ( !processed && GetEventHandler())
 332     {
 333         processed = GetEventHandler()->ProcessEvent(event);
 334     }
 335
 336     // Try the window the menu was popped up from (and up through the
 337     // hierarchy)
 338     wxWindow *win = GetInvokingWindow();
 339     if ( !processed && win )
 340         processed = win->GetEventHandler()->ProcessEvent(event);
 341
 342     return processed;
 343 }
 344
 345
 346 // ---------------------------------------------------------------------------
 347 // other
 348 // ---------------------------------------------------------------------------
 349
 350 void wxMenu::Attach(wxMenuBar *menubar)
 351 {
 352     // menu can be in at most one menubar because otherwise they would both
 353     // delete the menu pointer
 354     wxASSERT_MSG( !m_menuBar, wxT("menu belongs to 2 menubars, expect a crash") );
 355
 356     m_menuBar = menubar;
 357 }
 358
 359 void wxMenu::Detach()
 360 {
 361     wxASSERT_MSG( m_menuBar, wxT("can't detach menu if it's not attached") );
 362
 363     m_menuBar = NULL;
 364 }
 365
 366 wxWindow *wxMenu::GetWindow() const
 367 {
 368     if ( m_invokingWindow != NULL )
 369         return m_invokingWindow;
 370     else if ( m_menuBar != NULL)
 371         return (wxWindow *) m_menuBar->GetFrame();
 372
 373     return NULL;
 374 }
 375
 376 // helper functions returning the mac menu position for a certain item, note that this is
 377 // mac-wise 1 - based, i.e. the first item has index 1 whereas on MSWin it has pos 0
 378
 379 int wxMenu::MacGetIndexFromId( int id )
 380 {
 381     size_t pos;
 382     wxMenuItemList::Node *node = GetMenuItems().GetFirst();
 383     for ( pos = 0; node; pos++ )
 384     {
 385         if ( node->GetData()->GetId() == id )
 386             break;
 387
 388         node = node->GetNext();
 389     }
 390
 391     if (!node)
 392                 return 0;
 393
 394         return pos + 1 ;
 395 }
 396
 397 int wxMenu::MacGetIndexFromItem( wxMenuItem *pItem )
 398 {
 399     size_t pos;
 400     wxMenuItemList::Node *node = GetMenuItems().GetFirst();
 401     for ( pos = 0; node; pos++ )
 402     {
 403         if ( node->GetData() == pItem )
 404             break;
 405
 406         node = node->GetNext();
 407     }
 408
 409     if (!node)
 410                 return 0;
 411
 412         return pos + 1 ;
 413 }
 414
 415 void wxMenu::MacEnableMenu( bool bDoEnable )
 416 {
 417         if ( bDoEnable )
 418                 UMAEnableMenuItem( m_hMenu , 0 ) ;
 419         else
 420                 UMADisableMenuItem( m_hMenu , 0 ) ;
 421
 422         ::DrawMenuBar() ;
 423 }
 424
 425 bool wxMenu::MacMenuSelect( wxEvtHandler* handler, long when , int macMenuId, int macMenuItemNum )
 426 {
 427   int pos;
 428   wxNode *node;
 429
 430         if ( m_macMenuId == macMenuId )
 431         {
 432                 node = GetMenuItems().Nth(macMenuItemNum-1);
 433                 if (node)
 434                 {
 435                         wxMenuItem *pItem = (wxMenuItem*)node->Data();
 436
 437                         if (pItem->IsCheckable())
 438                                 pItem->Check(! pItem->IsChecked());
 439
 440                         wxCommandEvent event(wxEVT_COMMAND_MENU_SELECTED, pItem->GetId());
 441                         event.m_timeStamp = when;
 442                         event.SetEventObject(handler);
 443                 event.SetInt( pItem->GetId() );
 444                         {
 445                                 bool processed = false ;
 446
 447 #if WXWIN_COMPATIBILITY
 448                             // Try a callback
 449                             if (m_callback)
 450                             {
 451                                     (void) (*(m_callback)) (*this, event);
 452                                     processed = TRUE;
 453                             }
 454 #endif
 455                             // Try the menu's event handler
 456                             if ( !processed && handler)
 457                             {
 458                                     processed = handler->ProcessEvent(event);
 459                             }
 460
 461                                 // Try the window the menu was popped up from (and up
 462                                 // through the hierarchy)
 463                                 if ( !processed && GetInvokingWindow())
 464                                 processed = GetInvokingWindow()->GetEventHandler()->ProcessEvent(event);
 465                         }
 466                         return true ;
 467                 }
 468         }
 469 #ifndef __WXMAC_X__
 470         else if ( macMenuId == kHMHelpMenuID )
 471         {
 472                 int menuItem = formerHelpMenuItems ;
 473           for (pos = 0, node = GetMenuItems().First(); node; node = node->Next(), pos++)
 474           {
 475                 wxMenuItem * pItem = (wxMenuItem *)  node->Data() ;
 476
 477                 wxMenu *pSubMenu = pItem->GetSubMenu() ;
 478                         if ( pSubMenu != NULL )
 479                         {
 480                         }
 481                         else
 482                         {
 483                                 if ( pItem->GetId() != wxApp::s_macAboutMenuItemId )
 484                                         ++menuItem ;
 485
 486                                 if ( menuItem == macMenuItemNum )
 487                                 {
 488                                         wxCommandEvent event(wxEVT_COMMAND_MENU_SELECTED, pItem->GetId());
 489                                         event.m_timeStamp = when;
 490                                         event.SetEventObject(handler);
 491                                 event.SetInt( pItem->GetId() );
 492                                         {
 493                                                 bool processed = false ;
 494 #if WXWIN_COMPATIBILITY
 495                                             // Try a callback
 496                                             if (m_callback)
 497                                             {
 498                                                     (void) (*(m_callback)) (*this, event);
 499                                                     processed = TRUE;
 500                                             }
 501 #endif
 502                                             // Try the menu's event handler
 503                                             if ( !processed && handler)
 504                                             {
 505                                                     processed = handler->ProcessEvent(event);
 506                                             }
 507
 508                                                 // Try the window the menu was popped up from (and up
 509                                                 // through the hierarchy)
 510                                                 if ( !processed && GetInvokingWindow())
 511                                                 processed = GetInvokingWindow()->GetEventHandler()->ProcessEvent(event);
 512                                         }
 513                                         return true ;
 514                                 }
 515                         }
 516           }
 517         }
 518 #endif // __WXMAC_X__
 519
 520   for (pos = 0, node = GetMenuItems().First(); node; node = node->Next(), pos++)
 521   {
 522                 wxMenuItem * pItem = (wxMenuItem *)  node->Data() ;
 523
 524                 wxMenu *pSubMenu = pItem->GetSubMenu() ;
 525                 if ( pSubMenu != NULL )
 526                 {
 527                         if ( pSubMenu->MacMenuSelect( handler , when , macMenuId , macMenuItemNum ) )
 528                                 return true ;
 529                 }
 530   }
 531
 532         return false ;
 533 }
 534
 535 // Menu Bar
 536
 537 /*
 538
 539 Mac Implementation note :
 540
 541 The Mac has only one global menubar, so we attempt to install the currently
 542 active menubar from a frame, we currently don't take into account mdi-frames
 543 which would ask for menu-merging
 544
 545 Secondly there is no mac api for changing a menubar that is not the current
 546 menubar, so we have to wait for preparing the actual menubar until the
 547 wxMenubar is to be used
 548
 549 We can in subsequent versions use MacInstallMenuBar to provide some sort of
 550 auto-merge for MDI in case this will be necessary
 551
 552 */
 553
 554 wxMenuBar* wxMenuBar::s_macInstalledMenuBar = NULL ;
 555
 556 void wxMenuBar::Init()
 557 {
 558     m_eventHandler = this;
 559     m_menuBarFrame = NULL;
 560 }
 561
 562 wxMenuBar::wxMenuBar()
 563 {
 564     Init();
 565 }
 566
 567 wxMenuBar::wxMenuBar( long WXUNUSED(style) )
 568 {
 569     Init();
 570 }
 571
 572
 573 wxMenuBar::wxMenuBar(int count, wxMenu *menus[], const wxString titles[])
 574 {
 575     Init();
 576
 577     m_titles.Alloc(count);
 578
 579     for ( int i = 0; i < count; i++ )
 580     {
 581         m_menus.Append(menus[i]);
 582         m_titles.Add(titles[i]);
 583
 584         menus[i]->Attach(this);
 585     }
 586 }
 587
 588 wxMenuBar::~wxMenuBar()
 589 {
 590         if (s_macInstalledMenuBar == this)
 591         {
 592                 ::ClearMenuBar();
 593                 s_macInstalledMenuBar = NULL;
 594         }
 595
 596 }
 597
 598 void wxMenuBar::Refresh()
 599 {
 600     wxCHECK_RET( IsAttached(), wxT("can't refresh unatteched menubar") );
 601
 602     DrawMenuBar();
 603 }
 604
 605 #if wxUSE_ACCEL
 606
 607 void wxMenuBar::RebuildAccelTable()
 608 {
 609     // merge the accelerators of all menus into one accel table
 610     size_t nAccelCount = 0;
 611     size_t i, count = GetMenuCount();
 612     for ( i = 0; i < count; i++ )
 613     {
 614         nAccelCount += m_menus[i]->GetAccelCount();
 615     }
 616
 617     if ( nAccelCount )
 618     {
 619         wxAcceleratorEntry *accelEntries = new wxAcceleratorEntry[nAccelCount];
 620
 621         nAccelCount = 0;
 622         for ( i = 0; i < count; i++ )
 623         {
 624             nAccelCount += m_menus[i]->CopyAccels(&accelEntries[nAccelCount]);
 625         }
 626
 627         m_accelTable = wxAcceleratorTable(nAccelCount, accelEntries);
 628
 629         delete [] accelEntries;
 630     }
 631 }
 632
 633 #endif // wxUSE_ACCEL
 634
 635
 636 void wxMenuBar::MacInstallMenuBar()
 637 {
 638         if ( s_macInstalledMenuBar == this )
 639                 return ;
 640
 641         Handle menubar = ::GetNewMBar( kwxMacMenuBarResource ) ;
 642         wxString message ;
 643         wxCHECK_RET( menubar != NULL, "can't read MBAR resource" );
 644         ::SetMenuBar( menubar ) ;
 645         ::DisposeHandle( menubar ) ;
 646
 647                 MenuHandle menu = ::GetMenuHandle( kwxMacAppleMenuId ) ;
 648                 ::AppendResMenu(menu, 'DRVR');
 649
 650         for (int i = 0; i < m_menus.GetCount(); i++)
 651         {
 652                         Str255  label;
 653         wxNode *node;
 654         wxMenuItem *item;
 655         int pos ;
 656                         wxMenu* menu = m_menus[i] , *subMenu = NULL ;
 657
 658 #if !TARGET_CARBON
 659                         /* the help menu does not exist in CARBON anymore */
 660                         if( m_titles[i] == "?" || m_titles[i] == "&?"  || m_titles[i] == wxApp::s_macHelpMenuTitleName )
 661                         {
 662                                 MenuHandle mh = NULL ;
 663                                 if ( HMGetHelpMenuHandle( &mh ) != noErr )
 664                                 {
 665                                         continue ;
 666                                 }
 667                                 if ( formerHelpMenuItems == 0 )
 668                                 {
 669                                         if( mh )
 670                                                 formerHelpMenuItems = CountMenuItems( mh ) ;
 671                                 }
 672
 673                                 for (pos = 0 , node = menu->GetMenuItems().First(); node; node = node->Next(), pos++)
 674                                 {
 675                                         item = (wxMenuItem *)node->Data();
 676                                         subMenu = item->GetSubMenu() ;
 677                                         if (subMenu)
 678                                         {
 679                                                 // we don't support hierarchical menus in the help menu yet
 680                                         }
 681                                         else
 682                                         {
 683                                                 if ( item->IsSeparator() )
 684                                                 {
 685                                                         if ( mh )
 686                                                                 UMAAppendMenuItem(mh, "\p-" );
 687                                                 }
 688                                                 else
 689                                                 {
 690                                                         Str255 label ;
 691                                                         UInt8 modifiers ;
 692                                                         SInt16 key ;
 693                                                         wxMenuItem::MacBuildMenuString( label, &key , &modifiers  , item->GetText(), item->GetId() != wxApp::s_macAboutMenuItemId); // no shortcut in about menu
 694                                                         if ( label[0] == 0 )
 695                                                         {
 696                                                                 // we cannot add empty menus on mac
 697                                                                 label[0] = 1 ;
 698                                                                 label[1] = ' ' ;
 699                                                         }
 700                                                         if ( item->GetId() == wxApp::s_macAboutMenuItemId )
 701                                                         {
 702                                                                         UMASetMenuItemText( GetMenuHandle( kwxMacAppleMenuId ) , 1 , label );
 703                                                                         UMAEnableMenuItem( GetMenuHandle( kwxMacAppleMenuId ) , 1 );
 704                                                         }
 705                                                         else
 706                                                         {
 707                                                                 if ( mh )
 708                                                                         UMAAppendMenuItem(mh, label , key , modifiers );
 709                                                         }
 710                                                 }
 711                                         }
 712                                 }
 713                         }
 714 #else
 715                         if( m_titles[i] == "?" || m_titles[i] == "&?"  || m_titles[i] == wxApp::s_macHelpMenuTitleName )
 716                         {
 717                                 wxMenuItem::MacBuildMenuString( label, NULL , NULL , m_titles[i] , false );
 718                                 UMASetMenuTitle( menu->GetHMenu() , label ) ;
 719
 720                                 for (pos = 0 , node = menu->GetMenuItems().First(); node; node = node->Next(), pos++)
 721                                 {
 722                                         item = (wxMenuItem *)node->Data();
 723                                         subMenu = item->GetSubMenu() ;
 724                                         if (subMenu)
 725                                         {
 726                                                 UMAInsertMenu( subMenu->GetHMenu() , -1 ) ;
 727                                         }
 728                                         else
 729                                         {
 730                                                 if ( item->GetId() == wxApp::s_macAboutMenuItemId )
 731                                                 {
 732                                                         Str255 label ;
 733                                                         UInt8 modifiers ;
 734                                                         SInt16 key ;
 735                                                         wxMenuItem::MacBuildMenuString( label, &key , &modifiers  , item->GetText(), item->GetId() != wxApp::s_macAboutMenuItemId); // no shortcut in about menu
 736                                                         UMASetMenuItemText( GetMenuHandle( kwxMacAppleMenuId ) , 1 , label );
 737                                                         UMAEnableMenuItem( GetMenuHandle( kwxMacAppleMenuId ) , 1 );
 738                                                 }
 739                                         }
 740                                 }
 741                                 UMAInsertMenu(m_menus[i]->GetHMenu(), 0);
 742                         }
 743 #endif
 744                         else
 745                         {
 746                                 wxMenuItem::MacBuildMenuString( label, NULL , NULL , m_titles[i] , false );
 747                                 UMASetMenuTitle( menu->GetHMenu() , label ) ;
 748                                 for (pos = 0, node = menu->GetMenuItems().First(); node; node = node->Next(), pos++)
 749                                 {
 750                                         item = (wxMenuItem *)node->Data();
 751                                         subMenu = item->GetSubMenu() ;
 752                                         if (subMenu)
 753                                         {
 754                                                 UMAInsertMenu( subMenu->GetHMenu() , -1 ) ;
 755                                         }
 756                                 }
 757                                 UMAInsertMenu(m_menus[i]->GetHMenu(), 0);
 758                         }
 759                 }
 760                 UMADrawMenuBar() ;
 761
 762         s_macInstalledMenuBar = this;
 763 }
 764
 765 void wxMenuBar::EnableTop(size_t pos, bool enable)
 766 {
 767     wxCHECK_RET( IsAttached(), wxT("doesn't work with unattached menubars") );
 768         m_menus[pos]->MacEnableMenu( enable ) ;
 769     Refresh();
 770 }
 771
 772 void wxMenuBar::SetLabelTop(size_t pos, const wxString& label)
 773 {
 774     wxCHECK_RET( pos < GetMenuCount(), wxT("invalid menu index") );
 775
 776     m_titles[pos] = label;
 777
 778     if ( !IsAttached() )
 779     {
 780         return;
 781     }
 782
 783     m_menus[pos]->SetTitle( label ) ;
 784         if (wxMenuBar::s_macInstalledMenuBar == this) // are we currently installed ?
 785         {
 786                 ::SetMenuBar( GetMenuBar() ) ;
 787                 ::InvalMenuBar() ;
 788         }
 789 }
 790
 791 wxString wxMenuBar::GetLabelTop(size_t pos) const
 792 {
 793     wxCHECK_MSG( pos < GetMenuCount(), wxEmptyString,
 794                  wxT("invalid menu index in wxMenuBar::GetLabelTop") );
 795
 796     return m_titles[pos];
 797 }
 798
 799 int wxMenuBar::FindMenu(const wxString& title)
 800 {
 801     wxString menuTitle = wxStripMenuCodes(title);
 802
 803     size_t count = GetMenuCount();
 804     for ( size_t i = 0; i < count; i++ )
 805     {
 806         wxString title = wxStripMenuCodes(m_titles[i]);
 807         if ( menuTitle == title )
 808             return i;
 809     }
 810
 811     return wxNOT_FOUND;
 812
 813 }
 814
 815
 816 // ---------------------------------------------------------------------------
 817 // wxMenuBar construction
 818 // ---------------------------------------------------------------------------
 819
 820 // ---------------------------------------------------------------------------
 821 // wxMenuBar construction
 822 // ---------------------------------------------------------------------------
 823
 824 wxMenu *wxMenuBar::Replace(size_t pos, wxMenu *menu, const wxString& title)
 825 {
 826     wxMenu *menuOld = wxMenuBarBase::Replace(pos, menu, title);
 827     if ( !menuOld )
 828         return FALSE;
 829     m_titles[pos] = title;
 830
 831     if ( IsAttached() )
 832     {
 833                 if (s_macInstalledMenuBar == this)
 834                 {
 835                         UMADeleteMenu( menuOld->MacGetMenuId() /* m_menus[pos]->MacGetMenuId() */ ) ;
 836                         {
 837                                 Str255  label;
 838                                 wxMenuItem::MacBuildMenuString( label, NULL , NULL , title , false );
 839                                 UMASetMenuTitle( menu->GetHMenu() , label ) ;
 840                                 if ( pos == m_menus.GetCount() - 1)
 841                                 {
 842                                         UMAInsertMenu( menu->GetHMenu() , 0 ) ;
 843                                 }
 844                                 else
 845                                 {
 846                                         UMAInsertMenu( menu->GetHMenu() , m_menus[pos+1]->MacGetMenuId() ) ;
 847                                 }
 848                         }
 849                 }
 850
 851
 852 #if wxUSE_ACCEL
 853         if ( menuOld->HasAccels() || menu->HasAccels() )
 854         {
 855             // need to rebuild accell table
 856             RebuildAccelTable();
 857         }
 858 #endif // wxUSE_ACCEL
 859
 860         Refresh();
 861     }
 862
 863     return menuOld;
 864 }
 865
 866 bool wxMenuBar::Insert(size_t pos, wxMenu *menu, const wxString& title)
 867 {
 868     if ( !wxMenuBarBase::Insert(pos, menu, title) )
 869         return FALSE;
 870
 871     m_titles.Insert(title, pos);
 872
 873     menu->Attach(this);
 874
 875     if ( IsAttached() )
 876     {
 877         if ( pos == (size_t) -1 )
 878                 {
 879                         ::InsertMenu( menu->GetHMenu() , 0 ) ;
 880                 }
 881                 else
 882                 {
 883                         ::InsertMenu( menu->GetHMenu() , m_menus[pos+1]->MacGetMenuId() ) ;
 884                 }
 885
 886 #if wxUSE_ACCEL
 887         if ( menu->HasAccels() )
 888         {
 889             // need to rebuild accell table
 890             RebuildAccelTable();
 891         }
 892 #endif // wxUSE_ACCEL
 893
 894         Refresh();
 895     }
 896
 897     return TRUE;
 898 }
 899
 900 void wxMenuBar::MacMenuSelect(wxEvtHandler* handler, long when , int macMenuId, int macMenuItemNum)
 901 {
 902         // first scan fast for direct commands, i.e. menus which have these commands directly in their own list
 903
 904         if ( macMenuId == kwxMacAppleMenuId && macMenuItemNum == 1 )
 905         {
 906                         wxCommandEvent event(wxEVT_COMMAND_MENU_SELECTED, wxApp::s_macAboutMenuItemId );
 907                         event.m_timeStamp = when;
 908                         event.SetEventObject(handler);
 909         event.SetInt( wxApp::s_macAboutMenuItemId );
 910                         handler->ProcessEvent(event);
 911         }
 912         else
 913         {
 914           for (int i = 0; i < m_menus.GetCount() ; i++)
 915           {
 916                 if ( m_menus[i]->MacGetMenuId() == macMenuId
 917 #ifndef __WXMAC_X__
 918                      ||
 919                         ( macMenuId == kHMHelpMenuID && ( m_titles[i] == "?" || m_titles[i] == "&?"  || m_titles[i] == wxApp::s_macHelpMenuTitleName ) )
 920 #endif
 921                         )
 922                 {
 923                         if ( m_menus[i]->MacMenuSelect( handler , when , macMenuId , macMenuItemNum ) )
 924                                 return ;
 925                         else
 926                         {
 927                                 //TODO flag this as an error since it must contain the item
 928                                 return ;
 929                         }
 930                 }
 931                 }
 932
 933           for (int i = 0; i < m_menus.GetCount(); i++)
 934           {
 935                 if ( m_menus[i]->MacMenuSelect( handler , when , macMenuId , macMenuItemNum ) )
 936                 {
 937                         break ;
 938                 }
 939           }
 940         }
 941 }
 942
 943 wxMenu *wxMenuBar::Remove(size_t pos)
 944 {
 945     wxMenu *menu = wxMenuBarBase::Remove(pos);
 946     if ( !menu )
 947         return NULL;
 948
 949     if ( IsAttached() )
 950     {
 951                 if (s_macInstalledMenuBar == this)
 952                 {
 953                         ::DeleteMenu( menu->MacGetMenuId() /* m_menus[pos]->MacGetMenuId() */ ) ;
 954                 }
 955
 956         menu->Detach();
 957
 958 #if wxUSE_ACCEL
 959         if ( menu->HasAccels() )
 960         {
 961             // need to rebuild accell table
 962             RebuildAccelTable();
 963         }
 964 #endif // wxUSE_ACCEL
 965
 966         Refresh();
 967     }
 968
 969     m_titles.Remove(pos);
 970
 971     return menu;
 972 }
 973
 974 bool wxMenuBar::Append(wxMenu *menu, const wxString& title)
 975 {
 976     WXHMENU submenu = menu ? menu->GetHMenu() : 0;
 977     wxCHECK_MSG( submenu, FALSE, wxT("can't append invalid menu to menubar") );
 978
 979     if ( !wxMenuBarBase::Append(menu, title) )
 980         return FALSE;
 981
 982     menu->Attach(this);
 983
 984     m_titles.Add(title);
 985
 986     if ( IsAttached() )
 987     {
 988                 if (s_macInstalledMenuBar == this)
 989                 {
 990                         ::InsertMenu( menu->GetHMenu() , 0 ) ;
 991                 }
 992
 993 #if wxUSE_ACCEL
 994         if ( menu->HasAccels() )
 995         {
 996             // need to rebuild accell table
 997             RebuildAccelTable();
 998         }
 999 #endif // wxUSE_ACCEL
1000
1001         Refresh();
1002     }
1003
1004     return TRUE;
1005 }
1006
1007 void wxMenuBar::Attach(wxFrame *frame)
1008 {
1009 //    wxASSERT_MSG( !IsAttached(), wxT("menubar already attached!") );
1010
1011     m_menuBarFrame = frame;
1012
1013 #if wxUSE_ACCEL
1014     RebuildAccelTable();
1015 #endif // wxUSE_ACCEL
1016 }
1017 // ---------------------------------------------------------------------------
1018 // wxMenuBar searching for menu items
1019 // ---------------------------------------------------------------------------
1020
1021 // Find the itemString in menuString, and return the item id or wxNOT_FOUND
1022 int wxMenuBar::FindMenuItem(const wxString& menuString,
1023                             const wxString& itemString) const
1024 {
1025     wxString menuLabel = wxStripMenuCodes(menuString);
1026     size_t count = GetMenuCount();
1027     for ( size_t i = 0; i < count; i++ )
1028     {
1029         wxString title = wxStripMenuCodes(m_titles[i]);
1030         if ( menuString == title )
1031             return m_menus[i]->FindItem(itemString);
1032     }
1033
1034     return wxNOT_FOUND;
1035 }
1036
1037 wxMenuItem *wxMenuBar::FindItem(int id, wxMenu **itemMenu) const
1038 {
1039     if ( itemMenu )
1040         *itemMenu = NULL;
1041
1042     wxMenuItem *item = NULL;
1043     size_t count = GetMenuCount();
1044     for ( size_t i = 0; !item && (i < count); i++ )
1045     {
1046         item = m_menus[i]->FindItem(id, itemMenu);
1047     }
1048
1049     return item;
1050 }
1051
1052