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 = wxGetAccelFromString(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 correctly
 418             // while our owner-drawning 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 inverses 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         // menu 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 been already 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 items 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 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 chane 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 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     wxCHECK_RET( IsAttached(), wxT("can't refresh unattached menubar") );
 851
 852 #if defined(WINCE_WITHOUT_COMMANDBAR)
 853     if (GetToolBar())
 854     {
 855         CommandBar_DrawMenuBar((HWND) GetToolBar()->GetHWND(), 0);
 856     }
 857 #elif defined(WINCE_WITH_COMMANDBAR)
 858     if (m_commandBar)
 859         DrawMenuBar((HWND) m_commandBar);
 860 #else
 861     DrawMenuBar(GetHwndOf(GetFrame()));
 862 #endif
 863 }
 864
 865 WXHMENU wxMenuBar::Create()
 866 {
 867     // Note: this totally doesn't work on Smartphone,
 868     // since you have to use resources.
 869     // We'll have to find another way to add a menu
 870     // by changing/adding menu items to an existing menu.
 871 #if defined(WINCE_WITHOUT_COMMANDBAR)
 872     if ( m_hMenu != 0 )
 873         return m_hMenu;
 874
 875     if (!GetToolBar())
 876         return 0;
 877
 878     HWND hCommandBar = (HWND) GetToolBar()->GetHWND();
 879     HMENU hMenu = (HMENU)::SendMessage(hCommandBar, SHCMBM_GETMENU, (WPARAM)0, (LPARAM)0);
 880
 881     // hMenu may be zero on Windows Mobile 5. So add the menus anyway.
 882     if (1) // (hMenu)
 883     {
 884         TBBUTTON tbButton;
 885         memset(&tbButton, 0, sizeof(TBBUTTON));
 886         tbButton.iBitmap = I_IMAGENONE;
 887         tbButton.fsState = TBSTATE_ENABLED;
 888         tbButton.fsStyle = TBSTYLE_DROPDOWN | TBSTYLE_NO_DROPDOWN_ARROW | TBSTYLE_AUTOSIZE;
 889
 890         size_t i;
 891         for (i = 0; i < GetMenuCount(); i++)
 892         {
 893             HMENU hPopupMenu = (HMENU) GetMenu(i)->GetHMenu() ;
 894             tbButton.dwData = (DWORD)hPopupMenu;
 895             wxString label = wxStripMenuCodes(GetLabelTop(i));
 896             tbButton.iString = (int) label.c_str();
 897
 898             int position = i;
 899
 900             tbButton.idCommand = NewControlId();
 901             if (!::SendMessage(hCommandBar, TB_INSERTBUTTON, position, (LPARAM)&tbButton))
 902             {
 903                 wxLogLastError(wxT("TB_INSERTBUTTON"));
 904             }
 905         }
 906     }
 907     m_hMenu = (WXHMENU) hMenu;
 908     return m_hMenu;
 909 #else
 910     if ( m_hMenu != 0 )
 911         return m_hMenu;
 912
 913     m_hMenu = (WXHMENU)::CreateMenu();
 914
 915     if ( !m_hMenu )
 916     {
 917         wxLogLastError(wxT("CreateMenu"));
 918     }
 919     else
 920     {
 921         size_t count = GetMenuCount(), i;
 922         wxMenuList::iterator it;
 923         for ( i = 0, it = m_menus.begin(); i < count; i++, it++ )
 924         {
 925             if ( !::AppendMenu((HMENU)m_hMenu, MF_POPUP | MF_STRING,
 926                                (UINT)(*it)->GetHMenu(),
 927                                m_titles[i]) )
 928             {
 929                 wxLogLastError(wxT("AppendMenu"));
 930             }
 931         }
 932     }
 933
 934     return m_hMenu;
 935 #endif
 936 }
 937
 938 int wxMenuBar::MSWPositionForWxMenu(wxMenu *menu, int wxpos)
 939 {
 940     wxASSERT(menu);
 941     wxASSERT(menu->GetHMenu());
 942     wxASSERT(m_hMenu);
 943
 944 #if defined(__WXWINCE__)
 945     int totalMSWItems = GetMenuCount();
 946 #else
 947     int totalMSWItems = GetMenuItemCount((HMENU)m_hMenu);
 948 #endif
 949
 950     int i; // For old C++ compatibility
 951     for(i=wxpos; i<totalMSWItems; i++)
 952     {
 953         if(GetSubMenu((HMENU)m_hMenu,i)==(HMENU)menu->GetHMenu())
 954             return i;
 955     }
 956     for(i=0; i<wxpos; i++)
 957     {
 958         if(GetSubMenu((HMENU)m_hMenu,i)==(HMENU)menu->GetHMenu())
 959             return i;
 960     }
 961     wxFAIL;
 962     return -1;
 963 }
 964
 965 // ---------------------------------------------------------------------------
 966 // wxMenuBar functions to work with the top level submenus
 967 // ---------------------------------------------------------------------------
 968
 969 // NB: we don't support owner drawn top level items for now, if we do these
 970 //     functions would have to be changed to use wxMenuItem as well
 971
 972 void wxMenuBar::EnableTop(size_t pos, bool enable)
 973 {
 974     wxCHECK_RET( IsAttached(), wxT("doesn't work with unattached menubars") );
 975     wxCHECK_RET( pos < GetMenuCount(), wxT("invalid menu index") );
 976
 977     int flag = enable ? MF_ENABLED : MF_GRAYED;
 978
 979     EnableMenuItem((HMENU)m_hMenu, MSWPositionForWxMenu(GetMenu(pos),pos), MF_BYPOSITION | flag);
 980
 981     Refresh();
 982 }
 983
 984 void wxMenuBar::SetLabelTop(size_t pos, const wxString& label)
 985 {
 986     wxCHECK_RET( pos < GetMenuCount(), wxT("invalid menu index") );
 987
 988     m_titles[pos] = label;
 989
 990     if ( !IsAttached() )
 991     {
 992         return;
 993     }
 994     //else: have to modify the existing menu
 995
 996     int mswpos = MSWPositionForWxMenu(GetMenu(pos),pos);
 997
 998     UINT id;
 999     UINT flagsOld = ::GetMenuState((HMENU)m_hMenu, mswpos, MF_BYPOSITION);
1000     if ( flagsOld == 0xFFFFFFFF )
1001     {
1002         wxLogLastError(wxT("GetMenuState"));
1003
1004         return;
1005     }
1006
1007     if ( flagsOld & MF_POPUP )
1008     {
1009         // HIBYTE contains the number of items in the submenu in this case
1010         flagsOld &= 0xff;
1011         id = (UINT)::GetSubMenu((HMENU)m_hMenu, mswpos);
1012     }
1013     else
1014     {
1015         id = pos;
1016     }
1017
1018 #ifdef __WXWINCE__
1019     MENUITEMINFO info;
1020     wxZeroMemory(info);
1021     info.cbSize = sizeof(info);
1022     info.fMask = MIIM_TYPE;
1023     info.fType = MFT_STRING;
1024     info.cch = label.length();
1025     info.dwTypeData = (LPTSTR) label.c_str();
1026     if ( !SetMenuItemInfo(GetHmenu(), id, TRUE, & info) )
1027     {
1028         wxLogLastError(wxT("SetMenuItemInfo"));
1029     }
1030
1031 #else
1032     if ( ::ModifyMenu(GetHmenu(), mswpos, MF_BYPOSITION | MF_STRING | flagsOld,
1033         id, label) == (int)0xFFFFFFFF )
1034     {
1035         wxLogLastError(wxT("ModifyMenu"));
1036     }
1037 #endif
1038
1039     Refresh();
1040 }
1041
1042 wxString wxMenuBar::GetLabelTop(size_t pos) const
1043 {
1044     wxCHECK_MSG( pos < GetMenuCount(), wxEmptyString,
1045                  wxT("invalid menu index in wxMenuBar::GetLabelTop") );
1046
1047     return wxMenuItem::GetLabelFromText(m_titles[pos]);
1048 }
1049
1050 // ---------------------------------------------------------------------------
1051 // wxMenuBar construction
1052 // ---------------------------------------------------------------------------
1053
1054 wxMenu *wxMenuBar::Replace(size_t pos, wxMenu *menu, const wxString& title)
1055 {
1056     wxMenu *menuOld = wxMenuBarBase::Replace(pos, menu, title);
1057     if ( !menuOld )
1058         return NULL;
1059
1060     m_titles[pos] = title;
1061
1062 #if defined(WINCE_WITHOUT_COMMANDBAR)
1063     if (IsAttached())
1064 #else
1065     if (GetHmenu())
1066 #endif
1067     {
1068         int mswpos = MSWPositionForWxMenu(menuOld,pos);
1069
1070         // can't use ModifyMenu() because it deletes the submenu it replaces
1071         if ( !::RemoveMenu(GetHmenu(), (UINT)mswpos, MF_BYPOSITION) )
1072         {
1073             wxLogLastError(wxT("RemoveMenu"));
1074         }
1075
1076         if ( !::InsertMenu(GetHmenu(), (UINT)mswpos,
1077                            MF_BYPOSITION | MF_POPUP | MF_STRING,
1078                            (UINT)GetHmenuOf(menu), title) )
1079         {
1080             wxLogLastError(wxT("InsertMenu"));
1081         }
1082
1083 #if wxUSE_ACCEL
1084         if ( menuOld->HasAccels() || menu->HasAccels() )
1085         {
1086             // need to rebuild accell table
1087             RebuildAccelTable();
1088         }
1089 #endif // wxUSE_ACCEL
1090
1091         if (IsAttached())
1092             Refresh();
1093     }
1094
1095     return menuOld;
1096 }
1097
1098 bool wxMenuBar::Insert(size_t pos, wxMenu *menu, const wxString& title)
1099 {
1100     // Find out which MSW item before which we'll be inserting before
1101     // wxMenuBarBase::Insert is called and GetMenu(pos) is the new menu.
1102     // If IsAttached() is false this won't be used anyway
1103     bool isAttached =
1104 #if defined(WINCE_WITHOUT_COMMANDBAR)
1105         IsAttached();
1106 #else
1107         (GetHmenu() != 0);
1108 #endif
1109
1110     int mswpos = (!isAttached || (pos == m_menus.GetCount()))
1111         ?   -1 // append the menu
1112         :   MSWPositionForWxMenu(GetMenu(pos),pos);
1113
1114     if ( !wxMenuBarBase::Insert(pos, menu, title) )
1115         return false;
1116
1117     m_titles.Insert(title, pos);
1118
1119     if ( isAttached )
1120     {
1121 #if defined(WINCE_WITHOUT_COMMANDBAR)
1122         if (!GetToolBar())
1123             return false;
1124         TBBUTTON tbButton;
1125         memset(&tbButton, 0, sizeof(TBBUTTON));
1126         tbButton.iBitmap = I_IMAGENONE;
1127         tbButton.fsState = TBSTATE_ENABLED;
1128         tbButton.fsStyle = TBSTYLE_DROPDOWN | TBSTYLE_NO_DROPDOWN_ARROW | TBSTYLE_AUTOSIZE;
1129
1130         HMENU hPopupMenu = (HMENU) menu->GetHMenu() ;
1131         tbButton.dwData = (DWORD)hPopupMenu;
1132         wxString label = wxStripMenuCodes(title);
1133         tbButton.iString = (int) label.c_str();
1134
1135         tbButton.idCommand = NewControlId();
1136         if (!::SendMessage((HWND) GetToolBar()->GetHWND(), TB_INSERTBUTTON, pos, (LPARAM)&tbButton))
1137         {
1138             wxLogLastError(wxT("TB_INSERTBUTTON"));
1139             return false;
1140         }
1141         wxUnusedVar(mswpos);
1142 #else
1143         if ( !::InsertMenu(GetHmenu(), mswpos,
1144                            MF_BYPOSITION | MF_POPUP | MF_STRING,
1145                            (UINT)GetHmenuOf(menu), title) )
1146         {
1147             wxLogLastError(wxT("InsertMenu"));
1148         }
1149 #endif
1150 #if wxUSE_ACCEL
1151         if ( menu->HasAccels() )
1152         {
1153             // need to rebuild accell table
1154             RebuildAccelTable();
1155         }
1156 #endif // wxUSE_ACCEL
1157
1158         if (IsAttached())
1159             Refresh();
1160     }
1161
1162     return true;
1163 }
1164
1165 bool wxMenuBar::Append(wxMenu *menu, const wxString& title)
1166 {
1167     WXHMENU submenu = menu ? menu->GetHMenu() : 0;
1168     wxCHECK_MSG( submenu, false, wxT("can't append invalid menu to menubar") );
1169
1170     if ( !wxMenuBarBase::Append(menu, title) )
1171         return false;
1172
1173     m_titles.Add(title);
1174
1175 #if defined(WINCE_WITHOUT_COMMANDBAR)
1176     if (IsAttached())
1177 #else
1178     if (GetHmenu())
1179 #endif
1180     {
1181 #if defined(WINCE_WITHOUT_COMMANDBAR)
1182         if (!GetToolBar())
1183             return false;
1184         TBBUTTON tbButton;
1185         memset(&tbButton, 0, sizeof(TBBUTTON));
1186         tbButton.iBitmap = I_IMAGENONE;
1187         tbButton.fsState = TBSTATE_ENABLED;
1188         tbButton.fsStyle = TBSTYLE_DROPDOWN | TBSTYLE_NO_DROPDOWN_ARROW | TBSTYLE_AUTOSIZE;
1189
1190         size_t pos = GetMenuCount();
1191         HMENU hPopupMenu = (HMENU) menu->GetHMenu() ;
1192         tbButton.dwData = (DWORD)hPopupMenu;
1193         wxString label = wxStripMenuCodes(title);
1194         tbButton.iString = (int) label.c_str();
1195
1196         tbButton.idCommand = NewControlId();
1197         if (!::SendMessage((HWND) GetToolBar()->GetHWND(), TB_INSERTBUTTON, pos, (LPARAM)&tbButton))
1198         {
1199             wxLogLastError(wxT("TB_INSERTBUTTON"));
1200             return false;
1201         }
1202 #else
1203         if ( !::AppendMenu(GetHmenu(), MF_POPUP | MF_STRING,
1204                            (UINT)submenu, title) )
1205         {
1206             wxLogLastError(wxT("AppendMenu"));
1207         }
1208 #endif
1209
1210 #if wxUSE_ACCEL
1211         if ( menu->HasAccels() )
1212         {
1213             // need to rebuild accelerator table
1214             RebuildAccelTable();
1215         }
1216 #endif // wxUSE_ACCEL
1217
1218         if (IsAttached())
1219             Refresh();
1220     }
1221
1222     return true;
1223 }
1224
1225 wxMenu *wxMenuBar::Remove(size_t pos)
1226 {
1227     wxMenu *menu = wxMenuBarBase::Remove(pos);
1228     if ( !menu )
1229         return NULL;
1230
1231 #if defined(WINCE_WITHOUT_COMMANDBAR)
1232     if (IsAttached())
1233 #else
1234     if (GetHmenu())
1235 #endif
1236     {
1237 #if defined(WINCE_WITHOUT_COMMANDBAR)
1238         if (GetToolBar())
1239         {
1240             if (!::SendMessage((HWND) GetToolBar()->GetHWND(), TB_DELETEBUTTON, (UINT) pos, (LPARAM) 0))
1241             {
1242                 wxLogLastError(wxT("TB_DELETEBUTTON"));
1243             }
1244         }
1245 #else
1246         if ( !::RemoveMenu(GetHmenu(), (UINT)MSWPositionForWxMenu(menu,pos), MF_BYPOSITION) )
1247         {
1248             wxLogLastError(wxT("RemoveMenu"));
1249         }
1250 #endif
1251
1252 #if wxUSE_ACCEL
1253         if ( menu->HasAccels() )
1254         {
1255             // need to rebuild accell table
1256             RebuildAccelTable();
1257         }
1258 #endif // wxUSE_ACCEL
1259
1260         if (IsAttached())
1261             Refresh();
1262     }
1263
1264     m_titles.RemoveAt(pos);
1265
1266     return menu;
1267 }
1268
1269 #if wxUSE_ACCEL
1270
1271 void wxMenuBar::RebuildAccelTable()
1272 {
1273     // merge the accelerators of all menus into one accel table
1274     size_t nAccelCount = 0;
1275     size_t i, count = GetMenuCount();
1276     wxMenuList::iterator it;
1277     for ( i = 0, it = m_menus.begin(); i < count; i++, it++ )
1278     {
1279         nAccelCount += (*it)->GetAccelCount();
1280     }
1281
1282     if ( nAccelCount )
1283     {
1284         wxAcceleratorEntry *accelEntries = new wxAcceleratorEntry[nAccelCount];
1285
1286         nAccelCount = 0;
1287         for ( i = 0, it = m_menus.begin(); i < count; i++, it++ )
1288         {
1289             nAccelCount += (*it)->CopyAccels(&accelEntries[nAccelCount]);
1290         }
1291
1292         m_accelTable = wxAcceleratorTable(nAccelCount, accelEntries);
1293
1294         delete [] accelEntries;
1295     }
1296 }
1297
1298 #endif // wxUSE_ACCEL
1299
1300 void wxMenuBar::Attach(wxFrame *frame)
1301 {
1302     wxMenuBarBase::Attach(frame);
1303
1304 #if defined(WINCE_WITH_COMMANDBAR)
1305     if (!m_hMenu)
1306         this->Create();
1307     if (!m_commandBar)
1308         m_commandBar = (WXHWND) CommandBar_Create(wxGetInstance(), (HWND) frame->GetHWND(), NewControlId());
1309     if (m_commandBar)
1310     {
1311         if (m_hMenu)
1312         {
1313             if (!CommandBar_InsertMenubarEx((HWND) m_commandBar, NULL, (LPTSTR) m_hMenu, 0))
1314             {
1315                 wxLogLastError(wxT("CommandBar_InsertMenubarEx"));
1316             }
1317         }
1318     }
1319 #endif
1320
1321 #if wxUSE_ACCEL
1322     RebuildAccelTable();
1323 #endif // wxUSE_ACCEL
1324 }
1325
1326 #if defined(WINCE_WITH_COMMANDBAR)
1327 bool wxMenuBar::AddAdornments(long style)
1328 {
1329     if (m_adornmentsAdded || !m_commandBar)
1330         return false;
1331
1332     if (style & wxCLOSE_BOX)
1333     {
1334         if (!CommandBar_AddAdornments((HWND) m_commandBar, 0, 0))
1335             wxLogLastError(wxT("CommandBar_AddAdornments"));
1336         else
1337             return true;
1338     }
1339     return false;
1340 }
1341 #endif
1342
1343 void wxMenuBar::Detach()
1344 {
1345     wxMenuBarBase::Detach();
1346 }
1347
1348 #endif // wxUSE_MENUS