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