src/msw/menu.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        menu.cpp
   3 // Purpose:     wxMenu, wxMenuBar, wxMenuItem
   4 // Author:      Julian Smart
   5 // Modified by: Vadim Zeitlin
   6 // Created:     04/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart and Markus Holzem
   9 // Licence:     wxWindows license
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ===========================================================================
  13 // declarations
  14 // ===========================================================================
  15
  16 // ---------------------------------------------------------------------------
  17 // headers
  18 // ---------------------------------------------------------------------------
  19
  20 #ifdef __GNUG__
  21     #pragma implementation "menu.h"
  22 #endif
  23
  24 // For compilers that support precompilation, includes "wx.h".
  25 #include "wx/wxprec.h"
  26
  27 #ifdef __BORLANDC__
  28     #pragma hdrstop
  29 #endif
  30
  31 #ifndef WX_PRECOMP
  32     #include "wx/frame.h"
  33     #include "wx/menu.h"
  34     #include "wx/utils.h"
  35 #endif
  36
  37 #if wxUSE_OWNER_DRAWN
  38     #include "wx/ownerdrw.h"
  39 #endif
  40
  41 #include "wx/msw/private.h"
  42 #include "wx/msw/menu.h"
  43 #include "wx/menuitem.h"
  44 #include "wx/log.h"
  45
  46 // other standard headers
  47 #include <string.h>
  48
  49 // ----------------------------------------------------------------------------
  50 // global variables
  51 // ----------------------------------------------------------------------------
  52
  53 extern wxMenu *wxCurrentPopupMenu;
  54
  55 // ----------------------------------------------------------------------------
  56 // constants
  57 // ----------------------------------------------------------------------------
  58
  59 // the (popup) menu title has this special id
  60 static const int idMenuTitle = -2;
  61
  62 // ----------------------------------------------------------------------------
  63 // macros
  64 // ----------------------------------------------------------------------------
  65
  66 #if !USE_SHARED_LIBRARY
  67     IMPLEMENT_DYNAMIC_CLASS(wxMenu, wxEvtHandler)
  68     IMPLEMENT_DYNAMIC_CLASS(wxMenuBar, wxEvtHandler)
  69 #endif
  70
  71 // convenience macros
  72 #define GetHMENU()          ((HMENU)GetHMenu())
  73 #define GetHMenuOf(menu)    ((HMENU)menu->GetHMenu())
  74
  75 // ============================================================================
  76 // implementation
  77 // ============================================================================
  78
  79 // ---------------------------------------------------------------------------
  80 // wxMenu construction, adding and removing menu items
  81 // ---------------------------------------------------------------------------
  82
  83 // Construct a menu with optional title (then use append)
  84 wxMenu::wxMenu(const wxString& title, const wxFunction func)
  85       : m_title(title)
  86 {
  87     m_parent = NULL;
  88     m_eventHandler = this;
  89     m_pInvokingWindow = NULL;
  90     m_doBreak = FALSE ;
  91     m_noItems = 0;
  92     m_menuBar = NULL;
  93     m_hMenu = (WXHMENU) CreatePopupMenu();
  94     m_savehMenu = 0 ;
  95     m_topLevelMenu = this;
  96     m_clientData = (void*) NULL;
  97
  98     if ( !!m_title )
  99     {
 100         Append(idMenuTitle, m_title) ;
 101         AppendSeparator() ;
 102     }
 103
 104 #if WXWIN_COMPATIBILITY
 105     Callback(func);
 106 #endif
 107 }
 108
 109 // The wxWindow destructor will take care of deleting the submenus.
 110 wxMenu::~wxMenu()
 111 {
 112     // free Windows resources
 113     if ( m_hMenu )
 114     {
 115         ::DestroyMenu((HMENU)m_hMenu);
 116         m_hMenu = 0;
 117     }
 118
 119     // delete submenus
 120     wxNode *node = m_menuItems.First();
 121     while ( node )
 122     {
 123         wxMenuItem *item = (wxMenuItem *)node->Data();
 124
 125         // Delete child menus.
 126         // Beware: they must not be appended to children list!!!
 127         // (because order of delete is significant)
 128         if ( item->IsSubMenu() )
 129             item->DeleteSubMenu();
 130
 131         wxNode *next = node->Next();
 132         delete item;
 133         delete node;
 134         node = next;
 135     }
 136 }
 137
 138 void wxMenu::Break()
 139 {
 140     m_doBreak = TRUE;
 141 }
 142
 143 // function appends a new item or submenu to the menu
 144 void wxMenu::Append(wxMenuItem *pItem)
 145 {
 146     wxCHECK_RET( pItem != NULL, "can't append NULL item to the menu" );
 147
 148     UINT flags = 0;
 149
 150     // if "Break" has just been called, insert a menu break before this item
 151     // (and don't forget to reset the flag)
 152     if ( m_doBreak ) {
 153         flags |= MF_MENUBREAK;
 154         m_doBreak = FALSE;
 155     }
 156
 157     if ( pItem->IsSeparator() ) {
 158         flags |= MF_SEPARATOR;
 159     }
 160
 161     // id is the numeric id for normal menu items and HMENU for submenus as
 162     // required by ::AppendMenu() API
 163     UINT id;
 164     wxMenu *submenu = pItem->GetSubMenu();
 165     if ( submenu != NULL ) {
 166         wxASSERT( submenu->GetHMenu() != (WXHMENU) NULL );
 167
 168         id = (UINT)submenu->GetHMenu();
 169         submenu->m_topLevelMenu = m_topLevelMenu;
 170         submenu->m_parent       = this;
 171         submenu->m_savehMenu    = (WXHMENU)id;
 172         submenu->m_hMenu        = 0;
 173
 174         flags |= MF_POPUP;
 175     }
 176     else {
 177         id = pItem->GetId();
 178     }
 179
 180     LPCSTR pData;
 181
 182 #if wxUSE_OWNER_DRAWN
 183     if ( pItem->IsOwnerDrawn() ) {  // want to get {Measure|Draw}Item messages?
 184         // item draws itself, pass pointer to it in data parameter
 185         flags |= MF_OWNERDRAW;
 186         pData = (LPCSTR)pItem;
 187     }
 188     else
 189 #endif
 190     {
 191         // menu is just a normal string (passed in data parameter)
 192         flags |= MF_STRING;
 193         pData = pItem->GetName();
 194     }
 195
 196     // visually select the menu title
 197     if ( id == idMenuTitle )
 198     {
 199         // TODO use SetMenuItemInfo(MFS_DEFAULT) to put it in bold face
 200     }
 201
 202     if ( !::AppendMenu(GetHMENU(), flags, id, pData) )
 203     {
 204         wxLogLastError("AppendMenu");
 205     }
 206     else
 207     {
 208         m_menuItems.Append(pItem);
 209         m_noItems++;
 210     }
 211 }
 212
 213 void wxMenu::AppendSeparator()
 214 {
 215     Append(new wxMenuItem(this, ID_SEPARATOR));
 216 }
 217
 218 // Pullright item
 219 void wxMenu::Append(int id,
 220                     const wxString& label,
 221                     wxMenu *SubMenu,
 222                     const wxString& helpString)
 223 {
 224     Append(new wxMenuItem(this, id, label, helpString, FALSE, SubMenu));
 225 }
 226
 227 // Ordinary menu item
 228 void wxMenu::Append(int id,
 229                     const wxString& label,
 230                     const wxString& helpString,
 231                     bool checkable)
 232 {
 233     // 'checkable' parameter is useless for Windows.
 234     Append(new wxMenuItem(this, id, label, helpString, checkable));
 235 }
 236
 237 // delete item by id
 238 void wxMenu::Delete(int id)
 239 {
 240     wxMenuItem *item = NULL;
 241     int pos;
 242     wxNode *node;
 243     for (pos = 0, node = m_menuItems.First(); node; node = node->Next(), pos++)
 244     {
 245         item = (wxMenuItem *)node->Data();
 246         if ( item->GetId() == id )
 247             break;
 248     }
 249
 250     wxCHECK_RET( node, "wxMenu::Delete(): item doesn't exist" );
 251
 252     HMENU menu = GetHMENU();
 253
 254     wxMenu *pSubMenu = item->GetSubMenu();
 255     if ( pSubMenu != NULL ) {
 256         RemoveMenu(menu, (UINT)pos, MF_BYPOSITION);
 257         pSubMenu->m_hMenu = pSubMenu->m_savehMenu;
 258         pSubMenu->m_savehMenu = 0;
 259         pSubMenu->m_parent = NULL;
 260         //     RemoveChild(item->subMenu);
 261         pSubMenu->m_topLevelMenu = NULL;
 262         // TODO: Why isn't subMenu deleted here???
 263         // Will put this in for now. Assuming this is supposed
 264         // to delete the menu, not just remove it.
 265         item->DeleteSubMenu();
 266     }
 267     else {
 268         DeleteMenu(menu, (UINT)pos, MF_BYPOSITION);
 269     }
 270
 271     m_menuItems.DeleteNode(node);
 272     delete item;
 273 }
 274
 275 // ---------------------------------------------------------------------------
 276 // wxMenu functions implemented in wxMenuItem
 277 // ---------------------------------------------------------------------------
 278
 279 void wxMenu::Enable(int id, bool Flag)
 280 {
 281     wxMenuItem *item = FindItemForId(id);
 282     wxCHECK_RET( item != NULL, "can't enable non-existing menu item" );
 283
 284     item->Enable(Flag);
 285 }
 286
 287 bool wxMenu::IsEnabled(int id) const
 288 {
 289     wxMenuItem *item = FindItemForId(id);
 290     wxCHECK_MSG( item != NULL, FALSE, "invalid item id" );
 291
 292     return item->IsEnabled();
 293 }
 294
 295 void wxMenu::Check(int id, bool Flag)
 296 {
 297     wxMenuItem *item = FindItemForId(id);
 298     wxCHECK_RET( item != NULL, "can't get status of non-existing menu item" );
 299
 300     item->Check(Flag);
 301 }
 302
 303 bool wxMenu::IsChecked(int id) const
 304 {
 305     wxMenuItem *item = FindItemForId(id);
 306     wxCHECK_MSG( item != NULL, FALSE, "invalid item id" );
 307
 308     return item->IsChecked();
 309 }
 310
 311 void wxMenu::SetLabel(int id, const wxString& label)
 312 {
 313     wxMenuItem *item = FindItemForId(id) ;
 314     wxCHECK_RET( item, "wxMenu::SetLabel: no such item" );
 315
 316     item->SetName(label);
 317 }
 318
 319 wxString wxMenu::GetLabel(int id) const
 320 {
 321     wxString label;
 322     wxMenuItem *pItem = FindItemForId(id) ;
 323     if (pItem)
 324         label = pItem->GetName() ;
 325     else
 326         wxFAIL_MSG("wxMenu::GetLabel: item doesn't exist");
 327
 328     return label;
 329 }
 330
 331 void wxMenu::SetHelpString(int itemId, const wxString& helpString)
 332 {
 333     wxMenuItem *item = FindItemForId (itemId);
 334     if (item)
 335         item->SetHelp(helpString);
 336     else
 337         wxFAIL_MSG("wxMenu::SetHelpString: item doesn't exist");
 338 }
 339
 340 wxString wxMenu::GetHelpString (int itemId) const
 341 {
 342     wxString help;
 343     wxMenuItem *item = FindItemForId (itemId);
 344     if (item)
 345         help = item->GetHelp();
 346     else
 347         wxFAIL_MSG("wxMenu::GetHelpString: item doesn't exist");
 348
 349     return help;
 350 }
 351
 352 // ---------------------------------------------------------------------------
 353 // wxMenu title
 354 // ---------------------------------------------------------------------------
 355
 356 void wxMenu::SetTitle(const wxString& label)
 357 {
 358     bool hasNoTitle = m_title.IsEmpty();
 359     m_title = label;
 360
 361     HMENU hMenu = GetHMENU();
 362
 363     if ( hasNoTitle )
 364     {
 365         if ( !label.IsEmpty() )
 366         {
 367             if ( !InsertMenu(hMenu, 0u, MF_BYPOSITION | MF_STRING,
 368                              (unsigned)idMenuTitle, m_title) ||
 369                  !InsertMenu(hMenu, 1u, MF_BYPOSITION, (unsigned)-1, NULL) )
 370             {
 371                 wxLogLastError("InsertMenu");
 372             }
 373         }
 374     }
 375     else
 376     {
 377         if ( label.IsEmpty() )
 378         {
 379             // remove the title and the separator after it
 380             if ( !RemoveMenu(hMenu, 0, MF_BYPOSITION) ||
 381                  !RemoveMenu(hMenu, 0, MF_BYPOSITION) )
 382             {
 383                 wxLogLastError("RemoveMenu");
 384             }
 385         }
 386         else
 387         {
 388             // modify the title
 389             if ( !ModifyMenu(hMenu, 0u,
 390                         MF_BYPOSITION | MF_STRING,
 391                         (unsigned)idMenuTitle, m_title) )
 392             {
 393                 wxLogLastError("ModifyMenu");
 394             }
 395         }
 396     }
 397
 398 #ifndef __WIN16__
 399     // put the title string in bold face
 400     if ( !m_title.IsEmpty() )
 401     {
 402         MENUITEMINFO mii;
 403         mii.cbSize = sizeof(mii);
 404         mii.fMask = MIIM_STATE;
 405         mii.fState = MFS_DEFAULT;
 406
 407         if ( !SetMenuItemInfo(hMenu, (unsigned)idMenuTitle, FALSE, &mii) )
 408         {
 409             wxLogLastError("SetMenuItemInfo");
 410         }
 411     }
 412 #endif
 413 }
 414
 415 const wxString wxMenu::GetTitle() const
 416 {
 417     return m_title;
 418 }
 419
 420 // ---------------------------------------------------------------------------
 421 // event processing
 422 // ---------------------------------------------------------------------------
 423
 424 bool wxMenu::MSWCommand(WXUINT WXUNUSED(param), WXWORD id)
 425 {
 426     // ignore commands from the menu title
 427
 428     // NB: VC++ generates wrong assembler for `if ( id != idMenuTitle )'!!
 429     if ( id != (WXWORD)idMenuTitle )
 430     {
 431         wxCommandEvent event(wxEVT_COMMAND_MENU_SELECTED);
 432         event.SetEventObject( this );
 433         event.SetId( id );
 434         event.SetInt( id );
 435         ProcessCommand(event);
 436     }
 437
 438     return TRUE;
 439 }
 440
 441 void wxMenu::ProcessCommand(wxCommandEvent & event)
 442 {
 443     bool processed = FALSE;
 444
 445 #if WXWIN_COMPATIBILITY
 446     // Try a callback
 447     if (m_callback)
 448     {
 449         (void)(*(m_callback))(*this, event);
 450         processed = TRUE;
 451     }
 452 #endif // WXWIN_COMPATIBILITY
 453
 454     // Try the menu's event handler
 455     if ( !processed && GetEventHandler())
 456     {
 457         processed = GetEventHandler()->ProcessEvent(event);
 458     }
 459
 460     // Try the window the menu was popped up from (and up through the
 461     // hierarchy)
 462     wxWindow *win = GetInvokingWindow();
 463     if ( !processed && win )
 464         processed = win->GetEventHandler()->ProcessEvent(event);
 465 }
 466
 467 // ---------------------------------------------------------------------------
 468 // Item search
 469 // ---------------------------------------------------------------------------
 470
 471 // Finds the item id matching the given string, -1 if not found.
 472 int wxMenu::FindItem (const wxString& itemString) const
 473 {
 474     wxString itemLabel = wxStripMenuCodes(itemString);
 475     for ( wxNode *node = m_menuItems.First(); node; node = node->Next() )
 476     {
 477         wxMenuItem *item = (wxMenuItem *)node->Data();
 478         if ( item->IsSubMenu() )
 479         {
 480             int ans = item->GetSubMenu()->FindItem(itemString);
 481             if ( ans != wxNOT_FOUND )
 482                 return ans;
 483         }
 484         else if ( !item->IsSeparator() )
 485         {
 486             wxString label = wxStripMenuCodes(item->GetName());
 487             if ( itemLabel == label )
 488                 return item->GetId();
 489         }
 490     }
 491
 492     return wxNOT_FOUND;
 493 }
 494
 495 wxMenuItem *wxMenu::FindItemForId(int itemId, wxMenu ** itemMenu) const
 496 {
 497     if ( itemMenu )
 498         *itemMenu = NULL;
 499
 500     wxMenuItem *item = NULL;
 501     for ( wxNode *node = m_menuItems.First(); node && !item; node = node->Next() )
 502     {
 503         item = (wxMenuItem *)node->Data();
 504
 505         if ( item->GetId() == itemId )
 506         {
 507             if (itemMenu)
 508                 *itemMenu = (wxMenu *)this;
 509         }
 510         else if ( item->IsSubMenu() )
 511         {
 512             item = item->GetSubMenu()->FindItemForId(itemId, itemMenu);
 513         }
 514         else
 515         {
 516             // don't exit the loop
 517             item = NULL;
 518         }
 519     }
 520
 521     return item;
 522 }
 523
 524 // ---------------------------------------------------------------------------
 525 // other
 526 // ---------------------------------------------------------------------------
 527
 528 bool wxWindow::PopupMenu(wxMenu *menu, int x, int y)
 529 {
 530     menu->SetInvokingWindow(this);
 531     menu->UpdateUI();
 532
 533     HWND hWnd = (HWND) GetHWND();
 534     HMENU hMenu = (HMENU)menu->GetHMenu();
 535     POINT point;
 536     point.x = x;
 537     point.y = y;
 538     ::ClientToScreen(hWnd, &point);
 539     wxCurrentPopupMenu = menu;
 540     ::TrackPopupMenu(hMenu, TPM_RIGHTBUTTON, point.x, point.y, 0, hWnd, NULL);
 541     wxYield();
 542     wxCurrentPopupMenu = NULL;
 543
 544     menu->SetInvokingWindow(NULL);
 545
 546     return TRUE;
 547 }
 548
 549 void wxMenu::Attach(wxMenuBar *menubar)
 550 {
 551     // menu can be in at most one menubar because otherwise they would both
 552     // delete the menu pointer
 553     wxASSERT_MSG( !m_menuBar, "menu belongs to 2 menubars, expect a crash" );
 554
 555     m_menuBar = menubar;
 556     m_savehMenu = m_hMenu;
 557     m_hMenu = 0;
 558 }
 559
 560 void wxMenu::Detach()
 561 {
 562     wxASSERT_MSG( m_menuBar, "can't detach menu if it's not attached" );
 563
 564     m_hMenu = m_savehMenu;
 565     m_savehMenu = 0;
 566 }
 567
 568 // ---------------------------------------------------------------------------
 569 // Menu Bar
 570 // ---------------------------------------------------------------------------
 571
 572 void wxMenuBar::Init()
 573 {
 574     m_eventHandler = this;
 575     m_menuCount = 0;
 576     m_menus = NULL;
 577     m_titles = NULL;
 578     m_menuBarFrame = NULL;
 579     m_hMenu = 0;
 580 }
 581
 582 wxMenuBar::wxMenuBar()
 583 {
 584     Init();
 585 }
 586
 587 wxMenuBar::wxMenuBar( long WXUNUSED(style) )
 588 {
 589     Init();
 590 }
 591
 592 wxMenuBar::wxMenuBar(int count, wxMenu *menus[], const wxString titles[])
 593 {
 594     Init();
 595
 596     m_menuCount = count;
 597     m_menus = menus;
 598     m_titles = new wxString[count];
 599
 600     int i;
 601     for ( i = 0; i < count; i++ )
 602         m_titles[i] = titles[i];
 603
 604     for ( i = 0; i < count; i++ )
 605         m_menus[i]->Attach(this);
 606 }
 607
 608 wxMenuBar::~wxMenuBar()
 609 {
 610     for ( int i = 0; i < m_menuCount; i++ )
 611     {
 612         delete m_menus[i];
 613     }
 614
 615     delete[] m_menus;
 616     delete[] m_titles;
 617 }
 618
 619 // ---------------------------------------------------------------------------
 620 // wxMenuBar helpers
 621 // ---------------------------------------------------------------------------
 622
 623 void wxMenuBar::Refresh()
 624 {
 625     wxCHECK_RET( m_menuBarFrame, "can't refresh a menubar withotu a frame" );
 626
 627     DrawMenuBar((HWND)m_menuBarFrame->GetHWND()) ;
 628 }
 629
 630 WXHMENU wxMenuBar::Create()
 631 {
 632     wxCHECK_MSG( !m_hMenu, TRUE, "menubar already created" );
 633
 634     m_hMenu = (WXHMENU)::CreateMenu();
 635
 636     if ( !m_hMenu )
 637     {
 638         wxLogLastError("CreateMenu");
 639     }
 640     else
 641     {
 642         for ( int i = 0; i < m_menuCount; i++ )
 643         {
 644             if ( !::AppendMenu((HMENU)m_hMenu, MF_POPUP | MF_STRING,
 645                                (UINT)m_menus[i]->GetHMenu(),
 646                                m_titles[i]) )
 647             {
 648                 wxLogLastError("AppendMenu");
 649             }
 650         }
 651     }
 652
 653     return m_hMenu;
 654 }
 655
 656 // ---------------------------------------------------------------------------
 657 // wxMenuBar functions forwarded to wxMenuItem
 658 // ---------------------------------------------------------------------------
 659
 660 // Must only be used AFTER menu has been attached to frame,
 661 // otherwise use individual menus to enable/disable items
 662 void wxMenuBar::Enable(int id, bool enable)
 663 {
 664     wxMenu *itemMenu = NULL;
 665     wxMenuItem *item = FindItemForId(id, &itemMenu) ;
 666
 667     wxCHECK_RET( item, "attempt to enable an item which doesn't exist" );
 668
 669     item->Enable(enable);
 670 }
 671
 672 void wxMenuBar::EnableTop(int pos, bool enable)
 673 {
 674     int flag = enable ? MF_ENABLED : MF_GRAYED;;
 675
 676     EnableMenuItem((HMENU)m_hMenu, pos, MF_BYPOSITION | flag);
 677 }
 678
 679 // Must only be used AFTER menu has been attached to frame,
 680 // otherwise use individual menus
 681 void wxMenuBar::Check(int id, bool check)
 682 {
 683     wxMenu *itemMenu = NULL;
 684     wxMenuItem *item = FindItemForId(id, &itemMenu) ;
 685
 686     wxCHECK_RET( item, "attempt to check an item which doesn't exist" );
 687     wxCHECK_RET( item->IsCheckable(), "attempt to check an uncheckable item" );
 688
 689     item->Check(check);
 690 }
 691
 692 bool wxMenuBar::IsChecked(int id) const
 693 {
 694     wxMenu *itemMenu = NULL;
 695     wxMenuItem *item = FindItemForId(id, &itemMenu) ;
 696
 697     wxCHECK_MSG( item, FALSE, "wxMenuBar::IsChecked(): no such item" );
 698
 699     int flag = ::GetMenuState(GetHMenuOf(itemMenu), id, MF_BYCOMMAND);
 700
 701     return (flag & MF_CHECKED) != 0;
 702 }
 703
 704 bool wxMenuBar::IsEnabled(int id) const
 705 {
 706     wxMenu *itemMenu = NULL;
 707     wxMenuItem *item = FindItemForId(id, &itemMenu) ;
 708
 709     wxCHECK_MSG( item, FALSE, "wxMenuBar::IsEnabled(): no such item" );
 710
 711     int flag = ::GetMenuState(GetHMenuOf(itemMenu), id, MF_BYCOMMAND) ;
 712
 713     return (flag & MF_ENABLED) != 0;
 714 }
 715
 716 void wxMenuBar::SetLabel(int id, const wxString& label)
 717 {
 718     wxMenu *itemMenu = NULL;
 719     wxMenuItem *item = FindItemForId(id, &itemMenu) ;
 720
 721     wxCHECK_RET( item, "wxMenuBar::SetLabel(): no such item" );
 722
 723     item->SetName(label);
 724 }
 725
 726 wxString wxMenuBar::GetLabel(int id) const
 727 {
 728     wxMenu *itemMenu = NULL;
 729     wxMenuItem *item = FindItemForId(id, &itemMenu) ;
 730
 731     wxCHECK_MSG( item, "", "wxMenuBar::GetLabel(): no such item" );
 732
 733     return item->GetName();
 734 }
 735
 736 void wxMenuBar::SetHelpString (int id, const wxString& helpString)
 737 {
 738     wxMenu *itemMenu = NULL;
 739     wxMenuItem *item = FindItemForId(id, &itemMenu) ;
 740
 741     wxCHECK_RET( item, "wxMenuBar::SetHelpString(): no such item" );
 742
 743     item->SetHelp(helpString);
 744 }
 745
 746 wxString wxMenuBar::GetHelpString (int id) const
 747 {
 748     wxMenu *itemMenu = NULL;
 749     wxMenuItem *item = FindItemForId(id, &itemMenu) ;
 750
 751     wxCHECK_MSG( item, "", "wxMenuBar::GetHelpString(): no such item" );
 752
 753     return item->GetHelp();
 754 }
 755
 756 // ---------------------------------------------------------------------------
 757 // wxMenuBar functions to work with the top level submenus
 758 // ---------------------------------------------------------------------------
 759
 760 // NB: we don't support owner drawn top level items for now, if we do these
 761 //     functions would have to be changed to use wxMenuItem as well
 762
 763 void wxMenuBar::SetLabelTop(int pos, const wxString& label)
 764 {
 765     UINT id;
 766     UINT flagsOld = ::GetMenuState((HMENU)m_hMenu, pos, MF_BYPOSITION);
 767     if ( flagsOld == 0xFFFFFFFF )
 768     {
 769         wxLogLastError("GetMenuState");
 770
 771         return;
 772     }
 773
 774     if ( flagsOld & MF_POPUP )
 775     {
 776         // HIBYTE contains the number of items in the submenu in this case
 777         flagsOld &= 0xff ;
 778         id = (UINT)::GetSubMenu((HMENU)m_hMenu, pos) ;
 779     }
 780     else
 781     {
 782         id = pos;
 783     }
 784
 785     if ( ::ModifyMenu(GetHMENU(), pos, MF_BYPOSITION | MF_STRING | flagsOld,
 786                       id, label) == 0xFFFFFFFF )
 787     {
 788         wxLogLastError("ModifyMenu");
 789     }
 790 }
 791
 792 wxString wxMenuBar::GetLabelTop(int pos) const
 793 {
 794     int len = ::GetMenuString((HMENU)m_hMenu, pos, NULL, 0, MF_BYCOMMAND);
 795
 796     len++;  // for the NUL character
 797     wxString label;
 798     ::GetMenuString(GetHMENU(), pos, label.GetWriteBuf(len), len, MF_BYCOMMAND);
 799     label.UngetWriteBuf();
 800
 801     return label;
 802 }
 803
 804 // ---------------------------------------------------------------------------
 805 // wxMenuBar notifications
 806 // ---------------------------------------------------------------------------
 807
 808 bool wxMenuBar::OnDelete(wxMenu *a_menu, int pos)
 809 {
 810     if ( !m_menuBarFrame )
 811         return TRUE;
 812
 813     if ( ::RemoveMenu((HMENU)m_hMenu, (UINT)pos, MF_BYPOSITION) )
 814     {
 815         // VZ: I'm not sure about what's going on here, so I leave an assert
 816         wxASSERT_MSG( m_menus[pos] == a_menu, "what is this parameter for??" );
 817
 818         a_menu->Detach();
 819
 820         if ( m_menuBarFrame )
 821             Refresh();
 822
 823         return TRUE;
 824     }
 825     else
 826     {
 827         wxLogLastError("RemoveMenu");
 828     }
 829
 830     return FALSE;
 831 }
 832
 833 bool wxMenuBar::OnAppend(wxMenu *a_menu, const char *title)
 834 {
 835     WXHMENU submenu = a_menu->GetHMenu();
 836     if ( !submenu )
 837         return FALSE;
 838
 839     if ( !m_menuBarFrame )
 840         return TRUE;
 841
 842     a_menu->Attach(this);
 843
 844     if ( !::AppendMenu(GetHMENU(), MF_POPUP | MF_STRING,
 845                        (UINT)submenu, title) )
 846     {
 847         wxLogLastError("AppendMenu");
 848     }
 849
 850     Refresh();
 851
 852     return TRUE;
 853 }
 854
 855 // ---------------------------------------------------------------------------
 856 // wxMenuBar construction
 857 // ---------------------------------------------------------------------------
 858
 859 void wxMenuBar::Append (wxMenu * menu, const wxString& title)
 860 {
 861     if (!OnAppend(menu, title))
 862         return;
 863
 864     m_menuCount ++;
 865     wxMenu **new_menus = new wxMenu *[m_menuCount];
 866     wxString *new_titles = new wxString[m_menuCount];
 867     int i;
 868
 869     for (i = 0; i < m_menuCount - 1; i++)
 870     {
 871         new_menus[i] = m_menus[i];
 872         m_menus[i] = NULL;
 873         new_titles[i] = m_titles[i];
 874         m_titles[i] = "";
 875     }
 876     if (m_menus)
 877     {
 878         delete[]m_menus;
 879         delete[]m_titles;
 880     }
 881     m_menus = new_menus;
 882     m_titles = new_titles;
 883
 884     m_menus[m_menuCount - 1] = (wxMenu *)menu;
 885     m_titles[m_menuCount - 1] = title;
 886
 887     menu->SetParent(this);
 888 }
 889
 890 void wxMenuBar::Delete(wxMenu * menu, int i)
 891 {
 892     int j;
 893     int ii = (int) i;
 894
 895     if (menu != 0) {
 896         for (ii = 0; ii < m_menuCount; ii++) {
 897             if (m_menus[ii] == menu)
 898                 break;
 899         }
 900         if (ii >= m_menuCount)
 901             return;
 902     } else {
 903         if (ii < 0 || ii >= m_menuCount)
 904             return;
 905         menu = m_menus[ii];
 906     }
 907
 908     if (!OnDelete(menu, ii))
 909         return;
 910
 911     menu->SetParent(NULL);
 912
 913     -- m_menuCount;
 914     for (j = ii; j < m_menuCount; j++) {
 915         m_menus[j] = m_menus[j + 1];
 916         m_titles[j] = m_titles[j + 1];
 917     }
 918 }
 919
 920 // ---------------------------------------------------------------------------
 921 // wxMenuBar searching for menu items
 922 // ---------------------------------------------------------------------------
 923
 924 // Find the itemString in menuString, and return the item id or wxNOT_FOUND
 925 int wxMenuBar::FindMenuItem(const wxString& menuString,
 926                             const wxString& itemString) const
 927 {
 928     wxString menuLabel = wxStripMenuCodes(menuString);
 929     for ( int i = 0; i < m_menuCount; i++ )
 930     {
 931         wxString title = wxStripMenuCodes(m_titles[i]);
 932         if ( menuString == title )
 933             return m_menus[i]->FindItem(itemString);
 934     }
 935
 936     return wxNOT_FOUND;
 937 }
 938
 939 wxMenuItem *wxMenuBar::FindItemForId (int id, wxMenu **itemMenu) const
 940 {
 941     if ( itemMenu )
 942         *itemMenu = NULL;
 943
 944     wxMenuItem *item = NULL;
 945     for ( int i = 0; !item && (i < m_menuCount); i++ )
 946     {
 947         item = m_menus[i]->FindItemForId(id, itemMenu);
 948     }
 949
 950     return item;
 951 }
 952
 953
 954 // ----------------------------------------------------------------------------
 955 // helper functions
 956 // ----------------------------------------------------------------------------
 957
 958 wxWindow *wxMenu::GetWindow() const
 959 {
 960     if ( m_pInvokingWindow != NULL )
 961         return m_pInvokingWindow;
 962     else if ( m_menuBar != NULL)
 963         return m_menuBar->GetFrame();
 964
 965     return NULL;
 966 }
 967
 968 WXHMENU wxMenu::GetHMenu() const
 969 {
 970     if ( m_hMenu != 0 )
 971         return m_hMenu;
 972     else if ( m_savehMenu != 0 )
 973         return m_savehMenu;
 974
 975     wxFAIL_MSG("wxMenu without HMENU");
 976
 977     return 0;
 978 }
 979
 980 // Update a menu and all submenus recursively. source is the object that has
 981 // the update event handlers defined for it. If NULL, the menu or associated
 982 // window will be used.
 983 void wxMenu::UpdateUI(wxEvtHandler* source)
 984 {
 985     if (!source && GetInvokingWindow())
 986         source = GetInvokingWindow()->GetEventHandler();
 987     if (!source)
 988         source = GetEventHandler();
 989     if (!source)
 990         source = this;
 991
 992     wxNode* node = GetItems().First();
 993     while (node)
 994     {
 995         wxMenuItem* item = (wxMenuItem*) node->Data();
 996         if ( !item->IsSeparator() )
 997         {
 998             wxWindowID id = item->GetId();
 999             wxUpdateUIEvent event(id);
1000             event.SetEventObject( source );
1001
1002             if (source->ProcessEvent(event))
1003             {
1004                 if (event.GetSetText())
1005                     SetLabel(id, event.GetText());
1006                 if (event.GetSetChecked())
1007                     Check(id, event.GetChecked());
1008                 if (event.GetSetEnabled())
1009                     Enable(id, event.GetEnabled());
1010             }
1011
1012             if (item->GetSubMenu())
1013                 item->GetSubMenu()->UpdateUI(source);
1014         }
1015         node = node->Next();
1016     }
1017 }