src/common/framecmn.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/common/framecmn.cpp
   3 // Purpose:     common (for all platforms) wxFrame functions
   4 // Author:      Julian Smart, Vadim Zeitlin
   5 // Created:     01/02/97
   6 // Id:          $Id$
   7 // Copyright:   (c) 1998 Robert Roebling and Julian Smart
   8 // Licence:     wxWindows licence
   9 /////////////////////////////////////////////////////////////////////////////
  10
  11 // ============================================================================
  12 // declarations
  13 // ============================================================================
  14
  15 // ----------------------------------------------------------------------------
  16 // headers
  17 // ----------------------------------------------------------------------------
  18
  19 // For compilers that support precompilation, includes "wx.h".
  20 #include "wx/wxprec.h"
  21
  22 #ifdef __BORLANDC__
  23     #pragma hdrstop
  24 #endif
  25
  26 #include "wx/frame.h"
  27
  28 #ifndef WX_PRECOMP
  29     #include "wx/menu.h"
  30     #include "wx/menuitem.h"
  31     #include "wx/dcclient.h"
  32     #include "wx/toolbar.h"
  33     #include "wx/statusbr.h"
  34 #endif // WX_PRECOMP
  35
  36 extern WXDLLEXPORT_DATA(const char) wxFrameNameStr[] = "frame";
  37 extern WXDLLEXPORT_DATA(const char) wxStatusLineNameStr[] = "status_line";
  38
  39 // ----------------------------------------------------------------------------
  40 // event table
  41 // ----------------------------------------------------------------------------
  42
  43 #if wxUSE_MENUS && wxUSE_STATUSBAR
  44
  45 BEGIN_EVENT_TABLE(wxFrameBase, wxTopLevelWindow)
  46     EVT_MENU_OPEN(wxFrameBase::OnMenuOpen)
  47     EVT_MENU_CLOSE(wxFrameBase::OnMenuClose)
  48
  49     EVT_MENU_HIGHLIGHT_ALL(wxFrameBase::OnMenuHighlight)
  50 END_EVENT_TABLE()
  51
  52 #endif // wxUSE_MENUS && wxUSE_STATUSBAR
  53
  54 // ============================================================================
  55 // implementation
  56 // ============================================================================
  57
  58 // ----------------------------------------------------------------------------
  59 // XTI
  60 // ----------------------------------------------------------------------------
  61
  62 wxDEFINE_FLAGS( wxFrameStyle )
  63 wxBEGIN_FLAGS( wxFrameStyle )
  64 // new style border flags, we put them first to
  65 // use them for streaming out
  66 wxFLAGS_MEMBER(wxBORDER_SIMPLE)
  67 wxFLAGS_MEMBER(wxBORDER_SUNKEN)
  68 wxFLAGS_MEMBER(wxBORDER_DOUBLE)
  69 wxFLAGS_MEMBER(wxBORDER_RAISED)
  70 wxFLAGS_MEMBER(wxBORDER_STATIC)
  71 wxFLAGS_MEMBER(wxBORDER_NONE)
  72
  73 // old style border flags
  74 wxFLAGS_MEMBER(wxSIMPLE_BORDER)
  75 wxFLAGS_MEMBER(wxSUNKEN_BORDER)
  76 wxFLAGS_MEMBER(wxDOUBLE_BORDER)
  77 wxFLAGS_MEMBER(wxRAISED_BORDER)
  78 wxFLAGS_MEMBER(wxSTATIC_BORDER)
  79 wxFLAGS_MEMBER(wxBORDER)
  80
  81 // standard window styles
  82 wxFLAGS_MEMBER(wxTAB_TRAVERSAL)
  83 wxFLAGS_MEMBER(wxCLIP_CHILDREN)
  84 wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW)
  85 wxFLAGS_MEMBER(wxWANTS_CHARS)
  86 wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE)
  87 wxFLAGS_MEMBER(wxALWAYS_SHOW_SB )
  88 wxFLAGS_MEMBER(wxVSCROLL)
  89 wxFLAGS_MEMBER(wxHSCROLL)
  90
  91 // frame styles
  92 wxFLAGS_MEMBER(wxSTAY_ON_TOP)
  93 wxFLAGS_MEMBER(wxCAPTION)
  94 #if WXWIN_COMPATIBILITY_2_6
  95 wxFLAGS_MEMBER(wxTHICK_FRAME)
  96 #endif // WXWIN_COMPATIBILITY_2_6
  97 wxFLAGS_MEMBER(wxSYSTEM_MENU)
  98 wxFLAGS_MEMBER(wxRESIZE_BORDER)
  99 #if WXWIN_COMPATIBILITY_2_6
 100 wxFLAGS_MEMBER(wxRESIZE_BOX)
 101 #endif // WXWIN_COMPATIBILITY_2_6
 102 wxFLAGS_MEMBER(wxCLOSE_BOX)
 103 wxFLAGS_MEMBER(wxMAXIMIZE_BOX)
 104 wxFLAGS_MEMBER(wxMINIMIZE_BOX)
 105
 106 wxFLAGS_MEMBER(wxFRAME_TOOL_WINDOW)
 107 wxFLAGS_MEMBER(wxFRAME_FLOAT_ON_PARENT)
 108
 109 wxFLAGS_MEMBER(wxFRAME_SHAPED)
 110 wxEND_FLAGS( wxFrameStyle )
 111
 112 wxIMPLEMENT_DYNAMIC_CLASS_XTI(wxFrame, wxTopLevelWindow, "wx/frame.h")
 113
 114 wxBEGIN_PROPERTIES_TABLE(wxFrame)
 115 wxEVENT_PROPERTY( Menu, wxEVT_COMMAND_MENU_SELECTED, wxCommandEvent)
 116
 117 wxPROPERTY( Title,wxString, SetTitle, GetTitle, wxString(), 0 /*flags*/, \
 118            wxT("Helpstring"), wxT("group"))
 119 wxPROPERTY_FLAGS( WindowStyle, wxFrameStyle, long, SetWindowStyleFlag, \
 120                  GetWindowStyleFlag, wxEMPTY_PARAMETER_VALUE, 0 /*flags*/, \
 121                  wxT("Helpstring"), wxT("group")) // style
 122 wxPROPERTY( MenuBar, wxMenuBar *, SetMenuBar, GetMenuBar, wxEMPTY_PARAMETER_VALUE, \
 123            0 /*flags*/, wxT("Helpstring"), wxT("group"))
 124 wxEND_PROPERTIES_TABLE()
 125
 126 wxEMPTY_HANDLERS_TABLE(wxFrame)
 127
 128 wxCONSTRUCTOR_6( wxFrame, wxWindow*, Parent, wxWindowID, Id, wxString, Title, \
 129                 wxPoint, Position, wxSize, Size, long, WindowStyle)
 130
 131 // ----------------------------------------------------------------------------
 132 // construction/destruction
 133 // ----------------------------------------------------------------------------
 134
 135 wxFrameBase::wxFrameBase()
 136 {
 137 #if wxUSE_MENUS
 138     m_frameMenuBar = NULL;
 139 #endif // wxUSE_MENUS
 140
 141 #if wxUSE_TOOLBAR
 142     m_frameToolBar = NULL;
 143 #endif // wxUSE_TOOLBAR
 144
 145 #if wxUSE_STATUSBAR
 146     m_frameStatusBar = NULL;
 147 #endif // wxUSE_STATUSBAR
 148
 149     m_statusBarPane = 0;
 150 }
 151
 152 wxFrameBase::~wxFrameBase()
 153 {
 154     // this destructor is required for Darwin
 155 }
 156
 157 wxFrame *wxFrameBase::New(wxWindow *parent,
 158                           wxWindowID id,
 159                           const wxString& title,
 160                           const wxPoint& pos,
 161                           const wxSize& size,
 162                           long style,
 163                           const wxString& name)
 164 {
 165     return new wxFrame(parent, id, title, pos, size, style, name);
 166 }
 167
 168 void wxFrameBase::DeleteAllBars()
 169 {
 170 #if wxUSE_MENUS
 171     wxDELETE(m_frameMenuBar);
 172 #endif // wxUSE_MENUS
 173
 174 #if wxUSE_STATUSBAR
 175     wxDELETE(m_frameStatusBar);
 176 #endif // wxUSE_STATUSBAR
 177
 178 #if wxUSE_TOOLBAR
 179     wxDELETE(m_frameToolBar);
 180 #endif // wxUSE_TOOLBAR
 181 }
 182
 183 bool wxFrameBase::IsOneOfBars(const wxWindow *win) const
 184 {
 185 #if wxUSE_MENUS
 186     if ( win == GetMenuBar() )
 187         return true;
 188 #endif // wxUSE_MENUS
 189
 190 #if wxUSE_STATUSBAR
 191     if ( win == GetStatusBar() )
 192         return true;
 193 #endif // wxUSE_STATUSBAR
 194
 195 #if wxUSE_TOOLBAR
 196     if ( win == GetToolBar() )
 197         return true;
 198 #endif // wxUSE_TOOLBAR
 199
 200     wxUnusedVar(win);
 201
 202     return false;
 203 }
 204
 205 // ----------------------------------------------------------------------------
 206 // wxFrame size management: we exclude the areas taken by menu/status/toolbars
 207 // from the client area, so the client area is what's really available for the
 208 // frame contents
 209 // ----------------------------------------------------------------------------
 210
 211 // get the origin of the client area in the client coordinates
 212 wxPoint wxFrameBase::GetClientAreaOrigin() const
 213 {
 214     wxPoint pt = wxTopLevelWindow::GetClientAreaOrigin();
 215
 216 #if wxUSE_TOOLBAR && !defined(__WXUNIVERSAL__)
 217     wxToolBar *toolbar = GetToolBar();
 218     if ( toolbar && toolbar->IsShown() )
 219     {
 220         int w, h;
 221         toolbar->GetSize(&w, &h);
 222
 223         if ( toolbar->GetWindowStyleFlag() & wxTB_VERTICAL )
 224         {
 225             pt.x += w;
 226         }
 227         else
 228         {
 229             pt.y += h;
 230         }
 231     }
 232 #endif // wxUSE_TOOLBAR
 233
 234     return pt;
 235 }
 236
 237 // ----------------------------------------------------------------------------
 238 // misc
 239 // ----------------------------------------------------------------------------
 240
 241 #if wxUSE_MENUS
 242
 243 bool wxFrameBase::ProcessCommand(int id)
 244 {
 245     wxMenuBar *bar = GetMenuBar();
 246     if ( !bar )
 247         return false;
 248
 249     wxMenuItem *item = bar->FindItem(id);
 250     if ( !item )
 251         return false;
 252
 253     return ProcessCommand(item);
 254 }
 255
 256 bool wxFrameBase::ProcessCommand(wxMenuItem *item)
 257 {
 258     wxCommandEvent commandEvent(wxEVT_COMMAND_MENU_SELECTED, item->GetId());
 259     commandEvent.SetEventObject(this);
 260
 261     if (!item->IsEnabled())
 262         return true;
 263
 264     if ((item->GetKind() == wxITEM_RADIO) && item->IsChecked() )
 265         return true;
 266
 267     if (item->IsCheckable())
 268     {
 269         item->Toggle();
 270
 271         // use the new value
 272         commandEvent.SetInt(item->IsChecked());
 273     }
 274
 275     return HandleWindowEvent(commandEvent);
 276 }
 277
 278 #endif // wxUSE_MENUS
 279
 280 // Do the UI update processing for this window. This is
 281 // provided for the application to call if it wants to
 282 // force a UI update, particularly for the menus and toolbar.
 283 void wxFrameBase::UpdateWindowUI(long flags)
 284 {
 285     wxWindowBase::UpdateWindowUI(flags);
 286
 287 #if wxUSE_TOOLBAR
 288     if (GetToolBar())
 289         GetToolBar()->UpdateWindowUI(flags);
 290 #endif
 291
 292 #if wxUSE_MENUS
 293     if (GetMenuBar())
 294     {
 295         // If coming from an idle event, we only want to update the menus if
 296         // we're in the wxUSE_IDLEMENUUPDATES configuration, otherwise they
 297         // will be update when the menu is opened later
 298 #if !wxUSE_IDLEMENUUPDATES
 299         if ( !(flags & wxUPDATE_UI_FROMIDLE) )
 300 #endif // wxUSE_IDLEMENUUPDATES
 301             DoMenuUpdates();
 302     }
 303 #endif // wxUSE_MENUS
 304 }
 305
 306 // ----------------------------------------------------------------------------
 307 // event handlers for status bar updates from menus
 308 // ----------------------------------------------------------------------------
 309
 310 #if wxUSE_MENUS && wxUSE_STATUSBAR
 311
 312 void wxFrameBase::OnMenuHighlight(wxMenuEvent& event)
 313 {
 314 #if wxUSE_STATUSBAR
 315     (void)ShowMenuHelp(event.GetMenuId());
 316 #endif // wxUSE_STATUSBAR
 317 }
 318
 319 void wxFrameBase::OnMenuOpen(wxMenuEvent& event)
 320 {
 321 #if wxUSE_IDLEMENUUPDATES
 322     wxUnusedVar(event);
 323 #else // !wxUSE_IDLEMENUUPDATES
 324     // as we didn't update the menus from idle time, do it now
 325     DoMenuUpdates(event.GetMenu());
 326 #endif // wxUSE_IDLEMENUUPDATES/!wxUSE_IDLEMENUUPDATES
 327 }
 328
 329 void wxFrameBase::OnMenuClose(wxMenuEvent& WXUNUSED(event))
 330 {
 331     DoGiveHelp(wxEmptyString, false);
 332 }
 333
 334 #endif // wxUSE_MENUS && wxUSE_STATUSBAR
 335
 336 // Implement internal behaviour (menu updating on some platforms)
 337 void wxFrameBase::OnInternalIdle()
 338 {
 339     wxTopLevelWindow::OnInternalIdle();
 340
 341 #if wxUSE_MENUS && wxUSE_IDLEMENUUPDATES
 342     if (wxUpdateUIEvent::CanUpdate(this))
 343         DoMenuUpdates();
 344 #endif
 345 }
 346
 347 // ----------------------------------------------------------------------------
 348 // status bar stuff
 349 // ----------------------------------------------------------------------------
 350
 351 #if wxUSE_STATUSBAR
 352
 353 wxStatusBar* wxFrameBase::CreateStatusBar(int number,
 354                                           long style,
 355                                           wxWindowID id,
 356                                           const wxString& name)
 357 {
 358     // the main status bar can only be created once (or else it should be
 359     // deleted before calling CreateStatusBar() again)
 360     wxCHECK_MSG( !m_frameStatusBar, NULL,
 361                  wxT("recreating status bar in wxFrame") );
 362
 363     SetStatusBar(OnCreateStatusBar(number, style, id, name));
 364
 365     return m_frameStatusBar;
 366 }
 367
 368 wxStatusBar *wxFrameBase::OnCreateStatusBar(int number,
 369                                             long style,
 370                                             wxWindowID id,
 371                                             const wxString& name)
 372 {
 373     wxStatusBar *statusBar = new wxStatusBar(this, id, style, name);
 374
 375     statusBar->SetFieldsCount(number);
 376
 377     return statusBar;
 378 }
 379
 380 void wxFrameBase::SetStatusText(const wxString& text, int number)
 381 {
 382     wxCHECK_RET( m_frameStatusBar != NULL, wxT("no statusbar to set text for") );
 383
 384     m_frameStatusBar->SetStatusText(text, number);
 385 }
 386
 387 void wxFrameBase::SetStatusWidths(int n, const int widths_field[] )
 388 {
 389     wxCHECK_RET( m_frameStatusBar != NULL, wxT("no statusbar to set widths for") );
 390
 391     m_frameStatusBar->SetStatusWidths(n, widths_field);
 392
 393     PositionStatusBar();
 394 }
 395
 396 void wxFrameBase::PushStatusText(const wxString& text, int number)
 397 {
 398     wxCHECK_RET( m_frameStatusBar != NULL, wxT("no statusbar to set text for") );
 399
 400     m_frameStatusBar->PushStatusText(text, number);
 401 }
 402
 403 void wxFrameBase::PopStatusText(int number)
 404 {
 405     wxCHECK_RET( m_frameStatusBar != NULL, wxT("no statusbar to set text for") );
 406
 407     m_frameStatusBar->PopStatusText(number);
 408 }
 409
 410 bool wxFrameBase::ShowMenuHelp(int menuId)
 411 {
 412 #if wxUSE_MENUS
 413     // if no help string found, we will clear the status bar text
 414     //
 415     // NB: wxID_NONE is used for (sub)menus themselves by wxMSW
 416     wxString helpString;
 417     if ( menuId != wxID_SEPARATOR && menuId != wxID_NONE )
 418     {
 419         const wxMenuItem * const item = FindItemInMenuBar(menuId);
 420         if ( item && !item->IsSeparator() )
 421             helpString = item->GetHelp();
 422
 423         // notice that it's ok if we don't find the item because it might
 424         // belong to the popup menu, so don't assert here
 425     }
 426
 427     DoGiveHelp(helpString, true);
 428
 429     return !helpString.empty();
 430 #else // !wxUSE_MENUS
 431     return false;
 432 #endif // wxUSE_MENUS/!wxUSE_MENUS
 433 }
 434
 435 void wxFrameBase::SetStatusBar(wxStatusBar *statBar)
 436 {
 437     bool hadBar = m_frameStatusBar != NULL;
 438     m_frameStatusBar = statBar;
 439
 440     if ( (m_frameStatusBar != NULL) != hadBar )
 441     {
 442         PositionStatusBar();
 443
 444         DoLayout();
 445     }
 446 }
 447
 448 #endif // wxUSE_STATUSBAR
 449
 450 #if wxUSE_MENUS || wxUSE_TOOLBAR
 451 void wxFrameBase::DoGiveHelp(const wxString& help, bool show)
 452 {
 453 #if wxUSE_STATUSBAR
 454     if ( m_statusBarPane < 0 )
 455     {
 456         // status bar messages disabled
 457         return;
 458     }
 459
 460     wxStatusBar *statbar = GetStatusBar();
 461     if ( !statbar )
 462         return;
 463
 464     wxString text;
 465     if ( show )
 466     {
 467         // remember the old status bar text if this is the first time we're
 468         // called since the menu has been opened as we're going to overwrite it
 469         // in our DoGiveHelp() and we want to restore it when the menu is
 470         // closed
 471         //
 472         // note that it would be logical to do this in OnMenuOpen() but under
 473         // MSW we get an EVT_MENU_HIGHLIGHT before EVT_MENU_OPEN, strangely
 474         // enough, and so this doesn't work and instead we use the ugly trick
 475         // with using special m_oldStatusText value as "menu opened" (but it is
 476         // arguably better than adding yet another member variable to wxFrame
 477         // on all platforms)
 478         if ( m_oldStatusText.empty() )
 479         {
 480             m_oldStatusText = statbar->GetStatusText(m_statusBarPane);
 481             if ( m_oldStatusText.empty() )
 482             {
 483                 // use special value to prevent us from doing this the next time
 484                 m_oldStatusText += wxT('\0');
 485             }
 486         }
 487
 488         m_lastHelpShown =
 489         text = help;
 490     }
 491     else // hide help, restore the original text
 492     {
 493         // clear the last shown help string but remember its value
 494         wxString lastHelpShown;
 495         lastHelpShown.swap(m_lastHelpShown);
 496
 497         // also clear the old status text but remember it too to restore it
 498         // below
 499         text.swap(m_oldStatusText);
 500
 501         if ( statbar->GetStatusText(m_statusBarPane) != lastHelpShown )
 502         {
 503             // if the text was changed with an explicit SetStatusText() call
 504             // from the user code in the meanwhile, do not overwrite it with
 505             // the old status bar contents -- this is almost certainly not what
 506             // the user expects and would be very hard to avoid from user code
 507             return;
 508         }
 509     }
 510
 511     statbar->SetStatusText(text, m_statusBarPane);
 512 #else
 513     wxUnusedVar(help);
 514     wxUnusedVar(show);
 515 #endif // wxUSE_STATUSBAR
 516 }
 517 #endif // wxUSE_MENUS || wxUSE_TOOLBAR
 518
 519
 520 // ----------------------------------------------------------------------------
 521 // toolbar stuff
 522 // ----------------------------------------------------------------------------
 523
 524 #if wxUSE_TOOLBAR
 525
 526 wxToolBar* wxFrameBase::CreateToolBar(long style,
 527                                       wxWindowID id,
 528                                       const wxString& name)
 529 {
 530     // the main toolbar can't be recreated (unless it was explicitly deleted
 531     // before)
 532     wxCHECK_MSG( !m_frameToolBar, NULL,
 533                  wxT("recreating toolbar in wxFrame") );
 534
 535     if ( style == -1 )
 536     {
 537         // use default style
 538         //
 539         // NB: we don't specify the default value in the method declaration
 540         //     because
 541         //      a) this allows us to have different defaults for different
 542         //         platforms (even if we don't have them right now)
 543         //      b) we don't need to include wx/toolbar.h in the header then
 544         style = wxBORDER_NONE | wxTB_HORIZONTAL | wxTB_FLAT;
 545     }
 546
 547     SetToolBar(OnCreateToolBar(style, id, name));
 548
 549     return m_frameToolBar;
 550 }
 551
 552 wxToolBar* wxFrameBase::OnCreateToolBar(long style,
 553                                         wxWindowID id,
 554                                         const wxString& name)
 555 {
 556 #if defined(__WXWINCE__) && defined(__POCKETPC__)
 557     return new wxToolMenuBar(this, id,
 558                          wxDefaultPosition, wxDefaultSize,
 559                          style, name);
 560 #else
 561     return new wxToolBar(this, id,
 562                          wxDefaultPosition, wxDefaultSize,
 563                          style, name);
 564 #endif
 565 }
 566
 567 void wxFrameBase::SetToolBar(wxToolBar *toolbar)
 568 {
 569     if ( (toolbar != NULL) != (m_frameToolBar != NULL) )
 570     {
 571         // the toolbar visibility must have changed so we need to both position
 572         // the toolbar itself (if it appeared) and to relayout the frame
 573         // contents in any case
 574
 575         if ( toolbar )
 576         {
 577             // we need to assign it to m_frameToolBar for PositionToolBar() to
 578             // do anything
 579             m_frameToolBar = toolbar;
 580             PositionToolBar();
 581         }
 582         //else: tricky: do not reset m_frameToolBar yet as otherwise DoLayout()
 583         //      wouldn't recognize the (still existing) toolbar as one of our
 584         //      bars and wouldn't layout the single child of the frame correctly
 585
 586
 587         // and this is even more tricky: we want DoLayout() to recognize the
 588         // old toolbar for the purpose of not counting it among our non-bar
 589         // children but we don't want to reserve any more space for it so we
 590         // temporarily hide it
 591         if ( m_frameToolBar )
 592             m_frameToolBar->Hide();
 593
 594         DoLayout();
 595
 596         if ( m_frameToolBar )
 597             m_frameToolBar->Show();
 598     }
 599
 600     // this might have been already done above but it's simpler to just always
 601     // do it unconditionally instead of testing for whether we already did it
 602     m_frameToolBar = toolbar;
 603 }
 604
 605 #endif // wxUSE_TOOLBAR
 606
 607 // ----------------------------------------------------------------------------
 608 // menus
 609 // ----------------------------------------------------------------------------
 610
 611 #if wxUSE_MENUS
 612
 613 // update all menus
 614 void wxFrameBase::DoMenuUpdates(wxMenu* menu)
 615 {
 616     if (menu)
 617     {
 618         wxEvtHandler* source = GetEventHandler();
 619         menu->UpdateUI(source);
 620     }
 621     else
 622     {
 623         wxMenuBar* bar = GetMenuBar();
 624         if (bar != NULL)
 625             bar->UpdateMenus();
 626     }
 627 }
 628
 629 void wxFrameBase::DetachMenuBar()
 630 {
 631     if ( m_frameMenuBar )
 632     {
 633         m_frameMenuBar->Detach();
 634         m_frameMenuBar = NULL;
 635     }
 636 }
 637
 638 void wxFrameBase::AttachMenuBar(wxMenuBar *menubar)
 639 {
 640     if ( menubar )
 641     {
 642         menubar->Attach((wxFrame *)this);
 643         m_frameMenuBar = menubar;
 644     }
 645 }
 646
 647 void wxFrameBase::SetMenuBar(wxMenuBar *menubar)
 648 {
 649     if ( menubar == GetMenuBar() )
 650     {
 651         // nothing to do
 652         return;
 653     }
 654
 655     DetachMenuBar();
 656
 657     this->AttachMenuBar(menubar);
 658 }
 659
 660 wxMenuItem *wxFrameBase::FindItemInMenuBar(int menuId) const
 661 {
 662     const wxMenuBar * const menuBar = GetMenuBar();
 663
 664     return menuBar ? menuBar->FindItem(menuId) : NULL;
 665 }
 666
 667 #endif // wxUSE_MENUS