src/msw/menu.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/msw/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 // For compilers that support precompilation, includes "wx.h".
  21 #include "wx/wxprec.h"
  22
  23 #ifdef __BORLANDC__
  24     #pragma hdrstop
  25 #endif
  26
  27 #if wxUSE_MENUS
  28
  29 #include "wx/menu.h"
  30
  31 #ifndef WX_PRECOMP
  32     #include "wx/frame.h"
  33     #include "wx/utils.h"
  34     #include "wx/intl.h"
  35     #include "wx/log.h"
  36 #endif
  37
  38 #if wxUSE_OWNER_DRAWN
  39     #include "wx/ownerdrw.h"
  40 #endif
  41
  42 #include "wx/msw/private.h"
  43
  44 // include <commctrl.h> "properly"
  45 #include "wx/msw/wrapcctl.h"
  46
  47 #ifdef __WXWINCE__
  48 #include <windows.h>
  49 #include <windowsx.h>
  50 #include <tchar.h>
  51 #include <ole2.h>
  52 #include <shellapi.h>
  53 #if (_WIN32_WCE < 400) && !defined(__HANDHELDPC__)
  54 #include <aygshell.h>
  55 #endif
  56
  57 #include "wx/msw/wince/missing.h"
  58
  59 #endif
  60
  61 // other standard headers
  62 #include <string.h>
  63
  64 #if wxUSE_OWNER_DRAWN && defined(MIIM_BITMAP)
  65     #include "wx/dynlib.h"
  66 #endif
  67
  68 #ifndef MNS_CHECKORBMP
  69     #define MNS_CHECKORBMP 0x04000000
  70 #endif
  71 #ifndef MIM_STYLE
  72     #define MIM_STYLE 0x00000010
  73 #endif
  74
  75 // ----------------------------------------------------------------------------
  76 // global variables
  77 // ----------------------------------------------------------------------------
  78
  79 // ----------------------------------------------------------------------------
  80 // constants
  81 // ----------------------------------------------------------------------------
  82
  83 // the (popup) menu title has this special id
  84 static const int idMenuTitle = -3;
  85
  86 // ----------------------------------------------------------------------------
  87 // private functions
  88 // ----------------------------------------------------------------------------
  89
  90 // make the given menu item default
  91 static void SetDefaultMenuItem(HMENU WXUNUSED_IN_WINCE(hmenu),
  92                                UINT WXUNUSED_IN_WINCE(id))
  93 {
  94 #ifndef __WXWINCE__
  95     MENUITEMINFO mii;
  96     wxZeroMemory(mii);
  97     mii.cbSize = sizeof(MENUITEMINFO);
  98     mii.fMask = MIIM_STATE;
  99     mii.fState = MFS_DEFAULT;
 100
 101     if ( !::SetMenuItemInfo(hmenu, id, FALSE, &mii) )
 102     {
 103         wxLogLastError(wxT("SetMenuItemInfo"));
 104     }
 105 #endif
 106 }
 107
 108 #ifdef __WXWINCE__
 109 UINT GetMenuState(HMENU hMenu, UINT id, UINT flags)
 110 {
 111     MENUITEMINFO info;
 112     wxZeroMemory(info);
 113     info.cbSize = sizeof(info);
 114     info.fMask = MIIM_STATE;
 115     // MF_BYCOMMAND is zero so test MF_BYPOSITION
 116     if ( !::GetMenuItemInfo(hMenu, id, flags & MF_BYPOSITION ? TRUE : FALSE , & info) )
 117         wxLogLastError(wxT("GetMenuItemInfo"));
 118     return info.fState;
 119 }
 120 #endif
 121
 122 // ============================================================================
 123 // implementation
 124 // ============================================================================
 125
 126 #include "wx/listimpl.cpp"
 127
 128 WX_DEFINE_LIST( wxMenuInfoList )
 129
 130 #if wxUSE_EXTENDED_RTTI
 131
 132 WX_DEFINE_FLAGS( wxMenuStyle )
 133
 134 wxBEGIN_FLAGS( wxMenuStyle )
 135     wxFLAGS_MEMBER(wxMENU_TEAROFF)
 136 wxEND_FLAGS( wxMenuStyle )
 137
 138 IMPLEMENT_DYNAMIC_CLASS_XTI(wxMenu, wxEvtHandler,"wx/menu.h")
 139
 140 wxCOLLECTION_TYPE_INFO( wxMenuItem * , wxMenuItemList ) ;
 141
 142 template<> void wxCollectionToVariantArray( wxMenuItemList const &theList, wxxVariantArray &value)
 143 {
 144     wxListCollectionToVariantArray<wxMenuItemList::compatibility_iterator>( theList , value ) ;
 145 }
 146
 147 wxBEGIN_PROPERTIES_TABLE(wxMenu)
 148     wxEVENT_PROPERTY( Select , wxEVT_COMMAND_MENU_SELECTED , wxCommandEvent)
 149     wxPROPERTY( Title, wxString , SetTitle, GetTitle, wxString(), 0 /*flags*/ , wxT("Helpstring") , wxT("group") )
 150     wxREADONLY_PROPERTY_FLAGS( MenuStyle , wxMenuStyle , long , GetStyle , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
 151     wxPROPERTY_COLLECTION( MenuItems , wxMenuItemList , wxMenuItem* , Append , GetMenuItems , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
 152 wxEND_PROPERTIES_TABLE()
 153
 154 wxBEGIN_HANDLERS_TABLE(wxMenu)
 155 wxEND_HANDLERS_TABLE()
 156
 157 wxDIRECT_CONSTRUCTOR_2( wxMenu , wxString , Title , long , MenuStyle  )
 158
 159 WX_DEFINE_FLAGS( wxMenuBarStyle )
 160
 161 wxBEGIN_FLAGS( wxMenuBarStyle )
 162     wxFLAGS_MEMBER(wxMB_DOCKABLE)
 163 wxEND_FLAGS( wxMenuBarStyle )
 164
 165 // the negative id would lead the window (its superclass !) to vetoe streaming out otherwise
 166 bool wxMenuBarStreamingCallback( const wxObject *WXUNUSED(object), wxWriter * , wxPersister * , wxxVariantArray & )
 167 {
 168     return true ;
 169 }
 170
 171 IMPLEMENT_DYNAMIC_CLASS_XTI_CALLBACK(wxMenuBar, wxWindow ,"wx/menu.h",wxMenuBarStreamingCallback)
 172
 173 IMPLEMENT_DYNAMIC_CLASS_XTI(wxMenuInfo, wxObject , "wx/menu.h" )
 174
 175 wxBEGIN_PROPERTIES_TABLE(wxMenuInfo)
 176     wxREADONLY_PROPERTY( Menu , wxMenu* , GetMenu , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
 177     wxREADONLY_PROPERTY( Title , wxString , GetTitle , wxString() , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
 178 wxEND_PROPERTIES_TABLE()
 179
 180 wxBEGIN_HANDLERS_TABLE(wxMenuInfo)
 181 wxEND_HANDLERS_TABLE()
 182
 183 wxCONSTRUCTOR_2( wxMenuInfo , wxMenu* , Menu , wxString , Title )
 184
 185 wxCOLLECTION_TYPE_INFO( wxMenuInfo * , wxMenuInfoList ) ;
 186
 187 template<> void wxCollectionToVariantArray( wxMenuInfoList const &theList, wxxVariantArray &value)
 188 {
 189     wxListCollectionToVariantArray<wxMenuInfoList::compatibility_iterator>( theList , value ) ;
 190 }
 191
 192 wxBEGIN_PROPERTIES_TABLE(wxMenuBar)
 193     wxPROPERTY_COLLECTION( MenuInfos , wxMenuInfoList , wxMenuInfo* , Append , GetMenuInfos , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
 194 wxEND_PROPERTIES_TABLE()
 195
 196 wxBEGIN_HANDLERS_TABLE(wxMenuBar)
 197 wxEND_HANDLERS_TABLE()
 198
 199 wxCONSTRUCTOR_DUMMY( wxMenuBar )
 200
 201 #else
 202 IMPLEMENT_DYNAMIC_CLASS(wxMenu, wxEvtHandler)
 203 IMPLEMENT_DYNAMIC_CLASS(wxMenuBar, wxWindow)
 204 IMPLEMENT_DYNAMIC_CLASS(wxMenuInfo, wxObject)
 205 #endif
 206
 207 const wxMenuInfoList& wxMenuBar::GetMenuInfos() const
 208 {
 209     wxMenuInfoList* list = const_cast< wxMenuInfoList* >( &m_menuInfos ) ;
 210     WX_CLEAR_LIST( wxMenuInfoList , *list ) ;
 211     for( size_t i = 0 ; i < GetMenuCount() ; ++i )
 212     {
 213         wxMenuInfo* info = new wxMenuInfo() ;
 214         info->Create( const_cast<wxMenuBar*>(this)->GetMenu(i) , GetLabelTop(i) ) ;
 215         list->Append( info ) ;
 216     }
 217     return m_menuInfos ;
 218 }
 219
 220 // ---------------------------------------------------------------------------
 221 // wxMenu construction, adding and removing menu items
 222 // ---------------------------------------------------------------------------
 223
 224 // Construct a menu with optional title (then use append)
 225 void wxMenu::Init()
 226 {
 227     m_doBreak = false;
 228     m_startRadioGroup = -1;
 229
 230     // create the menu
 231     m_hMenu = (WXHMENU)CreatePopupMenu();
 232     if ( !m_hMenu )
 233     {
 234         wxLogLastError(wxT("CreatePopupMenu"));
 235     }
 236
 237     // if we have a title, insert it in the beginning of the menu
 238     if ( !m_title.empty() )
 239     {
 240         Append(idMenuTitle, m_title);
 241         AppendSeparator();
 242     }
 243 }
 244
 245 // The wxWindow destructor will take care of deleting the submenus.
 246 wxMenu::~wxMenu()
 247 {
 248     // we should free Windows resources only if Windows doesn't do it for us
 249     // which happens if we're attached to a menubar or a submenu of another
 250     // menu
 251     if ( !IsAttached() && !GetParent() )
 252     {
 253         if ( !::DestroyMenu(GetHmenu()) )
 254         {
 255             wxLogLastError(wxT("DestroyMenu"));
 256         }
 257     }
 258
 259 #if wxUSE_ACCEL
 260     // delete accels
 261     WX_CLEAR_ARRAY(m_accels);
 262 #endif // wxUSE_ACCEL
 263 }
 264
 265 void wxMenu::Break()
 266 {
 267     // this will take effect during the next call to Append()
 268     m_doBreak = true;
 269 }
 270
 271 void wxMenu::Attach(wxMenuBarBase *menubar)
 272 {
 273     wxMenuBase::Attach(menubar);
 274
 275     EndRadioGroup();
 276 }
 277
 278 #if wxUSE_ACCEL
 279
 280 int wxMenu::FindAccel(int id) const
 281 {
 282     size_t n, count = m_accels.GetCount();
 283     for ( n = 0; n < count; n++ )
 284     {
 285         if ( m_accels[n]->m_command == id )
 286             return n;
 287     }
 288
 289     return wxNOT_FOUND;
 290 }
 291
 292 void wxMenu::UpdateAccel(wxMenuItem *item)
 293 {
 294     if ( item->IsSubMenu() )
 295     {
 296         wxMenu *submenu = item->GetSubMenu();
 297         wxMenuItemList::compatibility_iterator node = submenu->GetMenuItems().GetFirst();
 298         while ( node )
 299         {
 300             UpdateAccel(node->GetData());
 301
 302             node = node->GetNext();
 303         }
 304     }
 305     else if ( !item->IsSeparator() )
 306     {
 307         // recurse upwards: we should only modify m_accels of the top level
 308         // menus, not of the submenus as wxMenuBar doesn't look at them
 309         // (alternative and arguable cleaner solution would be to recurse
 310         // downwards in GetAccelCount() and CopyAccels())
 311         if ( GetParent() )
 312         {
 313             GetParent()->UpdateAccel(item);
 314             return;
 315         }
 316
 317         // find the (new) accel for this item
 318         wxAcceleratorEntry *accel = wxAcceleratorEntry::Create(item->GetText());
 319         if ( accel )
 320             accel->m_command = item->GetId();
 321
 322         // find the old one
 323         int n = FindAccel(item->GetId());
 324         if ( n == wxNOT_FOUND )
 325         {
 326             // no old, add new if any
 327             if ( accel )
 328                 m_accels.Add(accel);
 329             else
 330                 return;     // skipping RebuildAccelTable() below
 331         }
 332         else
 333         {
 334             // replace old with new or just remove the old one if no new
 335             delete m_accels[n];
 336             if ( accel )
 337                 m_accels[n] = accel;
 338             else
 339                 m_accels.RemoveAt(n);
 340         }
 341
 342         if ( IsAttached() )
 343         {
 344             GetMenuBar()->RebuildAccelTable();
 345         }
 346     }
 347     //else: it is a separator, they can't have accels, nothing to do
 348 }
 349
 350 #endif // wxUSE_ACCEL
 351
 352 // append a new item or submenu to the menu
 353 bool wxMenu::DoInsertOrAppend(wxMenuItem *pItem, size_t pos)
 354 {
 355 #if wxUSE_ACCEL
 356     UpdateAccel(pItem);
 357 #endif // wxUSE_ACCEL
 358
 359     UINT flags = 0;
 360
 361     // if "Break" has just been called, insert a menu break before this item
 362     // (and don't forget to reset the flag)
 363     if ( m_doBreak ) {
 364         flags |= MF_MENUBREAK;
 365         m_doBreak = false;
 366     }
 367
 368     if ( pItem->IsSeparator() ) {
 369         flags |= MF_SEPARATOR;
 370     }
 371
 372     // id is the numeric id for normal menu items and HMENU for submenus as
 373     // required by ::AppendMenu() API
 374     UINT id;
 375     wxMenu *submenu = pItem->GetSubMenu();
 376     if ( submenu != NULL ) {
 377         wxASSERT_MSG( submenu->GetHMenu(), wxT("invalid submenu") );
 378
 379         submenu->SetParent(this);
 380
 381         id = (UINT)submenu->GetHMenu();
 382
 383         flags |= MF_POPUP;
 384     }
 385     else {
 386         id = pItem->GetId();
 387     }
 388
 389
 390     // prepare to insert the item in the menu
 391     wxString itemText = pItem->GetText();
 392     LPCTSTR pData = NULL;
 393     if ( pos == (size_t)-1 )
 394     {
 395         // append at the end (note that the item is already appended to
 396         // internal data structures)
 397         pos = GetMenuItemCount() - 1;
 398     }
 399
 400     // adjust position to account for the title, if any
 401     if ( !m_title.empty() )
 402         pos += 2; // for the title itself and its separator
 403
 404     BOOL ok = false;
 405
 406     // check if we have something more than a simple text item
 407 #if wxUSE_OWNER_DRAWN
 408     if ( pItem->IsOwnerDrawn() )
 409     {
 410         // is the item owner-drawn just because of the bitmap?
 411         if ( pItem->GetBitmap().Ok() &&
 412                 !pItem->GetTextColour().Ok() &&
 413                     !pItem->GetBackgroundColour().Ok() &&
 414                         !pItem->GetFont().Ok() &&
 415                             !pItem->GetBitmap(true).Ok() )
 416         {
 417             // try to use InsertMenuItem() as it's guaranteed to look correct
 418             // while our owner-drawn code is not
 419
 420             // first compile-time check
 421 #ifdef MIIM_BITMAP
 422             WinStruct<MENUITEMINFO> mii;
 423
 424             // now run-time one: MIIM_BITMAP only works under WinME/2000+
 425             if ( wxGetWinVersion() >= wxWinVersion_98 )
 426             {
 427                 mii.fMask = MIIM_STRING | MIIM_DATA | MIIM_BITMAP;
 428                 mii.cch = itemText.length();
 429                 mii.dwTypeData = wx_const_cast(wxChar *, itemText.c_str());
 430
 431                 if (flags & MF_POPUP)
 432                 {
 433                     mii.fMask |= MIIM_SUBMENU;
 434                     mii.hSubMenu = (HMENU)pItem->GetSubMenu()->GetHMenu();
 435                 }
 436                 else
 437                 {
 438                     mii.fMask |= MIIM_ID;
 439                     mii.wID = id;
 440                 }
 441
 442                 // we can't pass HBITMAP directly as hbmpItem for 2 reasons:
 443                 //  1. we can't draw it with transparency then (this is not
 444                 //     very important now but would be with themed menu bg)
 445                 //  2. worse, Windows inverts the bitmap for the selected
 446                 //     item and this looks downright ugly
 447                 //
 448                 // so instead draw it ourselves in MSWOnDrawItem()
 449                 mii.dwItemData = wx_reinterpret_cast(ULONG_PTR, pItem);
 450                 mii.hbmpItem = HBMMENU_CALLBACK;
 451
 452                 ok = ::InsertMenuItem(GetHmenu(), pos, TRUE /* by pos */, &mii);
 453                 if ( !ok )
 454                 {
 455                     wxLogLastError(wxT("InsertMenuItem()"));
 456                 }
 457                 else // InsertMenuItem() ok
 458                 {
 459                     // we need to remove the extra indent which is reserved for
 460                     // the checkboxes by default as it looks ugly unless check
 461                     // boxes are used together with bitmaps and this is not the
 462                     // case in wx API
 463                     WinStruct<MENUINFO> mi;
 464
 465                     // don't call SetMenuInfo() directly, this would prevent
 466                     // the app from starting up under Windows 95/NT 4
 467                     typedef BOOL (WINAPI *SetMenuInfo_t)(HMENU, MENUINFO *);
 468
 469                     wxDynamicLibrary dllUser(_T("user32"));
 470                     wxDYNLIB_FUNCTION(SetMenuInfo_t, SetMenuInfo, dllUser);
 471                     if ( pfnSetMenuInfo )
 472                     {
 473                         mi.fMask = MIM_STYLE;
 474                         mi.dwStyle = MNS_CHECKORBMP;
 475                         if ( !(*pfnSetMenuInfo)(GetHmenu(), &mi) )
 476                             wxLogLastError(_T("SetMenuInfo(MNS_NOCHECK)"));
 477                     }
 478
 479                     // tell the item that it's not really owner-drawn but only
 480                     // needs to draw its bitmap, the rest is done by Windows
 481                     pItem->ResetOwnerDrawn();
 482                 }
 483             }
 484 #endif // MIIM_BITMAP
 485         }
 486
 487         if ( !ok )
 488         {
 489             // item draws itself, pass pointer to it in data parameter
 490             flags |= MF_OWNERDRAW;
 491             pData = (LPCTSTR)pItem;
 492         }
 493     }
 494     else
 495 #endif // wxUSE_OWNER_DRAWN
 496     {
 497         // item is just a normal string (passed in data parameter)
 498         flags |= MF_STRING;
 499
 500 #ifdef __WXWINCE__
 501         itemText = wxMenuItem::GetLabelFromText(itemText);
 502 #endif
 503
 504         pData = (wxChar*)itemText.c_str();
 505     }
 506
 507     // item might have already been inserted by InsertMenuItem() above
 508     if ( !ok )
 509     {
 510         if ( !::InsertMenu(GetHmenu(), pos, flags | MF_BYPOSITION, id, pData) )
 511         {
 512             wxLogLastError(wxT("InsertMenu[Item]()"));
 513
 514             return false;
 515         }
 516     }
 517
 518
 519     // if we just appended the title, highlight it
 520     if ( (int)id == idMenuTitle )
 521     {
 522         // visually select the menu title
 523         SetDefaultMenuItem(GetHmenu(), id);
 524     }
 525
 526     // if we're already attached to the menubar, we must update it
 527     if ( IsAttached() && GetMenuBar()->IsAttached() )
 528     {
 529         GetMenuBar()->Refresh();
 530     }
 531
 532     return true;
 533 }
 534
 535 void wxMenu::EndRadioGroup()
 536 {
 537     // we're not inside a radio group any longer
 538     m_startRadioGroup = -1;
 539 }
 540
 541 wxMenuItem* wxMenu::DoAppend(wxMenuItem *item)
 542 {
 543     wxCHECK_MSG( item, NULL, _T("NULL item in wxMenu::DoAppend") );
 544
 545     bool check = false;
 546
 547     if ( item->GetKind() == wxITEM_RADIO )
 548     {
 549         int count = GetMenuItemCount();
 550
 551         if ( m_startRadioGroup == -1 )
 552         {
 553             // start a new radio group
 554             m_startRadioGroup = count;
 555
 556             // for now it has just one element
 557             item->SetAsRadioGroupStart();
 558             item->SetRadioGroupEnd(m_startRadioGroup);
 559
 560             // ensure that we have a checked item in the radio group
 561             check = true;
 562         }
 563         else // extend the current radio group
 564         {
 565             // we need to update its end item
 566             item->SetRadioGroupStart(m_startRadioGroup);
 567             wxMenuItemList::compatibility_iterator node = GetMenuItems().Item(m_startRadioGroup);
 568
 569             if ( node )
 570             {
 571                 node->GetData()->SetRadioGroupEnd(count);
 572             }
 573             else
 574             {
 575                 wxFAIL_MSG( _T("where is the radio group start item?") );
 576             }
 577         }
 578     }
 579     else // not a radio item
 580     {
 581         EndRadioGroup();
 582     }
 583
 584     if ( !wxMenuBase::DoAppend(item) || !DoInsertOrAppend(item) )
 585     {
 586         return NULL;
 587     }
 588
 589     if ( check )
 590     {
 591         // check the item initially
 592         item->Check(true);
 593     }
 594
 595     return item;
 596 }
 597
 598 wxMenuItem* wxMenu::DoInsert(size_t pos, wxMenuItem *item)
 599 {
 600     if (wxMenuBase::DoInsert(pos, item) && DoInsertOrAppend(item, pos))
 601         return item;
 602     else
 603         return NULL;
 604 }
 605
 606 wxMenuItem *wxMenu::DoRemove(wxMenuItem *item)
 607 {
 608     // we need to find the item's position in the child list
 609     size_t pos;
 610     wxMenuItemList::compatibility_iterator node = GetMenuItems().GetFirst();
 611     for ( pos = 0; node; pos++ )
 612     {
 613         if ( node->GetData() == item )
 614             break;
 615
 616         node = node->GetNext();
 617     }
 618
 619     // DoRemove() (unlike Remove) can only be called for an existing item!
 620     wxCHECK_MSG( node, NULL, wxT("bug in wxMenu::Remove logic") );
 621
 622 #if wxUSE_ACCEL
 623     // remove the corresponding accel from the accel table
 624     int n = FindAccel(item->GetId());
 625     if ( n != wxNOT_FOUND )
 626     {
 627         delete m_accels[n];
 628
 629         m_accels.RemoveAt(n);
 630     }
 631     //else: this item doesn't have an accel, nothing to do
 632 #endif // wxUSE_ACCEL
 633
 634     // remove the item from the menu
 635     if ( !::RemoveMenu(GetHmenu(), (UINT)pos, MF_BYPOSITION) )
 636     {
 637         wxLogLastError(wxT("RemoveMenu"));
 638     }
 639
 640     if ( IsAttached() && GetMenuBar()->IsAttached() )
 641     {
 642         // otherwise, the change won't be visible
 643         GetMenuBar()->Refresh();
 644     }
 645
 646     // and from internal data structures
 647     return wxMenuBase::DoRemove(item);
 648 }
 649
 650 // ---------------------------------------------------------------------------
 651 // accelerator helpers
 652 // ---------------------------------------------------------------------------
 653
 654 #if wxUSE_ACCEL
 655
 656 // create the wxAcceleratorEntries for our accels and put them into the provided
 657 // array - return the number of accels we have
 658 size_t wxMenu::CopyAccels(wxAcceleratorEntry *accels) const
 659 {
 660     size_t count = GetAccelCount();
 661     for ( size_t n = 0; n < count; n++ )
 662     {
 663         *accels++ = *m_accels[n];
 664     }
 665
 666     return count;
 667 }
 668
 669 #endif // wxUSE_ACCEL
 670
 671 // ---------------------------------------------------------------------------
 672 // set wxMenu title
 673 // ---------------------------------------------------------------------------
 674
 675 void wxMenu::SetTitle(const wxString& label)
 676 {
 677     bool hasNoTitle = m_title.empty();
 678     m_title = label;
 679
 680     HMENU hMenu = GetHmenu();
 681
 682     if ( hasNoTitle )
 683     {
 684         if ( !label.empty() )
 685         {
 686             if ( !::InsertMenu(hMenu, 0u, MF_BYPOSITION | MF_STRING,
 687                                (unsigned)idMenuTitle, m_title) ||
 688                  !::InsertMenu(hMenu, 1u, MF_BYPOSITION, (unsigned)-1, NULL) )
 689             {
 690                 wxLogLastError(wxT("InsertMenu"));
 691             }
 692         }
 693     }
 694     else
 695     {
 696         if ( label.empty() )
 697         {
 698             // remove the title and the separator after it
 699             if ( !RemoveMenu(hMenu, 0, MF_BYPOSITION) ||
 700                  !RemoveMenu(hMenu, 0, MF_BYPOSITION) )
 701             {
 702                 wxLogLastError(wxT("RemoveMenu"));
 703             }
 704         }
 705         else
 706         {
 707             // modify the title
 708 #ifdef __WXWINCE__
 709             MENUITEMINFO info;
 710             wxZeroMemory(info);
 711             info.cbSize = sizeof(info);
 712             info.fMask = MIIM_TYPE;
 713             info.fType = MFT_STRING;
 714             info.cch = m_title.length();
 715             info.dwTypeData = (LPTSTR) m_title.c_str();
 716             if ( !SetMenuItemInfo(hMenu, 0, TRUE, & info) )
 717             {
 718                 wxLogLastError(wxT("SetMenuItemInfo"));
 719             }
 720 #else
 721             if ( !ModifyMenu(hMenu, 0u,
 722                              MF_BYPOSITION | MF_STRING,
 723                              (unsigned)idMenuTitle, m_title) )
 724             {
 725                 wxLogLastError(wxT("ModifyMenu"));
 726             }
 727 #endif
 728         }
 729     }
 730
 731 #ifdef __WIN32__
 732     // put the title string in bold face
 733     if ( !m_title.empty() )
 734     {
 735         SetDefaultMenuItem(GetHmenu(), (UINT)idMenuTitle);
 736     }
 737 #endif // Win32
 738 }
 739
 740 // ---------------------------------------------------------------------------
 741 // event processing
 742 // ---------------------------------------------------------------------------
 743
 744 bool wxMenu::MSWCommand(WXUINT WXUNUSED(param), WXWORD id)
 745 {
 746     // ignore commands from the menu title
 747     if ( id != (WXWORD)idMenuTitle )
 748     {
 749         // get the checked status of the command: notice that menuState is the
 750         // old state of the menu, so the test for MF_CHECKED must be inverted
 751         UINT menuState = ::GetMenuState(GetHmenu(), id, MF_BYCOMMAND);
 752         SendEvent(id, !(menuState & MF_CHECKED));
 753     }
 754
 755     return true;
 756 }
 757
 758 // ---------------------------------------------------------------------------
 759 // other
 760 // ---------------------------------------------------------------------------
 761
 762 wxWindow *wxMenu::GetWindow() const
 763 {
 764     if ( m_invokingWindow != NULL )
 765         return m_invokingWindow;
 766     else if ( GetMenuBar() != NULL)
 767         return GetMenuBar()->GetFrame();
 768
 769     return NULL;
 770 }
 771
 772 // ---------------------------------------------------------------------------
 773 // Menu Bar
 774 // ---------------------------------------------------------------------------
 775
 776 void wxMenuBar::Init()
 777 {
 778     m_eventHandler = this;
 779     m_hMenu = 0;
 780 #if wxUSE_TOOLBAR && defined(__WXWINCE__)
 781     m_toolBar = NULL;
 782 #endif
 783     // Not using a combined wxToolBar/wxMenuBar? then use
 784     // a commandbar in WinCE .NET just to implement the
 785     // menubar.
 786 #if defined(WINCE_WITH_COMMANDBAR)
 787     m_commandBar = NULL;
 788     m_adornmentsAdded = false;
 789 #endif
 790 }
 791
 792 wxMenuBar::wxMenuBar()
 793 {
 794     Init();
 795 }
 796
 797 wxMenuBar::wxMenuBar( long WXUNUSED(style) )
 798 {
 799     Init();
 800 }
 801
 802 wxMenuBar::wxMenuBar(size_t count, wxMenu *menus[], const wxString titles[], long WXUNUSED(style))
 803 {
 804     Init();
 805
 806     m_titles.Alloc(count);
 807
 808     for ( size_t i = 0; i < count; i++ )
 809     {
 810         m_menus.Append(menus[i]);
 811         m_titles.Add(titles[i]);
 812
 813         menus[i]->Attach(this);
 814     }
 815 }
 816
 817 wxMenuBar::~wxMenuBar()
 818 {
 819     // In Windows CE (not .NET), the menubar is always associated
 820     // with a toolbar, which destroys the menu implicitly.
 821 #if defined(WINCE_WITHOUT_COMMANDBAR) && defined(__POCKETPC__)
 822     if (GetToolBar())
 823     {
 824         wxToolMenuBar* toolMenuBar = wxDynamicCast(GetToolBar(), wxToolMenuBar);
 825         if (toolMenuBar)
 826             toolMenuBar->SetMenuBar(NULL);
 827     }
 828 #else
 829     // we should free Windows resources only if Windows doesn't do it for us
 830     // which happens if we're attached to a frame
 831     if (m_hMenu && !IsAttached())
 832     {
 833 #if defined(WINCE_WITH_COMMANDBAR)
 834         ::DestroyWindow((HWND) m_commandBar);
 835         m_commandBar = (WXHWND) NULL;
 836 #else
 837         ::DestroyMenu((HMENU)m_hMenu);
 838 #endif
 839         m_hMenu = (WXHMENU)NULL;
 840     }
 841 #endif
 842 }
 843
 844 // ---------------------------------------------------------------------------
 845 // wxMenuBar helpers
 846 // ---------------------------------------------------------------------------
 847
 848 void wxMenuBar::Refresh()
 849 {
 850     if ( IsFrozen() )
 851         return;
 852
 853     wxCHECK_RET( IsAttached(), wxT("can't refresh unattached menubar") );
 854
 855 #if defined(WINCE_WITHOUT_COMMANDBAR)
 856     if (GetToolBar())
 857     {
 858         CommandBar_DrawMenuBar((HWND) GetToolBar()->GetHWND(), 0);
 859     }
 860 #elif defined(WINCE_WITH_COMMANDBAR)
 861     if (m_commandBar)
 862         DrawMenuBar((HWND) m_commandBar);
 863 #else
 864     DrawMenuBar(GetHwndOf(GetFrame()));
 865 #endif
 866 }
 867
 868 WXHMENU wxMenuBar::Create()
 869 {
 870     // Note: this doesn't work at all on Smartphone,
 871     // since you have to use resources.
 872     // We'll have to find another way to add a menu
 873     // by changing/adding menu items to an existing menu.
 874 #if defined(WINCE_WITHOUT_COMMANDBAR)
 875     if ( m_hMenu != 0 )
 876         return m_hMenu;
 877
 878     if (!GetToolBar())
 879         return 0;
 880
 881     HWND hCommandBar = (HWND) GetToolBar()->GetHWND();
 882     HMENU hMenu = (HMENU)::SendMessage(hCommandBar, SHCMBM_GETMENU, (WPARAM)0, (LPARAM)0);
 883
 884     // hMenu may be zero on Windows Mobile 5. So add the menus anyway.
 885     if (1) // (hMenu)
 886     {
 887         TBBUTTON tbButton;
 888         memset(&tbButton, 0, sizeof(TBBUTTON));
 889         tbButton.iBitmap = I_IMAGENONE;
 890         tbButton.fsState = TBSTATE_ENABLED;
 891         tbButton.fsStyle = TBSTYLE_DROPDOWN | TBSTYLE_NO_DROPDOWN_ARROW | TBSTYLE_AUTOSIZE;
 892
 893         size_t i;
 894         for (i = 0; i < GetMenuCount(); i++)
 895         {
 896             HMENU hPopupMenu = (HMENU) GetMenu(i)->GetHMenu() ;
 897             tbButton.dwData = (DWORD)hPopupMenu;
 898             wxString label = wxStripMenuCodes(GetLabelTop(i));
 899             tbButton.iString = (int) label.c_str();
 900
 901             int position = i;
 902
 903             tbButton.idCommand = NewControlId();
 904             if (!::SendMessage(hCommandBar, TB_INSERTBUTTON, position, (LPARAM)&tbButton))
 905             {
 906                 wxLogLastError(wxT("TB_INSERTBUTTON"));
 907             }
 908         }
 909     }
 910     m_hMenu = (WXHMENU) hMenu;
 911     return m_hMenu;
 912 #else
 913     if ( m_hMenu != 0 )
 914         return m_hMenu;
 915
 916     m_hMenu = (WXHMENU)::CreateMenu();
 917
 918     if ( !m_hMenu )
 919     {
 920         wxLogLastError(wxT("CreateMenu"));
 921     }
 922     else
 923     {
 924         size_t count = GetMenuCount(), i;
 925         wxMenuList::iterator it;
 926         for ( i = 0, it = m_menus.begin(); i < count; i++, it++ )
 927         {
 928             if ( !::AppendMenu((HMENU)m_hMenu, MF_POPUP | MF_STRING,
 929                                (UINT)(*it)->GetHMenu(),
 930                                m_titles[i]) )
 931             {
 932                 wxLogLastError(wxT("AppendMenu"));
 933             }
 934         }
 935     }
 936
 937     return m_hMenu;
 938 #endif
 939 }
 940
 941 int wxMenuBar::MSWPositionForWxMenu(wxMenu *menu, int wxpos)
 942 {
 943     wxASSERT(menu);
 944     wxASSERT(menu->GetHMenu());
 945     wxASSERT(m_hMenu);
 946
 947 #if defined(__WXWINCE__)
 948     int totalMSWItems = GetMenuCount();
 949 #else
 950     int totalMSWItems = GetMenuItemCount((HMENU)m_hMenu);
 951 #endif
 952
 953     int i; // For old C++ compatibility
 954     for(i=wxpos; i<totalMSWItems; i++)
 955     {
 956         if(GetSubMenu((HMENU)m_hMenu,i)==(HMENU)menu->GetHMenu())
 957             return i;
 958     }
 959     for(i=0; i<wxpos; i++)
 960     {
 961         if(GetSubMenu((HMENU)m_hMenu,i)==(HMENU)menu->GetHMenu())
 962             return i;
 963     }
 964     wxFAIL;
 965     return -1;
 966 }
 967
 968 // ---------------------------------------------------------------------------
 969 // wxMenuBar functions to work with the top level submenus
 970 // ---------------------------------------------------------------------------
 971
 972 // NB: we don't support owner drawn top level items for now, if we do these
 973 //     functions would have to be changed to use wxMenuItem as well
 974
 975 void wxMenuBar::EnableTop(size_t pos, bool enable)
 976 {
 977     wxCHECK_RET( IsAttached(), wxT("doesn't work with unattached menubars") );
 978     wxCHECK_RET( pos < GetMenuCount(), wxT("invalid menu index") );
 979
 980     int flag = enable ? MF_ENABLED : MF_GRAYED;
 981
 982     EnableMenuItem((HMENU)m_hMenu, MSWPositionForWxMenu(GetMenu(pos),pos), MF_BYPOSITION | flag);
 983
 984     Refresh();
 985 }
 986
 987 void wxMenuBar::SetLabelTop(size_t pos, const wxString& label)
 988 {
 989     wxCHECK_RET( pos < GetMenuCount(), wxT("invalid menu index") );
 990
 991     m_titles[pos] = label;
 992
 993     if ( !IsAttached() )
 994     {
 995         return;
 996     }
 997     //else: have to modify the existing menu
 998
 999     int mswpos = MSWPositionForWxMenu(GetMenu(pos),pos);
1000
1001     UINT id;
1002     UINT flagsOld = ::GetMenuState((HMENU)m_hMenu, mswpos, MF_BYPOSITION);
1003     if ( flagsOld == 0xFFFFFFFF )
1004     {
1005         wxLogLastError(wxT("GetMenuState"));
1006
1007         return;
1008     }
1009
1010     if ( flagsOld & MF_POPUP )
1011     {
1012         // HIBYTE contains the number of items in the submenu in this case
1013         flagsOld &= 0xff;
1014         id = (UINT)::GetSubMenu((HMENU)m_hMenu, mswpos);
1015     }
1016     else
1017     {
1018         id = pos;
1019     }
1020
1021 #ifdef __WXWINCE__
1022     MENUITEMINFO info;
1023     wxZeroMemory(info);
1024     info.cbSize = sizeof(info);
1025     info.fMask = MIIM_TYPE;
1026     info.fType = MFT_STRING;
1027     info.cch = label.length();
1028     info.dwTypeData = (LPTSTR) label.c_str();
1029     if ( !SetMenuItemInfo(GetHmenu(), id, TRUE, & info) )
1030     {
1031         wxLogLastError(wxT("SetMenuItemInfo"));
1032     }
1033
1034 #else
1035     if ( ::ModifyMenu(GetHmenu(), mswpos, MF_BYPOSITION | MF_STRING | flagsOld,
1036         id, label) == (int)0xFFFFFFFF )
1037     {
1038         wxLogLastError(wxT("ModifyMenu"));
1039     }
1040 #endif
1041
1042     Refresh();
1043 }
1044
1045 wxString wxMenuBar::GetLabelTop(size_t pos) const
1046 {
1047     wxCHECK_MSG( pos < GetMenuCount(), wxEmptyString,
1048                  wxT("invalid menu index in wxMenuBar::GetLabelTop") );
1049
1050     return wxMenuItem::GetLabelFromText(m_titles[pos]);
1051 }
1052
1053 // ---------------------------------------------------------------------------
1054 // wxMenuBar construction
1055 // ---------------------------------------------------------------------------
1056
1057 wxMenu *wxMenuBar::Replace(size_t pos, wxMenu *menu, const wxString& title)
1058 {
1059     wxMenu *menuOld = wxMenuBarBase::Replace(pos, menu, title);
1060     if ( !menuOld )
1061         return NULL;
1062
1063     m_titles[pos] = title;
1064
1065 #if defined(WINCE_WITHOUT_COMMANDBAR)
1066     if (IsAttached())
1067 #else
1068     if (GetHmenu())
1069 #endif
1070     {
1071         int mswpos = MSWPositionForWxMenu(menuOld,pos);
1072
1073         // can't use ModifyMenu() because it deletes the submenu it replaces
1074         if ( !::RemoveMenu(GetHmenu(), (UINT)mswpos, MF_BYPOSITION) )
1075         {
1076             wxLogLastError(wxT("RemoveMenu"));
1077         }
1078
1079         if ( !::InsertMenu(GetHmenu(), (UINT)mswpos,
1080                            MF_BYPOSITION | MF_POPUP | MF_STRING,
1081                            (UINT)GetHmenuOf(menu), title) )
1082         {
1083             wxLogLastError(wxT("InsertMenu"));
1084         }
1085
1086 #if wxUSE_ACCEL
1087         if ( menuOld->HasAccels() || menu->HasAccels() )
1088         {
1089             // need to rebuild accell table
1090             RebuildAccelTable();
1091         }
1092 #endif // wxUSE_ACCEL
1093
1094         if (IsAttached())
1095             Refresh();
1096     }
1097
1098     return menuOld;
1099 }
1100
1101 bool wxMenuBar::Insert(size_t pos, wxMenu *menu, const wxString& title)
1102 {
1103     // Find out which MSW item before which we'll be inserting before
1104     // wxMenuBarBase::Insert is called and GetMenu(pos) is the new menu.
1105     // If IsAttached() is false this won't be used anyway
1106     bool isAttached =
1107 #if defined(WINCE_WITHOUT_COMMANDBAR)
1108         IsAttached();
1109 #else
1110         (GetHmenu() != 0);
1111 #endif
1112
1113     int mswpos = (!isAttached || (pos == m_menus.GetCount()))
1114         ?   -1 // append the menu
1115         :   MSWPositionForWxMenu(GetMenu(pos),pos);
1116
1117     if ( !wxMenuBarBase::Insert(pos, menu, title) )
1118         return false;
1119
1120     m_titles.Insert(title, pos);
1121
1122     if ( isAttached )
1123     {
1124 #if defined(WINCE_WITHOUT_COMMANDBAR)
1125         if (!GetToolBar())
1126             return false;
1127         TBBUTTON tbButton;
1128         memset(&tbButton, 0, sizeof(TBBUTTON));
1129         tbButton.iBitmap = I_IMAGENONE;
1130         tbButton.fsState = TBSTATE_ENABLED;
1131         tbButton.fsStyle = TBSTYLE_DROPDOWN | TBSTYLE_NO_DROPDOWN_ARROW | TBSTYLE_AUTOSIZE;
1132
1133         HMENU hPopupMenu = (HMENU) menu->GetHMenu() ;
1134         tbButton.dwData = (DWORD)hPopupMenu;
1135         wxString label = wxStripMenuCodes(title);
1136         tbButton.iString = (int) label.c_str();
1137
1138         tbButton.idCommand = NewControlId();
1139         if (!::SendMessage((HWND) GetToolBar()->GetHWND(), TB_INSERTBUTTON, pos, (LPARAM)&tbButton))
1140         {
1141             wxLogLastError(wxT("TB_INSERTBUTTON"));
1142             return false;
1143         }
1144         wxUnusedVar(mswpos);
1145 #else
1146         if ( !::InsertMenu(GetHmenu(), mswpos,
1147                            MF_BYPOSITION | MF_POPUP | MF_STRING,
1148                            (UINT)GetHmenuOf(menu), title) )
1149         {
1150             wxLogLastError(wxT("InsertMenu"));
1151         }
1152 #endif
1153 #if wxUSE_ACCEL
1154         if ( menu->HasAccels() )
1155         {
1156             // need to rebuild accell table
1157             RebuildAccelTable();
1158         }
1159 #endif // wxUSE_ACCEL
1160
1161         if (IsAttached())
1162             Refresh();
1163     }
1164
1165     return true;
1166 }
1167
1168 bool wxMenuBar::Append(wxMenu *menu, const wxString& title)
1169 {
1170     WXHMENU submenu = menu ? menu->GetHMenu() : 0;
1171     wxCHECK_MSG( submenu, false, wxT("can't append invalid menu to menubar") );
1172
1173     if ( !wxMenuBarBase::Append(menu, title) )
1174         return false;
1175
1176     m_titles.Add(title);
1177
1178 #if defined(WINCE_WITHOUT_COMMANDBAR)
1179     if (IsAttached())
1180 #else
1181     if (GetHmenu())
1182 #endif
1183     {
1184 #if defined(WINCE_WITHOUT_COMMANDBAR)
1185         if (!GetToolBar())
1186             return false;
1187         TBBUTTON tbButton;
1188         memset(&tbButton, 0, sizeof(TBBUTTON));
1189         tbButton.iBitmap = I_IMAGENONE;
1190         tbButton.fsState = TBSTATE_ENABLED;
1191         tbButton.fsStyle = TBSTYLE_DROPDOWN | TBSTYLE_NO_DROPDOWN_ARROW | TBSTYLE_AUTOSIZE;
1192
1193         size_t pos = GetMenuCount();
1194         HMENU hPopupMenu = (HMENU) menu->GetHMenu() ;
1195         tbButton.dwData = (DWORD)hPopupMenu;
1196         wxString label = wxStripMenuCodes(title);
1197         tbButton.iString = (int) label.c_str();
1198
1199         tbButton.idCommand = NewControlId();
1200         if (!::SendMessage((HWND) GetToolBar()->GetHWND(), TB_INSERTBUTTON, pos, (LPARAM)&tbButton))
1201         {
1202             wxLogLastError(wxT("TB_INSERTBUTTON"));
1203             return false;
1204         }
1205 #else
1206         if ( !::AppendMenu(GetHmenu(), MF_POPUP | MF_STRING,
1207                            (UINT)submenu, title) )
1208         {
1209             wxLogLastError(wxT("AppendMenu"));
1210         }
1211 #endif
1212
1213 #if wxUSE_ACCEL
1214         if ( menu->HasAccels() )
1215         {
1216             // need to rebuild accelerator table
1217             RebuildAccelTable();
1218         }
1219 #endif // wxUSE_ACCEL
1220
1221         if (IsAttached())
1222             Refresh();
1223     }
1224
1225     return true;
1226 }
1227
1228 wxMenu *wxMenuBar::Remove(size_t pos)
1229 {
1230     wxMenu *menu = wxMenuBarBase::Remove(pos);
1231     if ( !menu )
1232         return NULL;
1233
1234 #if defined(WINCE_WITHOUT_COMMANDBAR)
1235     if (IsAttached())
1236 #else
1237     if (GetHmenu())
1238 #endif
1239     {
1240 #if defined(WINCE_WITHOUT_COMMANDBAR)
1241         if (GetToolBar())
1242         {
1243             if (!::SendMessage((HWND) GetToolBar()->GetHWND(), TB_DELETEBUTTON, (UINT) pos, (LPARAM) 0))
1244             {
1245                 wxLogLastError(wxT("TB_DELETEBUTTON"));
1246             }
1247         }
1248 #else
1249         if ( !::RemoveMenu(GetHmenu(), (UINT)MSWPositionForWxMenu(menu,pos), MF_BYPOSITION) )
1250         {
1251             wxLogLastError(wxT("RemoveMenu"));
1252         }
1253 #endif
1254
1255 #if wxUSE_ACCEL
1256         if ( menu->HasAccels() )
1257         {
1258             // need to rebuild accell table
1259             RebuildAccelTable();
1260         }
1261 #endif // wxUSE_ACCEL
1262
1263         if (IsAttached())
1264             Refresh();
1265     }
1266
1267     m_titles.RemoveAt(pos);
1268
1269     return menu;
1270 }
1271
1272 #if wxUSE_ACCEL
1273
1274 void wxMenuBar::RebuildAccelTable()
1275 {
1276     // merge the accelerators of all menus into one accel table
1277     size_t nAccelCount = 0;
1278     size_t i, count = GetMenuCount();
1279     wxMenuList::iterator it;
1280     for ( i = 0, it = m_menus.begin(); i < count; i++, it++ )
1281     {
1282         nAccelCount += (*it)->GetAccelCount();
1283     }
1284
1285     if ( nAccelCount )
1286     {
1287         wxAcceleratorEntry *accelEntries = new wxAcceleratorEntry[nAccelCount];
1288
1289         nAccelCount = 0;
1290         for ( i = 0, it = m_menus.begin(); i < count; i++, it++ )
1291         {
1292             nAccelCount += (*it)->CopyAccels(&accelEntries[nAccelCount]);
1293         }
1294
1295         m_accelTable = wxAcceleratorTable(nAccelCount, accelEntries);
1296
1297         delete [] accelEntries;
1298     }
1299 }
1300
1301 #endif // wxUSE_ACCEL
1302
1303 void wxMenuBar::Attach(wxFrame *frame)
1304 {
1305     wxMenuBarBase::Attach(frame);
1306
1307 #if defined(WINCE_WITH_COMMANDBAR)
1308     if (!m_hMenu)
1309         this->Create();
1310     if (!m_commandBar)
1311         m_commandBar = (WXHWND) CommandBar_Create(wxGetInstance(), (HWND) frame->GetHWND(), NewControlId());
1312     if (m_commandBar)
1313     {
1314         if (m_hMenu)
1315         {
1316             if (!CommandBar_InsertMenubarEx((HWND) m_commandBar, NULL, (LPTSTR) m_hMenu, 0))
1317             {
1318                 wxLogLastError(wxT("CommandBar_InsertMenubarEx"));
1319             }
1320         }
1321     }
1322 #endif
1323
1324 #if wxUSE_ACCEL
1325     RebuildAccelTable();
1326 #endif // wxUSE_ACCEL
1327 }
1328
1329 #if defined(WINCE_WITH_COMMANDBAR)
1330 bool wxMenuBar::AddAdornments(long style)
1331 {
1332     if (m_adornmentsAdded || !m_commandBar)
1333         return false;
1334
1335     if (style & wxCLOSE_BOX)
1336     {
1337         if (!CommandBar_AddAdornments((HWND) m_commandBar, 0, 0))
1338             wxLogLastError(wxT("CommandBar_AddAdornments"));
1339         else
1340             return true;
1341     }
1342     return false;
1343 }
1344 #endif
1345
1346 void wxMenuBar::Detach()
1347 {
1348     wxMenuBarBase::Detach();
1349 }
1350
1351 #endif // wxUSE_MENUS