interface/menu.h

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        menu.h
   3 // Purpose:     interface of wxMenuBar
   4 // Author:      wxWidgets team
   5 // RCS-ID:      $Id$
   6 // Licence:     wxWindows license
   7 /////////////////////////////////////////////////////////////////////////////
   8
   9 /**
  10     @class wxMenuBar
  11     @wxheader{menu.h}
  12
  13     A menu bar is a series of menus accessible from the top of a frame.
  14
  15     @library{wxcore}
  16     @category{menus}
  17
  18     @see wxMenu, @ref overview_eventhandlingoverview
  19 */
  20 class wxMenuBar : public wxWindow
  21 {
  22 public:
  23     /**
  24         Construct an empty menu barM
  25
  26         @param style
  27             If wxMB_DOCKABLE the menu bar can be detached (wxGTK only).
  28     */
  29     wxMenuBar(long style = 0);
  30
  31     /**
  32         Construct a menu bar from arrays of menus and titles.
  33
  34         @param n
  35             The number of menus.
  36         @param menus
  37             An array of menus. Do not use this array again - it now belongs to
  38             the menu bar.
  39         @param titles
  40             An array of title strings. Deallocate this array after creating
  41             the menu bar.
  42         @param style
  43             If wxMB_DOCKABLE the menu bar can be detached (wxGTK only).
  44     */
  45     wxMenuBar(size_t n, wxMenu* menus[], const wxString titles[],
  46               long style = 0);
  47
  48     /**
  49         Destructor, destroying the menu bar and removing it from the parent frame (if
  50         any).
  51     */
  52     ~wxMenuBar();
  53
  54     /**
  55         Adds the item to the end of the menu bar.
  56
  57         @param menu
  58             The menu to add. Do not deallocate this menu after calling Append.
  59         @param title
  60             The title of the menu.
  61
  62         @return @true on success, @false if an error occurred.
  63
  64         @see Insert()
  65     */
  66     bool Append(wxMenu* menu, const wxString& title);
  67
  68     /**
  69         Checks or unchecks a menu item.
  70
  71         @param id
  72             The menu item identifier.
  73         @param check
  74             If @true, checks the menu item, otherwise the item is unchecked.
  75
  76         @remarks Only use this when the menu bar has been associated with a
  77                  frame; otherwise, use the wxMenu equivalent call.
  78     */
  79     void Check(int id, const bool check);
  80
  81     /**
  82         Enables or disables (greys out) a menu item.
  83
  84         @param id
  85             The menu item identifier.
  86         @param enable
  87             @true to enable the item, @false to disable it.
  88
  89         @remarks Only use this when the menu bar has been associated with a
  90                  frame; otherwise, use the wxMenu equivalent call.
  91     */
  92     void Enable(int id, const bool enable);
  93
  94     /**
  95         Enables or disables a whole menu.
  96
  97         @param pos
  98             The position of the menu, starting from zero.
  99         @param enable
 100             @true to enable the menu, @false to disable it.
 101
 102         @remarks Only use this when the menu bar has been associated with a frame.
 103     */
 104     void EnableTop(int pos, const bool enable);
 105
 106     /**
 107         Finds the menu item object associated with the given menu item identifier.
 108
 109         @param id
 110             Menu item identifier.
 111         @param menu
 112             If not @NULL, menu will get set to the associated menu.
 113
 114         @return The found menu item object, or @NULL if one was not found.
 115     */
 116     wxMenuItem* FindItem(int id, wxMenu menu = NULL) const;
 117
 118     /**
 119         Returns the index of the menu with the given @a title or @c wxNOT_FOUND if no
 120         such menu exists in this menubar. The @a title parameter may specify either
 121         the menu title (with accelerator characters, i.e. @c "File") or just the
 122         menu label (@c "File") indifferently.
 123     */
 124     int FindMenu(const wxString& title) const;
 125
 126     /**
 127         Finds the menu item id for a menu name/menu item string pair.
 128
 129         @param menuString
 130             Menu title to find.
 131         @param itemString
 132             Item to find.
 133
 134         @return The menu item identifier, or wxNOT_FOUND if none was found.
 135
 136         @remarks Any special menu codes are stripped out of source and target
 137                  strings before matching.
 138     */
 139     int FindMenuItem(const wxString& menuString,
 140                      const wxString& itemString) const;
 141
 142     /**
 143         Gets the help string associated with the menu item identifier.
 144
 145         @param id
 146             The menu item identifier.
 147
 148         @return The help string, or the empty string if there was no help string
 149                 or the menu item was not found.
 150
 151         @see SetHelpString()
 152     */
 153     wxString GetHelpString(int id) const;
 154
 155     /**
 156         Gets the label associated with a menu item.
 157
 158         @param id
 159             The menu item identifier.
 160
 161         @return The menu item label, or the empty string if the item was not
 162                 found.
 163
 164         @remarks Use only after the menubar has been associated with a frame.
 165     */
 166     wxString GetLabel(int id) const;
 167
 168     /**
 169         Returns the label of a top-level menu. Note that the returned string does not
 170         include the accelerator characters which could have been specified in the menu
 171         title string during its construction.
 172
 173         @param pos
 174             Position of the menu on the menu bar, starting from zero.
 175
 176         @return The menu label, or the empty string if the menu was not found.
 177
 178         @remarks Use only after the menubar has been associated with a frame.
 179
 180         @see SetLabelTop()
 181     */
 182     wxString GetLabelTop(int pos) const;
 183
 184     /**
 185         Returns the menu at @a menuIndex (zero-based).
 186     */
 187     wxMenu* GetMenu(int menuIndex) const;
 188
 189     /**
 190         Returns the number of menus in this menubar.
 191     */
 192     size_t GetMenuCount() const;
 193
 194     /**
 195         Returns the label of a top-level menu. Note that the returned string
 196         includes the accelerator characters that have been specified in the menu
 197         title string during its construction.
 198
 199         @param pos
 200             Position of the menu on the menu bar, starting from zero.
 201
 202         @return The menu label, or the empty string if the menu was not found.
 203
 204         @remarks Use only after the menubar has been associated with a frame.
 205
 206         @see GetMenuLabelText(), SetMenuLabel()
 207     */
 208     wxString GetMenuLabel(int pos) const;
 209
 210     /**
 211         Returns the label of a top-level menu. Note that the returned string does not
 212         include any accelerator characters that may have been specified in the menu
 213         title string during its construction.
 214
 215         @param pos
 216             Position of the menu on the menu bar, starting from zero.
 217
 218         @return The menu label, or the empty string if the menu was not found.
 219
 220         @remarks Use only after the menubar has been associated with a frame.
 221
 222         @see GetMenuLabel(), SetMenuLabel()
 223     */
 224     wxString GetMenuLabelText(int pos) const;
 225
 226     /**
 227         Inserts the menu at the given position into the menu bar. Inserting menu at
 228         position 0 will insert it in the very beginning of it, inserting at position
 229         GetMenuCount() is the same as calling
 230         Append().
 231
 232         @param pos
 233             The position of the new menu in the menu bar
 234         @param menu
 235             The menu to add. wxMenuBar owns the menu and will free it.
 236         @param title
 237             The title of the menu.
 238
 239         @return @true on success, @false if an error occurred.
 240
 241         @see Append()
 242     */
 243     bool Insert(size_t pos, wxMenu* menu, const wxString& title);
 244
 245     /**
 246         Determines whether an item is checked.
 247
 248         @param id
 249             The menu item identifier.
 250
 251         @return @true if the item was found and is checked, @false otherwise.
 252     */
 253     bool IsChecked(int id) const;
 254
 255     /**
 256         Determines whether an item is enabled.
 257
 258         @param id
 259             The menu item identifier.
 260
 261         @return @true if the item was found and is enabled, @false otherwise.
 262     */
 263     bool IsEnabled(int id) const;
 264
 265     /**
 266         Redraw the menu bar
 267     */
 268     void Refresh();
 269
 270     /**
 271         Removes the menu from the menu bar and returns the menu object - the caller is
 272         responsible for deleting it. This function may be used together with
 273         Insert() to change the menubar
 274         dynamically.
 275
 276         @see Replace()
 277     */
 278     wxMenu* Remove(size_t pos);
 279
 280     /**
 281         Replaces the menu at the given position with another one.
 282
 283         @param pos
 284             The position of the new menu in the menu bar
 285         @param menu
 286             The menu to add.
 287         @param title
 288             The title of the menu.
 289
 290         @return The menu which was previously at position pos. The caller is
 291                 responsible for deleting it.
 292
 293         @see Insert(), Remove()
 294     */
 295     wxMenu* Replace(size_t pos, wxMenu* menu, const wxString& title);
 296
 297     /**
 298         Sets the help string associated with a menu item.
 299
 300         @param id
 301             Menu item identifier.
 302         @param helpString
 303             Help string to associate with the menu item.
 304
 305         @see GetHelpString()
 306     */
 307     void SetHelpString(int id, const wxString& helpString);
 308
 309     /**
 310         Sets the label of a menu item.
 311
 312         @param id
 313             Menu item identifier.
 314         @param label
 315             Menu item label.
 316
 317         @remarks Use only after the menubar has been associated with a frame.
 318
 319         @see GetLabel()
 320     */
 321     void SetLabel(int id, const wxString& label);
 322
 323     /**
 324         Sets the label of a top-level menu.
 325
 326         @param pos
 327             The position of a menu on the menu bar, starting from zero.
 328         @param label
 329             The menu label.
 330
 331         @remarks Use only after the menubar has been associated with a frame.
 332
 333         @see GetLabelTop()
 334     */
 335     void SetLabelTop(int pos, const wxString& label);
 336
 337     /**
 338         Sets the label of a top-level menu.
 339
 340         @param pos
 341             The position of a menu on the menu bar, starting from zero.
 342         @param label
 343             The menu label.
 344
 345         @remarks Use only after the menubar has been associated with a frame.
 346     */
 347     void SetMenuLabel(int pos, const wxString& label);
 348 };
 349
 350
 351
 352 /**
 353     @class wxMenu
 354     @wxheader{menu.h}
 355
 356     A menu is a popup (or pull down) list of items, one of which may be
 357     selected before the menu goes away (clicking elsewhere dismisses the
 358     menu). Menus may be used to construct either menu bars or popup menus.
 359
 360     A menu item has an integer ID associated with it which can be used to
 361     identify the selection, or to change the menu item in some way. A menu item
 362     with a special identifier -1 is a separator item and doesn't have an
 363     associated command but just makes a separator line appear in the menu.
 364
 365     @note Please note that @e wxID_ABOUT and @e wxID_EXIT are
 366     predefined by wxWidgets and have a special meaning since entries
 367     using these IDs will be taken out of the normal menus under MacOS X
 368     and will be inserted into the system menu (following the appropriate
 369     MacOS X interface guideline). On PalmOS @e wxID_EXIT is disabled according
 370     to Palm OS Companion guidelines.
 371
 372     Menu items may be either normal items, check items or radio items. Normal items
 373     don't have any special properties while the check items have a boolean flag
 374     associated to them and they show a checkmark in the menu when the flag is set.
 375     wxWidgets automatically toggles the flag value when the item is clicked and its
 376     value may be retrieved using either wxMenu::IsChecked method
 377     of wxMenu or wxMenuBar itself or by using
 378     wxEvent::IsChecked when you get the menu
 379     notification for the item in question.
 380
 381     The radio items are similar to the check items except that all the other items
 382     in the same radio group are unchecked when a radio item is checked. The radio
 383     group is formed by a contiguous range of radio items, i.e. it starts at the
 384     first item of this kind and ends with the first item of a different kind (or
 385     the end of the menu). Notice that because the radio groups are defined in terms
 386     of the item positions inserting or removing the items in the menu containing
 387     the radio items risks to not work correctly. Finally note that radio items
 388     are not supported under Motif.
 389
 390     @library{wxcore}
 391     @category{menus}
 392
 393     @see wxMenuBar, wxWindow::PopupMenu, @ref overview_eventhandlingoverview, @ref
 394     overview_wxfilehistory "wxFileHistory (most recently used files menu)"
 395 */
 396 class wxMenu : public wxEvtHandler
 397 {
 398 public:
 399     /**
 400         Constructs a wxMenu object.
 401
 402         @param style
 403             If set to wxMENU_TEAROFF, the menu will be detachable (wxGTK only).
 404     */
 405     wxMenu(long style);
 406
 407     /**
 408         Constructs a wxMenu object with a title
 409
 410         @param title
 411             Title at the top of the menu (not always supported).
 412         @param style
 413             If set to wxMENU_TEAROFF, the menu will be detachable (wxGTK only).
 414     */
 415     wxMenu(const wxString& title = "", long style = 0);
 416
 417     /**
 418         Destructor, destroying the menu.
 419         Note: under Motif, a popup menu must have a valid parent (the window
 420         it was last popped up on) when being destroyed. Therefore, make sure
 421         you delete or re-use the popup menu @e before destroying the
 422         parent window. Re-use in this context means popping up the menu on
 423         a different window from last time, which causes an implicit destruction
 424         and recreation of internal data structures.
 425     */
 426     ~wxMenu();
 427
 428     /**
 429         Adds a menu item.
 430
 431         @param id
 432             The menu command identifier.
 433         @param item
 434             The string to appear on the menu item.
 435         @param kind
 436             May be wxITEM_SEPARATOR, wxITEM_NORMAL,
 437             wxITEM_CHECK or wxITEM_RADIO
 438         @param helpString
 439             An optional help string associated with the item.
 440             By default, the handler for the wxEVT_MENU_HIGHLIGHT event displays
 441             this string in the status line.
 442
 443         @see AppendSeparator(), AppendCheckItem(), AppendRadioItem(),
 444              AppendSubMenu(), Insert(), SetLabel(),
 445              GetHelpString(), SetHelpString(), wxMenuItem
 446     */
 447     wxMenuItem* Append(int id, const wxString& item = "",
 448                        const wxString& helpString = "",
 449                        wxItemKind kind = wxITEM_NORMAL);
 450
 451     /**
 452         Adds a submenu.
 453
 454         @param id
 455             The menu command identifier.
 456         @param item
 457             The string to appear on the menu item.
 458         @param menu
 459             Pull-right submenu.
 460         @param helpString
 461             An optional help string associated with the item.
 462             By default, the handler for the wxEVT_MENU_HIGHLIGHT event displays
 463             this string in the status line.
 464
 465         @see AppendSeparator(), AppendCheckItem(), AppendRadioItem(),
 466              AppendSubMenu(), Insert(), SetLabel(),
 467              GetHelpString(), SetHelpString(), wxMenuItem
 468     */
 469     wxMenuItem* Append(int id, const wxString& item,
 470                        wxMenu* subMenu,
 471                        const wxString& helpString = "");
 472
 473     /**
 474         Adds a menu item object. This is the most generic variant of Append() method
 475         because it may be used for both items (including separators) and submenus and
 476         because you can also specify various extra properties of a menu item this way,
 477         such as bitmaps and fonts.
 478
 479         @param menuItem
 480             A menuitem object. It will be owned by the wxMenu object after this function
 481             is called, so do not delete it yourself.
 482
 483         @see AppendSeparator(), AppendCheckItem(), AppendRadioItem(),
 484              AppendSubMenu(), Insert(), SetLabel(),
 485              GetHelpString(), SetHelpString(), wxMenuItem
 486     */
 487     wxMenuItem* Append(wxMenuItem* menuItem);
 488
 489     /**
 490         Adds a checkable item to the end of the menu.
 491
 492         @see Append(), InsertCheckItem()
 493     */
 494     wxMenuItem* AppendCheckItem(int id, const wxString& item,
 495                                 const wxString& helpString = "");
 496
 497     /**
 498         Adds a radio item to the end of the menu. All consequent radio items form a
 499         group and when an item in the group is checked, all the others are
 500         automatically unchecked.
 501
 502         @see Append(), InsertRadioItem()
 503     */
 504     wxMenuItem* AppendRadioItem(int id, const wxString& item,
 505                                 const wxString& helpString = "");
 506
 507     /**
 508         Adds a separator to the end of the menu.
 509
 510         @see Append(), InsertSeparator()
 511     */
 512     wxMenuItem* AppendSeparator();
 513
 514     /**
 515         Adds the given @a submenu to this menu. @a text is the text shown in the
 516         menu for it and @a help is the help string shown in the status bar when the
 517         submenu item is selected.
 518     */
 519     wxMenuItem* AppendSubMenu(wxMenu* submenu, const wxString& text,
 520                               const wxString& help = wxEmptyString);
 521
 522     /**
 523         Inserts a break in a menu, causing the next appended item to appear in a new
 524         column.
 525     */
 526     void Break();
 527
 528     /**
 529         Checks or unchecks the menu item.
 530
 531         @param id
 532             The menu item identifier.
 533         @param check
 534             If @true, the item will be checked, otherwise it will be unchecked.
 535
 536         @see IsChecked()
 537     */
 538     void Check(int id, const bool check);
 539
 540     /**
 541         Deletes the menu item from the menu. If the item is a submenu, it will
 542         @b not be deleted. Use Destroy() if you want to delete a submenu.
 543
 544         @param id
 545             Id of the menu item to be deleted.
 546
 547         @see FindItem(), Destroy(), Remove()
 548     */
 549     void Delete(int id);
 550
 551     /**
 552         Deletes the menu item from the menu. If the item is a submenu, it will
 553         @b not be deleted. Use Destroy() if you want to delete a submenu.
 554
 555         @param item
 556             Menu item to be deleted.
 557
 558         @see FindItem(), Destroy(), Remove()
 559     */
 560     void Delete(wxMenuItem* item);
 561
 562     /**
 563         Deletes the menu item from the menu. If the item is a submenu, it will
 564         be deleted. Use Remove() if you want to keep the submenu (for example,
 565         to reuse it later).
 566
 567         @param id
 568             Id of the menu item to be deleted.
 569
 570         @see FindItem(), Deletes(), Remove()
 571     */
 572     void Destroy(int id);
 573
 574     /**
 575         Deletes the menu item from the menu. If the item is a submenu, it will
 576         be deleted. Use Remove() if you want to keep the submenu (for example,
 577         to reuse it later).
 578
 579         @param item
 580             Menu item to be deleted.
 581
 582         @see FindItem(), Deletes(), Remove()
 583     */
 584     void Destroy(wxMenuItem* item);
 585
 586     /**
 587         Enables or disables (greys out) a menu item.
 588
 589         @param id
 590             The menu item identifier.
 591         @param enable
 592             @true to enable the menu item, @false to disable it.
 593
 594         @see IsEnabled()
 595     */
 596     void Enable(int id, const bool enable);
 597
 598     /**
 599         Finds the menu id for a menu item string.
 600
 601         @param itemString
 602             Menu item string to find.
 603
 604         @return Menu item identifier, or wxNOT_FOUND if none is found.
 605
 606         @remarks Any special menu codes are stripped out of source and target
 607                  strings before matching.
 608     */
 609     int FindItem(const wxString& itemString) const;
 610
 611     /**
 612         Finds the menu item object associated with the given menu item identifier and,
 613         optionally, the (sub)menu it belongs to.
 614
 615         @param id
 616             Menu item identifier.
 617         @param menu
 618             If the pointer is not @NULL, it will be filled with the item's
 619             parent menu (if the item was found)
 620
 621         @return Menu item object or NULL if none is found.
 622     */
 623     const wxMenuItem *  FindItem(int id, wxMenu** menu = NULL) const;
 624
 625     /**
 626         Returns the wxMenuItem given a position in the menu.
 627     */
 628     wxMenuItem* FindItemByPosition(size_t position) const;
 629
 630     /**
 631         Returns the help string associated with a menu item.
 632
 633         @param id
 634             The menu item identifier.
 635
 636         @return The help string, or the empty string if there is no help string
 637                 or the item was not found.
 638
 639         @see SetHelpString(), Append()
 640     */
 641     wxString GetHelpString(int id) const;
 642
 643     /**
 644         Returns a menu item label.
 645
 646         @param id
 647             The menu item identifier.
 648
 649         @return The item label, or the empty string if the item was not found.
 650
 651         @see GetLabelText(), SetLabel()
 652     */
 653     wxString GetLabel(int id) const;
 654
 655     /**
 656         Returns a menu item label, without any of the original mnemonics and
 657         accelerators.
 658
 659         @param id
 660             The menu item identifier.
 661
 662         @return The item label, or the empty string if the item was not found.
 663
 664         @see GetLabel(), SetLabel()
 665     */
 666     wxString GetLabelText(int id) const;
 667
 668     /**
 669         Returns the number of items in the menu.
 670     */
 671     size_t GetMenuItemCount() const;
 672
 673     /**
 674         Returns the list of items in the menu. wxMenuItemList is a pseudo-template
 675         list class containing wxMenuItem pointers, see wxList.
 676     */
 677     wxMenuItemList GetMenuItems() const;
 678
 679     /**
 680         Returns the title of the menu.
 681
 682         @remarks This is relevant only to popup menus, use
 683                  wxMenuBar::GetMenuLabel for the menus in the menubar.
 684
 685         @see SetTitle()
 686     */
 687     wxString GetTitle() const;
 688
 689     /**
 690         Inserts the given @a item before the position @e pos. Inserting the item
 691         at position GetMenuItemCount() is the same
 692         as appending it.
 693
 694         @see Append(), Prepend()
 695     */
 696     wxMenuItem* Insert(size_t pos, wxMenuItem* item);
 697
 698     /**
 699         Inserts the given @a item before the position @e pos. Inserting the item
 700         at position GetMenuItemCount() is the same
 701         as appending it.
 702
 703         @see Append(), Prepend()
 704     */
 705     wxMenuItem* Insert(size_t pos, int id,
 706                        const wxString& item = "",
 707                        const wxString& helpString = "",
 708                        wxItemKind kind = wxITEM_NORMAL);
 709
 710     /**
 711         Inserts a checkable item at the given position.
 712
 713         @see Insert(), AppendCheckItem()
 714     */
 715     wxMenuItem* InsertCheckItem(size_t pos, int id,
 716                                 const wxString& item,
 717                                 const wxString& helpString = "");
 718
 719     /**
 720         Inserts a radio item at the given position.
 721
 722         @see Insert(), AppendRadioItem()
 723     */
 724     wxMenuItem* InsertRadioItem(size_t pos, int id,
 725                                 const wxString& item,
 726                                 const wxString& helpString = "");
 727
 728     /**
 729         Inserts a separator at the given position.
 730
 731         @see Insert(), AppendSeparator()
 732     */
 733     wxMenuItem* InsertSeparator(size_t pos);
 734
 735     /**
 736         Determines whether a menu item is checked.
 737
 738         @param id
 739             The menu item identifier.
 740
 741         @return @true if the menu item is checked, @false otherwise.
 742
 743         @see Check()
 744     */
 745     bool IsChecked(int id) const;
 746
 747     /**
 748         Determines whether a menu item is enabled.
 749
 750         @param id
 751             The menu item identifier.
 752
 753         @return @true if the menu item is enabled, @false otherwise.
 754
 755         @see Enable()
 756     */
 757     bool IsEnabled(int id) const;
 758
 759     /**
 760         Inserts the given @a item at position 0, i.e. before all the other
 761         existing items.
 762
 763         @see Append(), Insert()
 764     */
 765     wxMenuItem* Prepend(wxMenuItem* item);
 766
 767     /**
 768         Inserts the given @a item at position 0, i.e. before all the other
 769         existing items.
 770
 771         @see Append(), Insert()
 772     */
 773     wxMenuItem* Prepend(int id, const wxString& item = "",
 774                         const wxString& helpString = "",
 775                         wxItemKind kind = wxITEM_NORMAL);
 776
 777     /**
 778         Inserts a checkable item at position 0.
 779
 780         @see Prepend(), AppendCheckItem()
 781     */
 782     wxMenuItem* PrependCheckItem(int id, const wxString& item,
 783                                  const wxString& helpString = "");
 784
 785     /**
 786         Inserts a radio item at position 0.
 787
 788         @see Prepend(), AppendRadioItem()
 789     */
 790     wxMenuItem* PrependRadioItem(int id, const wxString& item,
 791                                  const wxString& helpString = "");
 792
 793     /**
 794         Inserts a separator at position 0.
 795
 796         @see Prepend(), AppendSeparator()
 797     */
 798     wxMenuItem* PrependSeparator();
 799
 800     /**
 801         Removes the menu item from the menu but doesn't delete the associated C++
 802         object. This allows to reuse the same item later by adding it back to the menu
 803         (especially useful with submenus).
 804
 805         @param id
 806             The identifier of the menu item to remove.
 807
 808         @return The item which was detached from the menu.
 809     */
 810     wxMenuItem* Remove(int id);
 811
 812     /**
 813         Removes the menu item from the menu but doesn't delete the associated C++
 814         object. This allows to reuse the same item later by adding it back to the menu
 815         (especially useful with submenus).
 816
 817         @param item
 818             The menu item to remove.
 819
 820         @return The item which was detached from the menu.
 821     */
 822     wxMenuItem* Remove(wxMenuItem* item);
 823
 824     /**
 825         Sets an item's help string.
 826
 827         @param id
 828             The menu item identifier.
 829         @param helpString
 830             The help string to set.
 831
 832         @see GetHelpString()
 833     */
 834     void SetHelpString(int id, const wxString& helpString);
 835
 836     /**
 837         Sets the label of a menu item.
 838
 839         @param id
 840             The menu item identifier.
 841         @param label
 842             The menu item label to set.
 843
 844         @see Append(), GetLabel()
 845     */
 846     void SetLabel(int id, const wxString& label);
 847
 848     /**
 849         Sets the title of the menu.
 850
 851         @param title
 852             The title to set.
 853
 854         @remarks This is relevant only to popup menus, use
 855                  wxMenuBar::SetLabelTop for the menus in the menubar.
 856
 857         @see GetTitle()
 858     */
 859     void SetTitle(const wxString& title);
 860
 861     /**
 862         Sends events to @a source (or owning window if @NULL) to update the
 863         menu UI. This is called just before the menu is popped up with
 864         wxWindow::PopupMenu, but
 865         the application may call it at other times if required.
 866     */
 867     void UpdateUI(wxEvtHandler* source = NULL) const;
 868 };
 869