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