src/os2/menu.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        menu.cpp
   3 // Purpose:     wxMenu, wxMenuBar, wxMenuItem
   4 // Author:      David Webster
   5 // Modified by:
   6 // Created:     10/10/99
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) David Webster
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifdef __GNUG__
  13     #pragma implementation "menu.h"
  14 #endif
  15
  16 // For compilers that support precompilation, includes "wx.h".
  17 #include "wx/wxprec.h"
  18
  19 #ifndef WX_PRECOMP
  20     #include "wx/frame.h"
  21     #include "wx/menu.h"
  22     #include "wx/utils.h"
  23     #include "wx/intl.h"
  24     #include "wx/log.h"
  25 #endif
  26
  27 #if wxUSE_OWNER_DRAWN
  28     #include "wx/ownerdrw.h"
  29 #endif
  30
  31 #include "wx/os2/private.h"
  32
  33 // other standard headers
  34 #include <string.h>
  35
  36 // ----------------------------------------------------------------------------
  37 // global variables
  38 // ----------------------------------------------------------------------------
  39
  40 extern wxMenu *wxCurrentPopupMenu;
  41
  42 // ----------------------------------------------------------------------------
  43 // constants
  44 // ----------------------------------------------------------------------------
  45
  46 // the (popup) menu title has this special id
  47 static const int idMenuTitle = -2;
  48
  49 // ----------------------------------------------------------------------------
  50 // macros
  51 // ----------------------------------------------------------------------------
  52
  53     IMPLEMENT_DYNAMIC_CLASS(wxMenu, wxEvtHandler)
  54     IMPLEMENT_DYNAMIC_CLASS(wxMenuBar, wxEvtHandler)
  55
  56 // ============================================================================
  57 // implementation
  58 // ============================================================================
  59
  60 // ---------------------------------------------------------------------------
  61 // wxMenu construction, adding and removing menu items
  62 // ---------------------------------------------------------------------------
  63
  64 // Construct a menu with optional title (then use append)
  65 void wxMenu::Init()
  66 {
  67     m_doBreak = FALSE;
  68
  69     // create the menu
  70     m_hMenu = (WXHMENU)0; // CreatePopupMenu();
  71     if ( !m_hMenu )
  72     {
  73         wxLogLastError("CreatePopupMenu");
  74     }
  75
  76     // if we have a title, insert it in the beginning of the menu
  77     if ( !!m_title )
  78     {
  79         Append(idMenuTitle, m_title);
  80         AppendSeparator();
  81     }
  82 }
  83
  84 // The wxWindow destructor will take care of deleting the submenus.
  85 wxMenu::~wxMenu()
  86 {
  87     // we should free Windows resources only if Windows doesn't do it for us
  88     // which happens if we're attached to a menubar or a submenu of another
  89     // menu
  90     if ( !IsAttached() && !GetParent() )
  91     {
  92 /*
  93         if ( !::DestroyMenu(GetHmenu()) )
  94         {
  95             wxLogLastError("DestroyMenu");
  96         }
  97 */
  98     }
  99
 100 #if wxUSE_ACCEL
 101     // delete accels
 102     WX_CLEAR_ARRAY(m_accels);
 103 #endif // wxUSE_ACCEL
 104 }
 105
 106 void wxMenu::Break()
 107 {
 108     // this will take effect during the next call to Append()
 109     m_doBreak = TRUE;
 110 }
 111
 112 #if wxUSE_ACCEL
 113
 114 int wxMenu::FindAccel(int id) const
 115 {
 116     size_t n, count = m_accels.GetCount();
 117     for ( n = 0; n < count; n++ )
 118     {
 119         if ( m_accels[n]->m_command == id )
 120             return n;
 121     }
 122
 123     return wxNOT_FOUND;
 124 }
 125
 126 void wxMenu::UpdateAccel(wxMenuItem *item)
 127 {
 128     // find the (new) accel for this item
 129     wxAcceleratorEntry *accel = wxGetAccelFromString(item->GetText());
 130     if ( accel )
 131         accel->m_command = item->GetId();
 132
 133     // find the old one
 134     int n = FindAccel(item->GetId());
 135     if ( n == wxNOT_FOUND )
 136     {
 137         // no old, add new if any
 138         if ( accel )
 139             m_accels.Add(accel);
 140         else
 141             return;     // skipping RebuildAccelTable() below
 142     }
 143     else
 144     {
 145         // replace old with new or just remove the old one if no new
 146         delete m_accels[n];
 147         if ( accel )
 148             m_accels[n] = accel;
 149         else
 150             m_accels.Remove(n);
 151     }
 152
 153     if ( IsAttached() )
 154     {
 155         m_menuBar->RebuildAccelTable();
 156     }
 157 }
 158
 159 #endif // wxUSE_ACCEL
 160
 161 // append a new item or submenu to the menu
 162 bool wxMenu::DoInsertOrAppend(wxMenuItem *pItem, size_t pos)
 163 {
 164 #if wxUSE_ACCEL
 165     UpdateAccel(pItem);
 166 #endif // wxUSE_ACCEL
 167
 168     UINT flags = 0;
 169 // TODO:
 170 /*
 171     // if "Break" has just been called, insert a menu break before this item
 172     // (and don't forget to reset the flag)
 173     if ( m_doBreak ) {
 174         flags |= MF_MENUBREAK;
 175         m_doBreak = FALSE;
 176     }
 177
 178     if ( pItem->IsSeparator() ) {
 179         flags |= MF_SEPARATOR;
 180     }
 181
 182     // id is the numeric id for normal menu items and HMENU for submenus as
 183     // required by ::AppendMenu() API
 184     UINT id;
 185     wxMenu *submenu = pItem->GetSubMenu();
 186     if ( submenu != NULL ) {
 187         wxASSERT_MSG( submenu->GetHMenu(), wxT("invalid submenu") );
 188
 189         submenu->SetParent(this);
 190
 191         id = (UINT)submenu->GetHMenu();
 192
 193         flags |= MF_POPUP;
 194     }
 195     else {
 196         id = pItem->GetId();
 197     }
 198
 199     LPCTSTR pData;
 200
 201 #if wxUSE_OWNER_DRAWN
 202     if ( pItem->IsOwnerDrawn() ) {  // want to get {Measure|Draw}Item messages?
 203         // item draws itself, pass pointer to it in data parameter
 204         flags |= MF_OWNERDRAW;
 205         pData = (LPCTSTR)pItem;
 206     }
 207     else
 208 #endif
 209     {
 210         // menu is just a normal string (passed in data parameter)
 211         flags |= MF_STRING;
 212
 213         pData = (char*)pItem->GetText().c_str();
 214     }
 215
 216     BOOL ok;
 217     if ( pos == (size_t)-1 )
 218     {
 219         ok = ::AppendMenu(GetHmenu(), flags, id, pData);
 220     }
 221     else
 222     {
 223         ok = ::InsertMenu(GetHmenu(), pos, flags | MF_BYPOSITION, id, pData);
 224     }
 225
 226     if ( !ok )
 227     {
 228         wxLogLastError("Insert or AppendMenu");
 229
 230         return FALSE;
 231     }
 232     else
 233     {
 234         // if we just appended the title, highlight it
 235 #ifdef __WIN32__
 236         if ( (int)id == idMenuTitle )
 237         {
 238             // visually select the menu title
 239             MENUITEMINFO mii;
 240             mii.cbSize = sizeof(mii);
 241             mii.fMask = MIIM_STATE;
 242             mii.fState = MFS_DEFAULT;
 243
 244             if ( !SetMenuItemInfo(GetHmenu(), (unsigned)id, FALSE, &mii) )
 245             {
 246                 wxLogLastError(wxT("SetMenuItemInfo"));
 247             }
 248         }
 249 #endif // __WIN32__
 250
 251         // if we're already attached to the menubar, we must update it
 252         if ( IsAttached() )
 253         {
 254             m_menuBar->Refresh();
 255         }
 256
 257         return TRUE;
 258     }
 259 */
 260     return FALSE;
 261 }
 262
 263 bool wxMenu::DoAppend(wxMenuItem *item)
 264 {
 265     return wxMenuBase::DoAppend(item) && DoInsertOrAppend(item);
 266 }
 267
 268 bool wxMenu::DoInsert(size_t pos, wxMenuItem *item)
 269 {
 270     return wxMenuBase::DoInsert(pos, item) && DoInsertOrAppend(item, pos);
 271 }
 272
 273 wxMenuItem *wxMenu::DoRemove(wxMenuItem *item)
 274 {
 275     // we need to find the items position in the child list
 276     size_t pos;
 277     wxMenuItemList::Node *node = GetMenuItems().GetFirst();
 278     for ( pos = 0; node; pos++ )
 279     {
 280         if ( node->GetData() == item )
 281             break;
 282
 283         node = node->GetNext();
 284     }
 285
 286     // DoRemove() (unlike Remove) can only be called for existing item!
 287     wxCHECK_MSG( node, NULL, wxT("bug in wxMenu::Remove logic") );
 288
 289 #if wxUSE_ACCEL
 290     // remove the corresponding accel from the accel table
 291     int n = FindAccel(item->GetId());
 292     if ( n != wxNOT_FOUND )
 293     {
 294         delete m_accels[n];
 295
 296         m_accels.Remove(n);
 297     }
 298     //else: this item doesn't have an accel, nothing to do
 299 #endif // wxUSE_ACCEL
 300 /*
 301     // remove the item from the menu
 302     if ( !::RemoveMenu(GetHmenu(), (UINT)pos, MF_BYPOSITION) )
 303     {
 304         wxLogLastError("RemoveMenu");
 305     }
 306 */
 307     if ( IsAttached() )
 308     {
 309         // otherwise, the chane won't be visible
 310         m_menuBar->Refresh();
 311     }
 312
 313     // and from internal data structures
 314     return wxMenuBase::DoRemove(item);
 315 }
 316
 317 // ---------------------------------------------------------------------------
 318 // accelerator helpers
 319 // ---------------------------------------------------------------------------
 320
 321 #if wxUSE_ACCEL
 322
 323 // create the wxAcceleratorEntries for our accels and put them into provided
 324 // array - return the number of accels we have
 325 size_t wxMenu::CopyAccels(wxAcceleratorEntry *accels) const
 326 {
 327     size_t count = GetAccelCount();
 328     for ( size_t n = 0; n < count; n++ )
 329     {
 330         *accels++ = *m_accels[n];
 331     }
 332
 333     return count;
 334 }
 335
 336 #endif // wxUSE_ACCEL
 337
 338 // ---------------------------------------------------------------------------
 339 // set wxMenu title
 340 // ---------------------------------------------------------------------------
 341
 342 void wxMenu::SetTitle(const wxString& label)
 343 {
 344     bool hasNoTitle = m_title.IsEmpty();
 345     m_title = label;
 346
 347     HMENU hMenu = GetHmenu();
 348
 349     if ( hasNoTitle )
 350     {
 351         if ( !label.IsEmpty() )
 352         {
 353 /*
 354             if ( !::InsertMenu(hMenu, 0u, MF_BYPOSITION | MF_STRING,
 355                                (unsigned)idMenuTitle, m_title) ||
 356                  !::InsertMenu(hMenu, 1u, MF_BYPOSITION, (unsigned)-1, NULL) )
 357             {
 358                 wxLogLastError("InsertMenu");
 359             }
 360 */
 361         }
 362     }
 363     else
 364     {
 365         if ( label.IsEmpty() )
 366         {
 367 /*
 368             // remove the title and the separator after it
 369             if ( !RemoveMenu(hMenu, 0, MF_BYPOSITION) ||
 370                  !RemoveMenu(hMenu, 0, MF_BYPOSITION) )
 371             {
 372                 wxLogLastError("RemoveMenu");
 373             }
 374 */
 375         }
 376         else
 377         {
 378 /*
 379             // modify the title
 380             if ( !ModifyMenu(hMenu, 0u,
 381                              MF_BYPOSITION | MF_STRING,
 382                              (unsigned)idMenuTitle, m_title) )
 383             {
 384                 wxLogLastError("ModifyMenu");
 385             }
 386 */
 387         }
 388     }
 389 /*
 390 #ifdef __WIN32__
 391     // put the title string in bold face
 392     if ( !m_title.IsEmpty() )
 393     {
 394         MENUITEMINFO mii;
 395         mii.cbSize = sizeof(mii);
 396         mii.fMask = MIIM_STATE;
 397         mii.fState = MFS_DEFAULT;
 398
 399         if ( !SetMenuItemInfo(hMenu, (unsigned)idMenuTitle, FALSE, &mii) )
 400         {
 401             wxLogLastError("SetMenuItemInfo");
 402         }
 403     }
 404 #endif // Win32
 405 */
 406 }
 407
 408 // ---------------------------------------------------------------------------
 409 // event processing
 410 // ---------------------------------------------------------------------------
 411
 412 bool wxMenu::OS2Command(WXUINT WXUNUSED(param), WXWORD id)
 413 {
 414     // ignore commands from the menu title
 415
 416     // NB: VC++ generates wrong assembler for `if ( id != idMenuTitle )'!!
 417     if ( id != (WXWORD)idMenuTitle )
 418     {
 419         wxCommandEvent event(wxEVT_COMMAND_MENU_SELECTED);
 420         event.SetEventObject( this );
 421         event.SetId( id );
 422         event.SetInt( id );
 423         ProcessCommand(event);
 424     }
 425
 426     return TRUE;
 427 }
 428
 429 bool wxMenu::ProcessCommand(wxCommandEvent & event)
 430 {
 431     bool processed = FALSE;
 432
 433 #if WXWIN_COMPATIBILITY
 434     // Try a callback
 435     if (m_callback)
 436     {
 437         (void)(*(m_callback))(*this, event);
 438         processed = TRUE;
 439     }
 440 #endif // WXWIN_COMPATIBILITY
 441
 442     // Try the menu's event handler
 443     if ( !processed && GetEventHandler())
 444     {
 445         processed = GetEventHandler()->ProcessEvent(event);
 446     }
 447
 448     // Try the window the menu was popped up from (and up through the
 449     // hierarchy)
 450     wxWindow *win = GetInvokingWindow();
 451     if ( !processed && win )
 452         processed = win->GetEventHandler()->ProcessEvent(event);
 453
 454     return processed;
 455 }
 456
 457 // ---------------------------------------------------------------------------
 458 // other
 459 // ---------------------------------------------------------------------------
 460
 461 void wxMenu::Attach(wxMenuBar *menubar)
 462 {
 463     // menu can be in at most one menubar because otherwise they would both
 464     // delete the menu pointer
 465     wxASSERT_MSG( !m_menuBar, wxT("menu belongs to 2 menubars, expect a crash") );
 466
 467     m_menuBar = menubar;
 468 }
 469
 470 void wxMenu::Detach()
 471 {
 472     wxASSERT_MSG( m_menuBar, wxT("can't detach menu if it's not attached") );
 473
 474     m_menuBar = NULL;
 475 }
 476
 477 wxWindow *wxMenu::GetWindow() const
 478 {
 479     if ( m_invokingWindow != NULL )
 480         return m_invokingWindow;
 481     else if ( m_menuBar != NULL)
 482         return m_menuBar->GetFrame();
 483
 484     return NULL;
 485 }
 486
 487 // ---------------------------------------------------------------------------
 488 // Menu Bar
 489 // ---------------------------------------------------------------------------
 490
 491 void wxMenuBar::Init()
 492 {
 493     m_eventHandler = this;
 494     m_menuBarFrame = NULL;
 495     m_hMenu = 0;
 496 }
 497
 498 wxMenuBar::wxMenuBar()
 499 {
 500     Init();
 501 }
 502
 503 wxMenuBar::wxMenuBar( long WXUNUSED(style) )
 504 {
 505     Init();
 506 }
 507
 508 wxMenuBar::wxMenuBar(int count, wxMenu *menus[], const wxString titles[])
 509 {
 510     Init();
 511
 512     m_titles.Alloc(count);
 513
 514     for ( int i = 0; i < count; i++ )
 515     {
 516         m_menus.Append(menus[i]);
 517         m_titles.Add(titles[i]);
 518
 519         menus[i]->Attach(this);
 520     }
 521 }
 522
 523 wxMenuBar::~wxMenuBar()
 524 {
 525 }
 526
 527 // ---------------------------------------------------------------------------
 528 // wxMenuBar helpers
 529 // ---------------------------------------------------------------------------
 530
 531 void wxMenuBar::Refresh(
 532   bool                              WXUNUSED(bEraseBackground)
 533 , const wxRect*                     WXUNUSED(pRect)
 534 )
 535 {
 536     wxCHECK_RET( IsAttached(), wxT("can't refresh unatteched menubar") );
 537
 538 //    DrawMenuBar(GetHwndOf(m_menuBarFrame));
 539 }
 540
 541 WXHMENU wxMenuBar::Create()
 542 {
 543     if (m_hMenu != 0 )
 544         return m_hMenu;
 545
 546     wxCHECK_MSG( !m_hMenu, TRUE, wxT("menubar already created") );
 547
 548 // TODO:
 549 /*
 550
 551     m_hMenu = (WXHMENU)::CreateMenu();
 552
 553     if ( !m_hMenu )
 554     {
 555         wxLogLastError("CreateMenu");
 556     }
 557     else
 558     {
 559         size_t count = GetMenuCount();
 560         for ( size_t i = 0; i < count; i++ )
 561         {
 562             if ( !::AppendMenu((HMENU)m_hMenu, MF_POPUP | MF_STRING,
 563                                (UINT)m_menus[i]->GetHMenu(),
 564                                m_titles[i]) )
 565             {
 566                 wxLogLastError("AppendMenu");
 567             }
 568         }
 569     }
 570
 571     return m_hMenu;
 572 */
 573     return (WXHMENU)0;
 574 }
 575
 576 // ---------------------------------------------------------------------------
 577 // wxMenuBar functions to work with the top level submenus
 578 // ---------------------------------------------------------------------------
 579
 580 // NB: we don't support owner drawn top level items for now, if we do these
 581 //     functions would have to be changed to use wxMenuItem as well
 582
 583 void wxMenuBar::EnableTop(size_t pos, bool enable)
 584 {
 585     wxCHECK_RET( IsAttached(), wxT("doesn't work with unattached menubars") );
 586
 587 //    int flag = enable ? MF_ENABLED : MF_GRAYED;
 588
 589 //    EnableMenuItem((HMENU)m_hMenu, pos, MF_BYPOSITION | flag);
 590
 591     Refresh();
 592 }
 593
 594 void wxMenuBar::SetLabelTop(size_t pos, const wxString& label)
 595 {
 596     wxCHECK_RET( pos < GetMenuCount(), wxT("invalid menu index") );
 597
 598     m_titles[pos] = label;
 599
 600     if ( !IsAttached() )
 601     {
 602         return;
 603     }
 604     //else: have to modify the existing menu
 605
 606 // TODO:
 607 /*
 608     UINT id;
 609     UINT flagsOld = ::GetMenuState((HMENU)m_hMenu, pos, MF_BYPOSITION);
 610     if ( flagsOld == 0xFFFFFFFF )
 611     {
 612         wxLogLastError(wxT("GetMenuState"));
 613
 614         return;
 615     }
 616
 617     if ( flagsOld & MF_POPUP )
 618     {
 619         // HIBYTE contains the number of items in the submenu in this case
 620         flagsOld &= 0xff;
 621         id = (UINT)::GetSubMenu((HMENU)m_hMenu, pos);
 622     }
 623     else
 624     {
 625         id = pos;
 626     }
 627
 628     if ( ::ModifyMenu(GetHmenu(), pos, MF_BYPOSITION | MF_STRING | flagsOld,
 629                       id, label) == (int)0xFFFFFFFF )
 630     {
 631         wxLogLastError("ModifyMenu");
 632     }
 633 */
 634     Refresh();
 635 }
 636
 637 wxString wxMenuBar::GetLabelTop(size_t pos) const
 638 {
 639     wxCHECK_MSG( pos < GetMenuCount(), wxEmptyString,
 640                  wxT("invalid menu index in wxMenuBar::GetLabelTop") );
 641
 642     return m_titles[pos];
 643 }
 644
 645 int wxMenuBar::FindMenu(const wxString& title)
 646 {
 647     wxString menuTitle = wxStripMenuCodes(title);
 648
 649     size_t count = GetMenuCount();
 650     for ( size_t i = 0; i < count; i++ )
 651     {
 652         wxString title = wxStripMenuCodes(m_titles[i]);
 653         if ( menuTitle == title )
 654             return i;
 655     }
 656
 657     return wxNOT_FOUND;
 658
 659 }
 660
 661 // ---------------------------------------------------------------------------
 662 // wxMenuBar construction
 663 // ---------------------------------------------------------------------------
 664
 665 wxMenu *wxMenuBar::Replace(size_t pos, wxMenu *menu, const wxString& title)
 666 {
 667     wxMenu *menuOld = wxMenuBarBase::Replace(pos, menu, title);
 668     if ( !menuOld )
 669         return FALSE;
 670     m_titles[pos] = title;
 671 // TODO:
 672 /*
 673     if ( IsAttached() )
 674     {
 675         // can't use ModifyMenu() because it deletes the submenu it replaces
 676         if ( !::RemoveMenu(GetHmenu(), (UINT)pos, MF_BYPOSITION) )
 677         {
 678             wxLogLastError("RemoveMenu");
 679         }
 680
 681         if ( !::InsertMenu(GetHmenu(), (UINT)pos,
 682                            MF_BYPOSITION | MF_POPUP | MF_STRING,
 683                            (UINT)GetHmenuOf(menu), title) )
 684         {
 685             wxLogLastError("InsertMenu");
 686         }
 687
 688 #if wxUSE_ACCEL
 689         if ( menuOld->HasAccels() || menu->HasAccels() )
 690         {
 691             // need to rebuild accell table
 692             RebuildAccelTable();
 693         }
 694 #endif // wxUSE_ACCEL
 695
 696         Refresh();
 697     }
 698 */
 699     return menuOld;
 700 }
 701
 702 bool wxMenuBar::Insert(size_t pos, wxMenu *menu, const wxString& title)
 703 {
 704     if ( !wxMenuBarBase::Insert(pos, menu, title) )
 705         return FALSE;
 706
 707     m_titles.Insert(title, pos);
 708
 709     menu->Attach(this);
 710 // TODO:
 711 /*
 712     if ( IsAttached() )
 713     {
 714         if ( !::InsertMenu(GetHmenu(), pos,
 715                            MF_BYPOSITION | MF_POPUP | MF_STRING,
 716                            (UINT)GetHmenuOf(menu), title) )
 717         {
 718             wxLogLastError("InsertMenu");
 719         }
 720
 721 #if wxUSE_ACCEL
 722         if ( menu->HasAccels() )
 723         {
 724             // need to rebuild accell table
 725             RebuildAccelTable();
 726         }
 727 #endif // wxUSE_ACCEL
 728
 729         Refresh();
 730     }
 731 */
 732     return TRUE;
 733 }
 734
 735 bool wxMenuBar::Append(wxMenu *menu, const wxString& title)
 736 {
 737     WXHMENU submenu = menu ? menu->GetHMenu() : 0;
 738     wxCHECK_MSG( submenu, FALSE, wxT("can't append invalid menu to menubar") );
 739
 740     if ( !wxMenuBarBase::Append(menu, title) )
 741         return FALSE;
 742
 743     menu->Attach(this);
 744
 745     m_titles.Add(title);
 746 // TODO:
 747 /*
 748     if ( IsAttached() )
 749     {
 750         if ( !::AppendMenu(GetHmenu(), MF_POPUP | MF_STRING,
 751                            (UINT)submenu, title) )
 752         {
 753             wxLogLastError(wxT("AppendMenu"));
 754         }
 755
 756 #if wxUSE_ACCEL
 757         if ( menu->HasAccels() )
 758         {
 759             // need to rebuild accell table
 760             RebuildAccelTable();
 761         }
 762 #endif // wxUSE_ACCEL
 763
 764         Refresh();
 765     }
 766 */
 767     return TRUE;
 768 }
 769
 770 wxMenu *wxMenuBar::Remove(size_t pos)
 771 {
 772     wxMenu *menu = wxMenuBarBase::Remove(pos);
 773     if ( !menu )
 774         return NULL;
 775 // TODO:
 776 /*
 777     if ( IsAttached() )
 778     {
 779         if ( !::RemoveMenu(GetHmenu(), (UINT)pos, MF_BYPOSITION) )
 780         {
 781             wxLogLastError("RemoveMenu");
 782         }
 783
 784         menu->Detach();
 785
 786 #if wxUSE_ACCEL
 787         if ( menu->HasAccels() )
 788         {
 789             // need to rebuild accell table
 790             RebuildAccelTable();
 791         }
 792 #endif // wxUSE_ACCEL
 793
 794         Refresh();
 795     }
 796
 797     m_titles.Remove(pos);
 798 */
 799     return menu;
 800 }
 801
 802 #if wxUSE_ACCEL
 803
 804 void wxMenuBar::RebuildAccelTable()
 805 {
 806     // merge the accelerators of all menus into one accel table
 807     size_t nAccelCount = 0;
 808     size_t i, count = GetMenuCount();
 809     for ( i = 0; i < count; i++ )
 810     {
 811         nAccelCount += m_menus[i]->GetAccelCount();
 812     }
 813
 814     if ( nAccelCount )
 815     {
 816         wxAcceleratorEntry *accelEntries = new wxAcceleratorEntry[nAccelCount];
 817
 818         nAccelCount = 0;
 819         for ( i = 0; i < count; i++ )
 820         {
 821             nAccelCount += m_menus[i]->CopyAccels(&accelEntries[nAccelCount]);
 822         }
 823
 824         m_accelTable = wxAcceleratorTable(nAccelCount, accelEntries);
 825
 826         delete [] accelEntries;
 827     }
 828 }
 829
 830 #endif // wxUSE_ACCEL
 831
 832 void wxMenuBar::Attach(wxFrame *frame)
 833 {
 834     wxASSERT_MSG( !IsAttached(), wxT("menubar already attached!") );
 835
 836     m_menuBarFrame = frame;
 837
 838 #if wxUSE_ACCEL
 839     RebuildAccelTable();
 840 #endif // wxUSE_ACCEL
 841 }
 842
 843 void wxMenuBar::Detach()
 844 {
 845 //    ::DestroyMenu((HMENU)m_hMenu);
 846     m_hMenu = (WXHMENU)NULL;
 847     m_menuBarFrame = NULL;
 848 }
 849
 850
 851 // ---------------------------------------------------------------------------
 852 // wxMenuBar searching for menu items
 853 // ---------------------------------------------------------------------------
 854
 855 // Find the itemString in menuString, and return the item id or wxNOT_FOUND
 856 int wxMenuBar::FindMenuItem(const wxString& menuString,
 857                             const wxString& itemString) const
 858 {
 859     wxString menuLabel = wxStripMenuCodes(menuString);
 860     size_t count = GetMenuCount();
 861     for ( size_t i = 0; i < count; i++ )
 862     {
 863         wxString title = wxStripMenuCodes(m_titles[i]);
 864         if ( menuString == title )
 865             return m_menus[i]->FindItem(itemString);
 866     }
 867
 868     return wxNOT_FOUND;
 869 }
 870
 871 wxMenuItem *wxMenuBar::FindItem(int id, wxMenu **itemMenu) const
 872 {
 873     if ( itemMenu )
 874         *itemMenu = NULL;
 875
 876     wxMenuItem *item = NULL;
 877     size_t count = GetMenuCount();
 878     for ( size_t i = 0; !item && (i < count); i++ )
 879     {
 880         item = m_menus[i]->FindItem(id, itemMenu);
 881     }
 882
 883     return item;
 884 }
 885