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