src/msw/menu.cpp

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