samples/menu/menu.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        samples/menu.cpp
   3 // Purpose:     wxMenu/wxMenuBar sample
   4 // Author:      Vadim Zeitlin
   5 // Modified by:
   6 // Created:     01.11.99
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 1999 Vadim Zeitlin
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 // For compilers that support precompilation, includes "wx/wx.h".
  21 #include "wx/wxprec.h"
  22
  23 #ifdef __BORLANDC__
  24     #pragma hdrstop
  25 #endif
  26
  27 #ifndef WX_PRECOMP
  28     #include "wx/app.h"
  29     #include "wx/frame.h"
  30     #include "wx/menu.h"
  31     #include "wx/msgdlg.h"
  32     #include "wx/log.h"
  33     #include "wx/textctrl.h"
  34     #include "wx/textdlg.h"
  35 #endif
  36
  37 #if !wxUSE_MENUS
  38     // nice try...
  39     #error "menu sample requires wxUSE_MENUS=1"
  40 #endif // wxUSE_MENUS
  41
  42 // not all ports have support for EVT_CONTEXT_MENU yet, don't define
  43 // USE_CONTEXT_MENU for those which don't
  44 #if defined(__WXMOTIF__) || defined(__WXPM__)
  45     #define USE_CONTEXT_MENU 0
  46 #else
  47     #define USE_CONTEXT_MENU 1
  48 #endif
  49
  50 // this sample is usefull when new port is developed
  51 // and usually new port has majority of flags turned off
  52 #if wxUSE_LOG && wxUSE_TEXTCTRL
  53     #define USE_LOG_WINDOW 1
  54 #else
  55     #define USE_LOG_WINDOW 0
  56 #endif
  57
  58 #if wxUSE_OWNER_DRAWN
  59 #include "copy.xpm"
  60 #endif
  61
  62 // ----------------------------------------------------------------------------
  63 // classes
  64 // ----------------------------------------------------------------------------
  65
  66 // Define a new application
  67 class MyApp: public wxApp
  68 {
  69 public:
  70     bool OnInit();
  71 };
  72
  73 // Define a new frame
  74 class MyFrame: public wxFrame
  75 {
  76 public:
  77     MyFrame();
  78
  79     virtual ~MyFrame();
  80
  81     void LogMenuEvent(const wxCommandEvent& event);
  82
  83 protected:
  84     void OnQuit(wxCommandEvent& event);
  85 #if USE_LOG_WINDOW
  86     void OnClearLog(wxCommandEvent& event);
  87 #endif
  88
  89     void OnAbout(wxCommandEvent& event);
  90
  91     void OnDummy(wxCommandEvent& event);
  92
  93     void OnAppendMenuItem(wxCommandEvent& event);
  94     void OnAppendSubMenu(wxCommandEvent& event);
  95     void OnDeleteMenuItem(wxCommandEvent& event);
  96     void OnInsertMenuItem(wxCommandEvent& event);
  97     void OnCheckMenuItem(wxCommandEvent& event);
  98     void OnEnableMenuItem(wxCommandEvent& event);
  99     void OnGetLabelMenuItem(wxCommandEvent& event);
 100 #if wxUSE_TEXTDLG
 101     void OnSetLabelMenuItem(wxCommandEvent& event);
 102 #endif
 103     void OnGetMenuItemInfo(wxCommandEvent& event);
 104 #if wxUSE_TEXTDLG
 105     void OnFindMenuItem(wxCommandEvent& event);
 106 #endif
 107
 108     void OnAppendMenu(wxCommandEvent& event);
 109     void OnInsertMenu(wxCommandEvent& event);
 110     void OnDeleteMenu(wxCommandEvent& event);
 111     void OnToggleMenu(wxCommandEvent& event);
 112     void OnEnableMenu(wxCommandEvent& event);
 113     void OnGetLabelMenu(wxCommandEvent& event);
 114     void OnSetLabelMenu(wxCommandEvent& event);
 115 #if wxUSE_TEXTDLG
 116     void OnFindMenu(wxCommandEvent& event);
 117 #endif
 118
 119     void OnTestNormal(wxCommandEvent& event);
 120     void OnTestCheck(wxCommandEvent& event);
 121     void OnTestRadio(wxCommandEvent& event);
 122
 123     void OnUpdateSubMenuNormal(wxUpdateUIEvent& event);
 124     void OnUpdateSubMenuCheck(wxUpdateUIEvent& event);
 125     void OnUpdateSubMenuRadio(wxUpdateUIEvent& event);
 126
 127 #if USE_CONTEXT_MENU
 128     void OnContextMenu(wxContextMenuEvent& event);
 129 #else
 130     void OnRightUp(wxMouseEvent& event)
 131         { ShowContextMenu(event.GetPosition()); }
 132 #endif
 133
 134     void OnMenuOpen(wxMenuEvent& event)
 135         {
 136 #if USE_LOG_WINDOW
 137             LogMenuOpenOrClose(event, _T("opened")); event.Skip();
 138 #endif
 139         }
 140     void OnMenuClose(wxMenuEvent& event)
 141         {
 142 #if USE_LOG_WINDOW
 143           LogMenuOpenOrClose(event, _T("closed")); event.Skip();
 144 #endif
 145        }
 146
 147     void OnUpdateCheckMenuItemUI(wxUpdateUIEvent& event);
 148
 149     void OnSize(wxSizeEvent& event);
 150
 151 private:
 152     void LogMenuOpenOrClose(const wxMenuEvent& event, const wxChar *what);
 153     void ShowContextMenu(const wxPoint& pos);
 154
 155     wxMenu *CreateDummyMenu(wxString *title);
 156
 157     wxMenuItem *GetLastMenuItem() const;
 158
 159     // the menu previously detached from the menubar (may be NULL)
 160     wxMenu *m_menu;
 161
 162     // the count of dummy menus already created
 163     size_t m_countDummy;
 164
 165 #if USE_LOG_WINDOW
 166     // the control used for logging
 167     wxTextCtrl *m_textctrl;
 168 #endif
 169
 170     // the previous log target
 171     wxLog *m_logOld;
 172
 173     DECLARE_EVENT_TABLE()
 174 };
 175
 176 // A small helper class which intercepts all menu events and logs them
 177 class MyEvtHandler : public wxEvtHandler
 178 {
 179 public:
 180     MyEvtHandler(MyFrame *frame) { m_frame = frame; }
 181
 182     void OnMenuEvent(wxCommandEvent& event)
 183     {
 184         m_frame->LogMenuEvent(event);
 185
 186         event.Skip();
 187     }
 188
 189 private:
 190     MyFrame *m_frame;
 191
 192     DECLARE_EVENT_TABLE()
 193 };
 194
 195 // ----------------------------------------------------------------------------
 196 // constants
 197 // ----------------------------------------------------------------------------
 198
 199 enum
 200 {
 201     Menu_File_Quit = wxID_EXIT,
 202 #if USE_LOG_WINDOW
 203     Menu_File_ClearLog,
 204 #endif
 205
 206     Menu_MenuBar_Toggle = 200,
 207     Menu_MenuBar_Append,
 208     Menu_MenuBar_Insert,
 209     Menu_MenuBar_Delete,
 210     Menu_MenuBar_Enable,
 211     Menu_MenuBar_GetLabel,
 212 #if wxUSE_TEXTDLG
 213     Menu_MenuBar_SetLabel,
 214     Menu_MenuBar_FindMenu,
 215 #endif
 216
 217     Menu_Menu_Append = 300,
 218     Menu_Menu_AppendSub,
 219     Menu_Menu_Insert,
 220     Menu_Menu_Delete,
 221     Menu_Menu_Enable,
 222     Menu_Menu_Check,
 223     Menu_Menu_GetLabel,
 224 #if wxUSE_TEXTDLG
 225     Menu_Menu_SetLabel,
 226 #endif
 227     Menu_Menu_GetInfo,
 228 #if wxUSE_TEXTDLG
 229     Menu_Menu_FindItem,
 230 #endif
 231
 232     Menu_Test_Normal = 400,
 233     Menu_Test_Check,
 234     Menu_Test_Radio1,
 235     Menu_Test_Radio2,
 236     Menu_Test_Radio3,
 237
 238     Menu_SubMenu = 450,
 239     Menu_SubMenu_Normal,
 240     Menu_SubMenu_Check,
 241     Menu_SubMenu_Radio1,
 242     Menu_SubMenu_Radio2,
 243     Menu_SubMenu_Radio3,
 244
 245     Menu_Dummy_First = 500,
 246     Menu_Dummy_Second,
 247     Menu_Dummy_Third,
 248     Menu_Dummy_Fourth,
 249     Menu_Dummy_Last,
 250
 251     Menu_Help_About = wxID_ABOUT,
 252
 253     Menu_Popup_ToBeDeleted = 2000,
 254     Menu_Popup_ToBeGreyed,
 255     Menu_Popup_ToBeChecked,
 256     Menu_Popup_Submenu,
 257
 258     Menu_Max
 259 };
 260
 261 // ----------------------------------------------------------------------------
 262 // event tables
 263 // ----------------------------------------------------------------------------
 264
 265 BEGIN_EVENT_TABLE(MyFrame, wxFrame)
 266     EVT_MENU(Menu_File_Quit,     MyFrame::OnQuit)
 267 #if USE_LOG_WINDOW
 268     EVT_MENU(Menu_File_ClearLog, MyFrame::OnClearLog)
 269 #endif
 270
 271     EVT_MENU(Menu_Help_About, MyFrame::OnAbout)
 272
 273     EVT_MENU(Menu_MenuBar_Toggle,   MyFrame::OnToggleMenu)
 274     EVT_MENU(Menu_MenuBar_Append,   MyFrame::OnAppendMenu)
 275     EVT_MENU(Menu_MenuBar_Insert,   MyFrame::OnInsertMenu)
 276     EVT_MENU(Menu_MenuBar_Delete,   MyFrame::OnDeleteMenu)
 277     EVT_MENU(Menu_MenuBar_Enable,   MyFrame::OnEnableMenu)
 278     EVT_MENU(Menu_MenuBar_GetLabel, MyFrame::OnGetLabelMenu)
 279 #if wxUSE_TEXTDLG
 280     EVT_MENU(Menu_MenuBar_SetLabel, MyFrame::OnSetLabelMenu)
 281     EVT_MENU(Menu_MenuBar_FindMenu, MyFrame::OnFindMenu)
 282 #endif
 283
 284     EVT_MENU(Menu_Menu_Append,    MyFrame::OnAppendMenuItem)
 285     EVT_MENU(Menu_Menu_AppendSub, MyFrame::OnAppendSubMenu)
 286     EVT_MENU(Menu_Menu_Insert,    MyFrame::OnInsertMenuItem)
 287     EVT_MENU(Menu_Menu_Delete,    MyFrame::OnDeleteMenuItem)
 288     EVT_MENU(Menu_Menu_Enable,    MyFrame::OnEnableMenuItem)
 289     EVT_MENU(Menu_Menu_Check,     MyFrame::OnCheckMenuItem)
 290     EVT_MENU(Menu_Menu_GetLabel,  MyFrame::OnGetLabelMenuItem)
 291 #if wxUSE_TEXTDLG
 292     EVT_MENU(Menu_Menu_SetLabel,  MyFrame::OnSetLabelMenuItem)
 293 #endif
 294     EVT_MENU(Menu_Menu_GetInfo,   MyFrame::OnGetMenuItemInfo)
 295 #if wxUSE_TEXTDLG
 296     EVT_MENU(Menu_Menu_FindItem,  MyFrame::OnFindMenuItem)
 297 #endif
 298
 299     EVT_MENU(Menu_Test_Normal,    MyFrame::OnTestNormal)
 300     EVT_MENU(Menu_Test_Check,     MyFrame::OnTestCheck)
 301     EVT_MENU(Menu_Test_Radio1,    MyFrame::OnTestRadio)
 302     EVT_MENU(Menu_Test_Radio2,    MyFrame::OnTestRadio)
 303     EVT_MENU(Menu_Test_Radio3,    MyFrame::OnTestRadio)
 304
 305     EVT_UPDATE_UI(Menu_SubMenu_Normal,    MyFrame::OnUpdateSubMenuNormal)
 306     EVT_UPDATE_UI(Menu_SubMenu_Check,     MyFrame::OnUpdateSubMenuCheck)
 307     EVT_UPDATE_UI(Menu_SubMenu_Radio1,    MyFrame::OnUpdateSubMenuRadio)
 308     EVT_UPDATE_UI(Menu_SubMenu_Radio2,    MyFrame::OnUpdateSubMenuRadio)
 309     EVT_UPDATE_UI(Menu_SubMenu_Radio3,    MyFrame::OnUpdateSubMenuRadio)
 310
 311     EVT_MENU_RANGE(Menu_Dummy_First, Menu_Dummy_Last, MyFrame::OnDummy)
 312
 313     EVT_UPDATE_UI(Menu_Menu_Check, MyFrame::OnUpdateCheckMenuItemUI)
 314
 315 #if USE_CONTEXT_MENU
 316     EVT_CONTEXT_MENU(MyFrame::OnContextMenu)
 317 #else
 318     EVT_RIGHT_UP(MyFrame::OnRightUp)
 319 #endif
 320
 321     EVT_MENU_OPEN(MyFrame::OnMenuOpen)
 322     EVT_MENU_CLOSE(MyFrame::OnMenuClose)
 323
 324     EVT_SIZE(MyFrame::OnSize)
 325 END_EVENT_TABLE()
 326
 327 BEGIN_EVENT_TABLE(MyEvtHandler, wxEvtHandler)
 328     EVT_MENU(wxID_ANY, MyEvtHandler::OnMenuEvent)
 329 END_EVENT_TABLE()
 330
 331 // ============================================================================
 332 // implementation
 333 // ============================================================================
 334
 335 // ----------------------------------------------------------------------------
 336 // MyApp
 337 // ----------------------------------------------------------------------------
 338
 339 IMPLEMENT_APP(MyApp)
 340
 341 // The `main program' equivalent, creating the windows and returning the
 342 // main frame
 343 bool MyApp::OnInit()
 344 {
 345     // Create the main frame window
 346     MyFrame* frame = new MyFrame;
 347
 348     frame->Show(true);
 349
 350 #if wxUSE_STATUSBAR
 351     frame->SetStatusText(_T("Welcome to wxWidgets menu sample"));
 352 #endif // wxUSE_STATUSBAR
 353
 354     SetTopWindow(frame);
 355
 356     return true;
 357 }
 358
 359 // ----------------------------------------------------------------------------
 360 // MyFrame
 361 // ----------------------------------------------------------------------------
 362
 363 // Define my frame constructor
 364 MyFrame::MyFrame()
 365        : wxFrame((wxFrame *)NULL, wxID_ANY, _T("wxWidgets menu sample"))
 366 {
 367 #if USE_LOG_WINDOW
 368     m_textctrl = NULL;
 369 #endif
 370     m_menu = NULL;
 371     m_countDummy = 0;
 372     m_logOld = NULL;
 373
 374 #if wxUSE_STATUSBAR
 375     CreateStatusBar();
 376 #endif // wxUSE_STATUSBAR
 377
 378     // create the menubar
 379     wxMenu *fileMenu = new wxMenu;
 380
 381 #if USE_LOG_WINDOW
 382     wxMenuItem *item = new wxMenuItem(fileMenu, Menu_File_ClearLog,
 383                                       _T("Clear &log\tCtrl-L"));
 384 #if wxUSE_OWNER_DRAWN
 385     item->SetBitmap(copy_xpm);
 386 #endif
 387     fileMenu->Append(item);
 388     fileMenu->AppendSeparator();
 389 #endif
 390     fileMenu->Append(Menu_File_Quit, _T("E&xit\tAlt-X"), _T("Quit menu sample"));
 391
 392     wxMenu *menubarMenu = new wxMenu;
 393     menubarMenu->Append(Menu_MenuBar_Append, _T("&Append menu\tCtrl-A"),
 394                         _T("Append a menu to the menubar"));
 395     menubarMenu->Append(Menu_MenuBar_Insert, _T("&Insert menu\tCtrl-I"),
 396                         _T("Insert a menu into the menubar"));
 397     menubarMenu->Append(Menu_MenuBar_Delete, _T("&Delete menu\tCtrl-D"),
 398                         _T("Delete the last menu from the menubar"));
 399     menubarMenu->Append(Menu_MenuBar_Toggle, _T("&Toggle menu\tCtrl-T"),
 400                         _T("Toggle the first menu in the menubar"), true);
 401     menubarMenu->AppendSeparator();
 402     menubarMenu->Append(Menu_MenuBar_Enable, _T("&Enable menu\tCtrl-E"),
 403                         _T("Enable or disable the last menu"), true);
 404     menubarMenu->AppendSeparator();
 405     menubarMenu->Append(Menu_MenuBar_GetLabel, _T("&Get menu label\tCtrl-G"),
 406                         _T("Get the label of the last menu"));
 407 #if wxUSE_TEXTDLG
 408     menubarMenu->Append(Menu_MenuBar_SetLabel, _T("&Set menu label\tCtrl-S"),
 409                         _T("Change the label of the last menu"));
 410     menubarMenu->AppendSeparator();
 411     menubarMenu->Append(Menu_MenuBar_FindMenu, _T("&Find menu from label\tCtrl-F"),
 412                         _T("Find a menu by searching for its label"));
 413 #endif
 414
 415     wxMenu* subMenu = new wxMenu;
 416     subMenu->Append(Menu_SubMenu_Normal, _T("&Normal submenu item"), _T("Disabled submenu item"));
 417     subMenu->AppendCheckItem(Menu_SubMenu_Check, _T("&Unchecked submenu item"), _T("Unchecked submenu item"));
 418     subMenu->AppendRadioItem(Menu_SubMenu_Radio1, _T("Radio item &1"), _T("Radio item"));
 419     subMenu->AppendRadioItem(Menu_SubMenu_Radio2, _T("Radio item &2"), _T("Radio item"));
 420     subMenu->AppendRadioItem(Menu_SubMenu_Radio3, _T("Radio item &3"), _T("Radio item"));
 421
 422     menubarMenu->Append(Menu_SubMenu, _T("Submenu"), subMenu);
 423
 424     wxMenu *menuMenu = new wxMenu;
 425     menuMenu->Append(Menu_Menu_Append, _T("&Append menu item\tAlt-A"),
 426                      _T("Append a menu item to the last menu"));
 427     menuMenu->Append(Menu_Menu_AppendSub, _T("&Append sub menu\tAlt-S"),
 428                      _T("Append a sub menu to the last menu"));
 429     menuMenu->Append(Menu_Menu_Insert, _T("&Insert menu item\tAlt-I"),
 430                      _T("Insert a menu item in head of the last menu"));
 431     menuMenu->Append(Menu_Menu_Delete, _T("&Delete menu item\tAlt-D"),
 432                      _T("Delete the last menu item from the last menu"));
 433     menuMenu->AppendSeparator();
 434     menuMenu->Append(Menu_Menu_Enable, _T("&Enable menu item\tAlt-E"),
 435                      _T("Enable or disable the last menu item"), true);
 436     menuMenu->Append(Menu_Menu_Check, _T("&Check menu item\tAlt-C"),
 437                      _T("Check or uncheck the last menu item"), true);
 438     menuMenu->AppendSeparator();
 439     menuMenu->Append(Menu_Menu_GetInfo, _T("Get menu item in&fo\tAlt-F"),
 440                      _T("Show the state of the last menu item"));
 441 #if wxUSE_TEXTDLG
 442     menuMenu->AppendSeparator();
 443     menuMenu->Append(Menu_Menu_FindItem, _T("Find menu item from label"),
 444                      _T("Find a menu item by searching for its label"));
 445 #endif
 446
 447     wxMenu *testMenu = new wxMenu;
 448     testMenu->Append(Menu_Test_Normal, _T("&Normal item"));
 449     testMenu->AppendSeparator();
 450     testMenu->AppendCheckItem(Menu_Test_Check, _T("&Check item"));
 451     testMenu->AppendSeparator();
 452     testMenu->AppendRadioItem(Menu_Test_Radio1, _T("Radio item &1"));
 453     testMenu->AppendRadioItem(Menu_Test_Radio2, _T("Radio item &2"));
 454     testMenu->AppendRadioItem(Menu_Test_Radio3, _T("Radio item &3"));
 455
 456     wxMenu *helpMenu = new wxMenu;
 457     helpMenu->Append(Menu_Help_About, _T("&About\tF1"), _T("About menu sample"));
 458
 459     wxMenuBar* menuBar = new wxMenuBar( wxMB_DOCKABLE );
 460
 461     menuBar->Append(fileMenu, _T("&File"));
 462     menuBar->Append(menubarMenu, _T("Menu&bar"));
 463     menuBar->Append(menuMenu, _T("&Menu"));
 464     menuBar->Append(testMenu, _T("&Test"));
 465     menuBar->Append(helpMenu, _T("&Help"));
 466
 467     // these items should be initially checked
 468     menuBar->Check(Menu_MenuBar_Toggle, true);
 469     menuBar->Check(Menu_MenuBar_Enable, true);
 470     menuBar->Check(Menu_Menu_Enable, true);
 471     menuBar->Check(Menu_Menu_Check, false);
 472
 473     // associate the menu bar with the frame
 474     SetMenuBar(menuBar);
 475
 476     // intercept all menu events and log them in this custom event handler
 477     PushEventHandler(new MyEvtHandler(this));
 478
 479 #if USE_LOG_WINDOW
 480     // create the log text window
 481     m_textctrl = new wxTextCtrl(this, wxID_ANY, _T(""),
 482                                 wxDefaultPosition, wxDefaultSize,
 483                                 wxTE_MULTILINE);
 484     m_textctrl->SetEditable(false);
 485
 486     wxLog::SetTimestamp(NULL);
 487     m_logOld = wxLog::SetActiveTarget(new wxLogTextCtrl(m_textctrl));
 488
 489     wxLogMessage(_T("Brief explanations: the commands or the \"Menu\" menu ")
 490                  _T("append/insert/delete items to/from the last menu.\n")
 491                  _T("The commands from \"Menubar\" menu work with the ")
 492                  _T("menubar itself.\n\n")
 493                  _T("Right click the band below to test popup menus.\n"));
 494 #endif
 495 }
 496
 497 MyFrame::~MyFrame()
 498 {
 499     delete m_menu;
 500
 501     // delete the event handler installed in ctor
 502     PopEventHandler(true);
 503
 504 #if USE_LOG_WINDOW
 505     // restore old logger
 506     delete wxLog::SetActiveTarget(m_logOld);
 507 #endif
 508 }
 509
 510 wxMenu *MyFrame::CreateDummyMenu(wxString *title)
 511 {
 512     wxMenu *menu = new wxMenu;
 513     menu->Append(Menu_Dummy_First, _T("&First item\tCtrl-F1"));
 514     menu->AppendSeparator();
 515     menu->AppendCheckItem(Menu_Dummy_Second, _T("&Second item\tCtrl-F2"));
 516
 517     if ( title )
 518     {
 519         title->Printf(_T("Dummy menu &%u"), (unsigned)++m_countDummy);
 520     }
 521
 522     return menu;
 523 }
 524
 525 wxMenuItem *MyFrame::GetLastMenuItem() const
 526 {
 527     wxMenuBar *menubar = GetMenuBar();
 528     wxMenu *menu = menubar->GetMenu(menubar->GetMenuCount() - 1);
 529
 530     wxMenuItemList::compatibility_iterator node = menu->GetMenuItems().GetLast();
 531     if ( !node )
 532     {
 533         wxLogWarning(_T("No last item in the last menu!"));
 534
 535         return NULL;
 536     }
 537     else
 538     {
 539         return node->GetData();
 540     }
 541 }
 542
 543 void MyFrame::LogMenuEvent(const wxCommandEvent& event)
 544 {
 545     int id = event.GetId();
 546     if ( !GetMenuBar()->FindItem(id) )
 547         return;
 548
 549     wxString msg = wxString::Format(_T("Menu command %d"), id);
 550     if ( GetMenuBar()->FindItem(id)->IsCheckable() )
 551     {
 552         msg += wxString::Format(_T(" (the item is currently %schecked)"),
 553                                 event.IsChecked() ? _T("") : _T("not "));
 554     }
 555
 556     wxLogMessage(msg);
 557 }
 558
 559 // ----------------------------------------------------------------------------
 560 // menu callbacks
 561 // ----------------------------------------------------------------------------
 562
 563 void MyFrame::OnQuit(wxCommandEvent& WXUNUSED(event))
 564 {
 565     Close(true);
 566 }
 567
 568 #if USE_LOG_WINDOW
 569 void MyFrame::OnClearLog(wxCommandEvent& WXUNUSED(event))
 570 {
 571     m_textctrl->Clear();
 572 }
 573 #endif
 574
 575 void MyFrame::OnAbout(wxCommandEvent& WXUNUSED(event))
 576 {
 577     (void)wxMessageBox(_T("wxWidgets menu sample\n(c) 1999-2001 Vadim Zeitlin"),
 578                        _T("About wxWidgets menu sample"),
 579                        wxICON_INFORMATION);
 580 }
 581
 582 void MyFrame::OnDeleteMenu(wxCommandEvent& WXUNUSED(event))
 583 {
 584     wxMenuBar *mbar = GetMenuBar();
 585
 586     size_t count = mbar->GetMenuCount();
 587     if ( count == 2 )
 588     {
 589         // don't let delete the first 2 menus
 590         wxLogError(_T("Can't delete any more menus"));
 591     }
 592     else
 593     {
 594         delete mbar->Remove(count - 1);
 595     }
 596 }
 597
 598 void MyFrame::OnInsertMenu(wxCommandEvent& WXUNUSED(event))
 599 {
 600     wxString title;
 601     wxMenu *menu = CreateDummyMenu(&title);
 602     GetMenuBar()->Insert(0, menu, title);
 603 }
 604
 605 void MyFrame::OnAppendMenu(wxCommandEvent& WXUNUSED(event))
 606 {
 607     wxString title;
 608     wxMenu *menu = CreateDummyMenu(&title);
 609     GetMenuBar()->Append(menu, title);
 610 }
 611
 612 void MyFrame::OnToggleMenu(wxCommandEvent& WXUNUSED(event))
 613 {
 614     wxMenuBar *mbar = GetMenuBar();
 615     if ( !m_menu )
 616     {
 617         // hide the menu
 618         m_menu = mbar->Remove(0);
 619     }
 620     else
 621     {
 622         // restore it
 623         mbar->Insert(0, m_menu, _T("&File"));
 624         m_menu = NULL;
 625     }
 626 }
 627
 628 void MyFrame::OnEnableMenu(wxCommandEvent& event)
 629 {
 630     wxMenuBar *mbar = GetMenuBar();
 631     size_t count = mbar->GetMenuCount();
 632
 633     mbar->EnableTop(count - 1, event.IsChecked());
 634 }
 635
 636 void MyFrame::OnGetLabelMenu(wxCommandEvent& WXUNUSED(event))
 637 {
 638     wxMenuBar *mbar = GetMenuBar();
 639     size_t count = mbar->GetMenuCount();
 640
 641     wxCHECK_RET( count, _T("no last menu?") );
 642
 643     wxLogMessage(_T("The label of the last menu item is '%s'"),
 644                  mbar->GetLabelTop(count - 1).c_str());
 645 }
 646
 647 #if wxUSE_TEXTDLG
 648 void MyFrame::OnSetLabelMenu(wxCommandEvent& WXUNUSED(event))
 649 {
 650     wxMenuBar *mbar = GetMenuBar();
 651     size_t count = mbar->GetMenuCount();
 652
 653     wxCHECK_RET( count, _T("no last menu?") );
 654
 655     wxString label = wxGetTextFromUser
 656                      (
 657                         _T("Enter new label: "),
 658                         _T("Change last menu text"),
 659                         mbar->GetLabelTop(count - 1),
 660                         this
 661                      );
 662
 663     if ( !label.empty() )
 664     {
 665         mbar->SetLabelTop(count - 1, label);
 666     }
 667 }
 668
 669 void MyFrame::OnFindMenu(wxCommandEvent& WXUNUSED(event))
 670 {
 671     wxMenuBar *mbar = GetMenuBar();
 672     size_t count = mbar->GetMenuCount();
 673
 674     wxCHECK_RET( count, _T("no last menu?") );
 675
 676     wxString label = wxGetTextFromUser
 677                      (
 678                         _T("Enter label to search for: "),
 679                         _T("Find menu"),
 680                         _T(""),
 681                         this
 682                      );
 683
 684     if ( !label.empty() )
 685     {
 686         int index = mbar->FindMenu(label);
 687
 688         if (index == wxNOT_FOUND)
 689         {
 690             wxLogWarning(_T("No menu with label '%s'"), label.c_str());
 691         }
 692         else
 693         {
 694             wxLogMessage(_T("Menu %d has label '%s'"), index, label.c_str());
 695         }
 696     }
 697 }
 698 #endif
 699
 700 void MyFrame::OnDummy(wxCommandEvent& event)
 701 {
 702     wxLogMessage(_T("Dummy item #%d"), event.GetId() - Menu_Dummy_First + 1);
 703 }
 704
 705 void MyFrame::OnAppendMenuItem(wxCommandEvent& WXUNUSED(event))
 706 {
 707     wxMenuBar *menubar = GetMenuBar();
 708     wxMenu *menu = menubar->GetMenu(menubar->GetMenuCount() - 1);
 709
 710     menu->AppendSeparator();
 711     menu->Append(Menu_Dummy_Third, _T("&Third dummy item\tCtrl-F3"),
 712                  _T("Checkable item"), true);
 713 }
 714
 715 void MyFrame::OnAppendSubMenu(wxCommandEvent& WXUNUSED(event))
 716 {
 717     wxMenuBar *menubar = GetMenuBar();
 718
 719     wxMenu *menu = menubar->GetMenu(menubar->GetMenuCount() - 2);
 720
 721     menu->Append(Menu_Dummy_Last, _T("&Dummy sub menu"),
 722                  CreateDummyMenu(NULL), _T("Dummy sub menu help"));
 723 }
 724
 725 void MyFrame::OnDeleteMenuItem(wxCommandEvent& WXUNUSED(event))
 726 {
 727     wxMenuBar *menubar = GetMenuBar();
 728     wxMenu *menu = menubar->GetMenu(menubar->GetMenuCount() - 1);
 729
 730     size_t count = menu->GetMenuItemCount();
 731     if ( !count )
 732     {
 733         wxLogWarning(_T("No items to delete!"));
 734     }
 735     else
 736     {
 737         menu->Destroy(menu->GetMenuItems().Item(count - 1)->GetData());
 738     }
 739 }
 740
 741 void MyFrame::OnInsertMenuItem(wxCommandEvent& WXUNUSED(event))
 742 {
 743     wxMenuBar *menubar = GetMenuBar();
 744     wxMenu *menu = menubar->GetMenu(menubar->GetMenuCount() - 1);
 745
 746     menu->Insert(0, wxMenuItem::New(menu, Menu_Dummy_Fourth,
 747                                     _T("Fourth dummy item\tCtrl-F4")));
 748     menu->Insert(1, wxMenuItem::New(menu, wxID_SEPARATOR, _T("")));
 749 }
 750
 751 void MyFrame::OnEnableMenuItem(wxCommandEvent& WXUNUSED(event))
 752 {
 753     wxMenuItem *item = GetLastMenuItem();
 754
 755     if ( item )
 756     {
 757         item->Enable(!item->IsEnabled());
 758     }
 759 }
 760
 761 void MyFrame::OnCheckMenuItem(wxCommandEvent& WXUNUSED(event))
 762 {
 763     wxMenuItem *item = GetLastMenuItem();
 764
 765     item->Toggle();
 766 }
 767
 768 void MyFrame::OnUpdateCheckMenuItemUI(wxUpdateUIEvent& event)
 769 {
 770     wxLogNull nolog;
 771
 772     wxMenuItem *item = GetLastMenuItem();
 773
 774     event.Enable(item && item->IsCheckable());
 775 }
 776
 777 void MyFrame::OnGetLabelMenuItem(wxCommandEvent& WXUNUSED(event))
 778 {
 779     wxMenuItem *item = GetLastMenuItem();
 780
 781     if ( item )
 782     {
 783         wxLogMessage(_T("The label of the last menu item is '%s'"),
 784                      item->GetLabel().c_str());
 785     }
 786 }
 787
 788 #if wxUSE_TEXTDLG
 789 void MyFrame::OnSetLabelMenuItem(wxCommandEvent& WXUNUSED(event))
 790 {
 791     wxMenuItem *item = GetLastMenuItem();
 792
 793     if ( item )
 794     {
 795         wxString label = wxGetTextFromUser
 796                          (
 797                             _T("Enter new label: "),
 798                             _T("Change last menu item text"),
 799                             item->GetLabel(),
 800                             this
 801                          );
 802
 803         if ( !label.empty() )
 804         {
 805             item->SetText(label);
 806         }
 807     }
 808 }
 809 #endif
 810
 811 void MyFrame::OnGetMenuItemInfo(wxCommandEvent& WXUNUSED(event))
 812 {
 813     wxMenuItem *item = GetLastMenuItem();
 814
 815     if ( item )
 816     {
 817         wxString msg;
 818         msg << _T("The item is ") << (item->IsEnabled() ? _T("enabled")
 819                                                     : _T("disabled"))
 820             << _T('\n');
 821
 822         if ( item->IsCheckable() )
 823         {
 824             msg << _T("It is checkable and ") << (item->IsChecked() ? _T("") : _T("un"))
 825                 << _T("checked\n");
 826         }
 827
 828 #if wxUSE_ACCEL
 829         wxAcceleratorEntry *accel = item->GetAccel();
 830         if ( accel )
 831         {
 832             msg << _T("Its accelerator is ");
 833
 834             int flags = accel->GetFlags();
 835             if ( flags & wxACCEL_ALT )
 836                 msg << _T("Alt-");
 837             if ( flags & wxACCEL_CTRL )
 838                 msg << _T("Ctrl-");
 839             if ( flags & wxACCEL_SHIFT )
 840                 msg << _T("Shift-");
 841
 842             int code = accel->GetKeyCode();
 843             switch ( code )
 844             {
 845                 case WXK_F1:
 846                 case WXK_F2:
 847                 case WXK_F3:
 848                 case WXK_F4:
 849                 case WXK_F5:
 850                 case WXK_F6:
 851                 case WXK_F7:
 852                 case WXK_F8:
 853                 case WXK_F9:
 854                 case WXK_F10:
 855                 case WXK_F11:
 856                 case WXK_F12:
 857                     msg << _T('F') << code - WXK_F1 + 1;
 858                     break;
 859
 860                 // if there are any other keys wxGetAccelFromString() may return,
 861                 // we should process them here
 862
 863                 default:
 864                     if ( wxIsalnum(code) )
 865                     {
 866                         msg << (wxChar)code;
 867
 868                         break;
 869                     }
 870
 871                     wxFAIL_MSG( _T("unknown keyboard accel") );
 872             }
 873
 874             delete accel;
 875         }
 876         else
 877         {
 878             msg << _T("It doesn't have an accelerator");
 879         }
 880 #endif // wxUSE_ACCEL
 881
 882         wxLogMessage(msg);
 883     }
 884 }
 885
 886 #if wxUSE_TEXTDLG
 887 void MyFrame::OnFindMenuItem(wxCommandEvent& WXUNUSED(event))
 888 {
 889     wxMenuBar *mbar = GetMenuBar();
 890     size_t count = mbar->GetMenuCount();
 891
 892     wxCHECK_RET( count, _T("no last menu?") );
 893
 894     wxString label = wxGetTextFromUser
 895                      (
 896                         _T("Enter label to search for: "),
 897                         _T("Find menu item"),
 898                         _T(""),
 899                         this
 900                      );
 901
 902     if ( !label.empty() )
 903     {
 904         size_t menuindex;
 905         int index = wxNOT_FOUND;
 906
 907         for (menuindex = 0; (menuindex < count) && (index == wxNOT_FOUND); ++menuindex)
 908         {
 909             index = mbar->FindMenuItem(mbar->GetMenu(menuindex)->GetTitle(), label);
 910         }
 911         if (index == wxNOT_FOUND)
 912         {
 913             wxLogWarning(_T("No menu item with label '%s'"), label.c_str());
 914         }
 915         else
 916         {
 917             wxLogMessage(_T("Menu item %d in menu %lu has label '%s'"),
 918                          index, (unsigned long)menuindex, label.c_str());
 919         }
 920     }
 921 }
 922 #endif
 923
 924 void MyFrame::ShowContextMenu(const wxPoint& pos)
 925 {
 926     wxMenu menu(_T("Test popup"));
 927
 928     menu.Append(Menu_Help_About, _T("&About"));
 929     menu.Append(Menu_Popup_Submenu, _T("&Submenu"), CreateDummyMenu(NULL));
 930     menu.Append(Menu_Popup_ToBeDeleted, _T("To be &deleted"));
 931     menu.AppendCheckItem(Menu_Popup_ToBeChecked, _T("To be &checked"));
 932     menu.Append(Menu_Popup_ToBeGreyed, _T("To be &greyed"),
 933                 _T("This menu item should be initially greyed out"));
 934     menu.AppendSeparator();
 935     menu.Append(Menu_File_Quit, _T("E&xit"));
 936
 937     menu.Delete(Menu_Popup_ToBeDeleted);
 938     menu.Check(Menu_Popup_ToBeChecked, true);
 939     menu.Enable(Menu_Popup_ToBeGreyed, false);
 940
 941     PopupMenu(&menu, pos.x, pos.y);
 942
 943     // test for destroying items in popup menus
 944 #if 0 // doesn't work in wxGTK!
 945     menu.Destroy(Menu_Popup_Submenu);
 946
 947     PopupMenu( &menu, event.GetX(), event.GetY() );
 948 #endif // 0
 949 }
 950
 951 void MyFrame::OnTestNormal(wxCommandEvent& WXUNUSED(event))
 952 {
 953     wxLogMessage(_T("Normal item selected"));
 954 }
 955
 956 void MyFrame::OnTestCheck(wxCommandEvent& event)
 957 {
 958     wxLogMessage(_T("Check item %schecked"),
 959                  event.IsChecked() ? _T("") : _T("un"));
 960 }
 961
 962 void MyFrame::OnTestRadio(wxCommandEvent& event)
 963 {
 964     wxLogMessage(_T("Radio item %d selected"),
 965                  event.GetId() - Menu_Test_Radio1 + 1);
 966 }
 967
 968 #if USE_LOG_WINDOW
 969 void MyFrame::LogMenuOpenOrClose(const wxMenuEvent& event, const wxChar *what)
 970 {
 971     wxString msg;
 972     msg << _T("A ")
 973         << ( event.IsPopup() ? _T("popup ") : _T("") )
 974         << _T("menu has been ")
 975         << what
 976         << _T(".");
 977
 978     wxLogStatus(this, msg.c_str());
 979 }
 980 #endif
 981
 982 void MyFrame::OnUpdateSubMenuNormal(wxUpdateUIEvent& event)
 983 {
 984     event.Enable(false);
 985 }
 986
 987 void MyFrame::OnUpdateSubMenuCheck(wxUpdateUIEvent& event)
 988 {
 989     event.Enable(true);
 990     event.Check(true);
 991 }
 992
 993 void MyFrame::OnUpdateSubMenuRadio(wxUpdateUIEvent& event)
 994 {
 995     int which = (event.GetId() - Menu_SubMenu_Radio1 + 1);
 996     if (which == 2)
 997         event.Check(true);
 998     else
 999         event.Check(false);
1000 }
1001
1002 #if USE_CONTEXT_MENU
1003 void MyFrame::OnContextMenu(wxContextMenuEvent& event)
1004 {
1005     wxPoint point = event.GetPosition();
1006     // If from keyboard
1007     if (point.x == -1 && point.y == -1) {
1008         wxSize size = GetSize();
1009         point.x = size.x / 2;
1010         point.y = size.y / 2;
1011     } else {
1012         point = ScreenToClient(point);
1013     }
1014     ShowContextMenu(point);
1015 }
1016 #endif
1017
1018 void MyFrame::OnSize(wxSizeEvent& WXUNUSED(event))
1019 {
1020 #if USE_LOG_WINDOW
1021     if ( !m_textctrl )
1022         return;
1023
1024     // leave a band below for popup menu testing
1025     wxSize size = GetClientSize();
1026     m_textctrl->SetSize(0, 0, size.x, (3*size.y)/4);
1027 #endif
1028
1029     // this is really ugly but we have to do it as we can't just call
1030     // event.Skip() because wxFrameBase would make the text control fill the
1031     // entire frame then
1032 #ifdef __WXUNIVERSAL__
1033     PositionMenuBar();
1034 #endif // __WXUNIVERSAL__
1035 }
1036