[wxWidgets.git] / samples / menu / menu.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        samples/menu.cpp
// Purpose:     wxMenu/wxMenuBar sample
// Author:      Vadim Zeitlin
// Modified by:
// Created:     01.11.99
// RCS-ID:      $Id$
// Copyright:   (c) 1999 Vadim Zeitlin
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

// ============================================================================
// declarations
// ============================================================================

// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------

// For compilers that support precompilation, includes "wx/wx.h".
#include <wx/wxprec.h>

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#ifndef WX_PRECOMP
    #include <wx/wx.h>

    #include <wx/log.h>
#endif

// ----------------------------------------------------------------------------
// classes
// ----------------------------------------------------------------------------

// Define a new application
class MyApp: public wxApp
{
public:
    bool OnInit();
};

// Define a new frame
class MyFrame: public wxFrame
{
public:
    MyFrame();

    virtual ~MyFrame() { delete m_menu; }

    void OnQuit(wxCommandEvent& event);
    void OnAbout(wxCommandEvent& event);

    void OnDummy(wxCommandEvent& event);

    void OnAppendMenuItem(wxCommandEvent& event);
    void OnAppendSubMenu(wxCommandEvent& event);
    void OnDeleteMenuItem(wxCommandEvent& event);
    void OnInsertMenuItem(wxCommandEvent& event);
    void OnCheckMenuItem(wxCommandEvent& event);
    void OnEnableMenuItem(wxCommandEvent& event);
    void OnGetLabelMenuItem(wxCommandEvent& event);
    void OnSetLabelMenuItem(wxCommandEvent& event);
    void OnGetMenuItemInfo(wxCommandEvent& event);

    void OnAppendMenu(wxCommandEvent& event);
    void OnInsertMenu(wxCommandEvent& event);
    void OnDeleteMenu(wxCommandEvent& event);
    void OnToggleMenu(wxCommandEvent& event);
    void OnEnableMenu(wxCommandEvent& event);
    void OnGetLabelMenu(wxCommandEvent& event);
    void OnSetLabelMenu(wxCommandEvent& event);

    void OnRightDown(wxMouseEvent& event);

    void OnUpdateCheckMenuItemUI(wxUpdateUIEvent& event);

private:
    wxMenu *CreateDummyMenu(wxString *title);

    wxMenuItem *GetLastMenuItem() const;

    wxMenu     *m_menu;

    size_t m_countDummy;

    DECLARE_EVENT_TABLE()
};

// ----------------------------------------------------------------------------
// constants
// ----------------------------------------------------------------------------

enum
{
    Menu_File_Quit = 100,

    Menu_MenuBar_Toggle = 200,
    Menu_MenuBar_Append,
    Menu_MenuBar_Insert,
    Menu_MenuBar_Delete,
    Menu_MenuBar_Enable,
    Menu_MenuBar_GetLabel,
    Menu_MenuBar_SetLabel,

    Menu_Menu_Append = 300,
    Menu_Menu_AppendSub,
    Menu_Menu_Insert,
    Menu_Menu_Delete,
    Menu_Menu_Enable,
    Menu_Menu_Check,
    Menu_Menu_GetLabel,
    Menu_Menu_SetLabel,
    Menu_Menu_GetInfo,

    Menu_Dummy_First = 400,
    Menu_Dummy_Second,
    Menu_Dummy_Third,
    Menu_Dummy_Fourth,
    Menu_Dummy_Last,

    Menu_Help_About = 1000,

    Menu_Popup_ToBeDeleted = 2000,
    Menu_Popup_ToBeGreyed,
    Menu_Popup_ToBeChecked,
    Menu_Popup_Submenu,

    Menu_Max
};

// ----------------------------------------------------------------------------
// event tables
// ----------------------------------------------------------------------------

BEGIN_EVENT_TABLE(MyFrame, wxFrame)
    EVT_MENU(Menu_File_Quit, MyFrame::OnQuit)

    EVT_MENU(Menu_Help_About, MyFrame::OnAbout)

    EVT_MENU(Menu_MenuBar_Toggle,   MyFrame::OnToggleMenu)
    EVT_MENU(Menu_MenuBar_Append,   MyFrame::OnAppendMenu)
    EVT_MENU(Menu_MenuBar_Insert,   MyFrame::OnInsertMenu)
    EVT_MENU(Menu_MenuBar_Delete,   MyFrame::OnDeleteMenu)
    EVT_MENU(Menu_MenuBar_Enable,   MyFrame::OnEnableMenu)
    EVT_MENU(Menu_MenuBar_GetLabel, MyFrame::OnGetLabelMenu)
    EVT_MENU(Menu_MenuBar_SetLabel, MyFrame::OnSetLabelMenu)

    EVT_MENU(Menu_Menu_Append,    MyFrame::OnAppendMenuItem)
    EVT_MENU(Menu_Menu_AppendSub, MyFrame::OnAppendSubMenu)
    EVT_MENU(Menu_Menu_Insert,    MyFrame::OnInsertMenuItem)
    EVT_MENU(Menu_Menu_Delete,    MyFrame::OnDeleteMenuItem)
    EVT_MENU(Menu_Menu_Enable,    MyFrame::OnEnableMenuItem)
    EVT_MENU(Menu_Menu_Check,     MyFrame::OnCheckMenuItem)
    EVT_MENU(Menu_Menu_GetLabel,  MyFrame::OnGetLabelMenuItem)
    EVT_MENU(Menu_Menu_SetLabel,  MyFrame::OnSetLabelMenuItem)
    EVT_MENU(Menu_Menu_GetInfo,   MyFrame::OnGetMenuItemInfo)

    EVT_MENU_RANGE(Menu_Dummy_First, Menu_Dummy_Last, MyFrame::OnDummy)

    EVT_UPDATE_UI(Menu_Menu_Check, MyFrame::OnUpdateCheckMenuItemUI)

    EVT_RIGHT_DOWN(MyFrame::OnRightDown)
END_EVENT_TABLE()

// ============================================================================
// implementation
// ============================================================================

// ----------------------------------------------------------------------------
// MyApp
// ----------------------------------------------------------------------------

IMPLEMENT_APP(MyApp)

// The `main program' equivalent, creating the windows and returning the
// main frame
bool MyApp::OnInit()
{
    // Create the main frame window
    MyFrame* frame = new MyFrame;

    frame->Show(TRUE);

    frame->SetStatusText("Hello, wxWindows");

    SetTopWindow(frame);

    return TRUE;
}

// ----------------------------------------------------------------------------
// MyFrame
// ----------------------------------------------------------------------------

// Define my frame constructor
MyFrame::MyFrame()
       : wxFrame((wxFrame *)NULL, -1, "wxWindows menu sample",
                 wxDefaultPosition, wxSize(300, 200))
{
    m_menu = NULL;
    m_countDummy = 0;

    CreateStatusBar();

    // create the menubar
    wxMenu *fileMenu = new wxMenu;
    fileMenu->Append(Menu_File_Quit, "E&xit\tAlt-X", "Quit toolbar sample" );

    wxMenu *menubarMenu = new wxMenu;
    menubarMenu->Append(Menu_MenuBar_Append, "&Append menu\tCtrl-A",
                        "Append a menu to the menubar");
    menubarMenu->Append(Menu_MenuBar_Insert, "&Insert menu\tCtrl-I",
                        "Insert a menu into the menubar");
    menubarMenu->Append(Menu_MenuBar_Delete, "&Delete menu\tCtrl-D",
                        "Delete the last menu from the menubar");
    menubarMenu->Append(Menu_MenuBar_Toggle, "&Toggle menu\tCtrl-T",
                        "Toggle the first menu in the menubar", TRUE);
    menubarMenu->AppendSeparator();
    menubarMenu->Append(Menu_MenuBar_Enable, "&Enable menu\tCtrl-E",
                        "Enable or disable the last menu", TRUE);
    menubarMenu->AppendSeparator();
    menubarMenu->Append(Menu_MenuBar_GetLabel, "&Get menu label\tCtrl-G",
                        "Get the label of the last menu");
    menubarMenu->Append(Menu_MenuBar_SetLabel, "&Set menu label\tCtrl-S",
                        "Change the label of the last menu");

    wxMenu *menuMenu = new wxMenu;
    menuMenu->Append(Menu_Menu_Append, "&Append menu item\tAlt-A",
                     "Append a menu item to the last menu");
    menuMenu->Append(Menu_Menu_AppendSub, "&Append sub menu\tAlt-S",
                     "Append a sub menu to the last menu");
    menuMenu->Append(Menu_Menu_Insert, "&Insert menu item\tAlt-I",
                     "Insert a menu item in head of the last menu");
    menuMenu->Append(Menu_Menu_Delete, "&Delete menu item\tAlt-D",
                     "Delete the last menu item from the last menu");
    menuMenu->AppendSeparator();
    menuMenu->Append(Menu_Menu_Enable, "&Enable menu item\tAlt-E",
                     "Enable or disable the last menu item", TRUE);
    menuMenu->Append(Menu_Menu_Check, "&Check menu item\tAlt-C",
                     "Check or uncheck the last menu item", TRUE);
    menuMenu->AppendSeparator();
    menuMenu->Append(Menu_Menu_GetLabel, "&Get menu item label\tAlt-G",
                     "Get the label of the last menu item");
    menuMenu->Append(Menu_Menu_SetLabel, "&Set menu item label\tAlt-S",
                     "Change the label of the last menu item");
    menuMenu->AppendSeparator();
    menuMenu->Append(Menu_Menu_GetInfo, "Get menu item in&fo\tAlt-F",
                     "Show the state of the last menu item");

    wxMenu *helpMenu = new wxMenu;
    helpMenu->Append(Menu_Help_About, "&About\tF1", "About menu sample");

    wxMenuBar* menuBar = new wxMenuBar( wxMB_DOCKABLE );

    menuBar->Append(fileMenu, "&File");
    menuBar->Append(menubarMenu, "Menu&bar");
    menuBar->Append(menuMenu, "&Menu");
    menuBar->Append(helpMenu, "&Help");

    // these items should be initially checked
    menuBar->Check(Menu_MenuBar_Toggle, TRUE);
    menuBar->Check(Menu_MenuBar_Enable, TRUE);
    menuBar->Check(Menu_Menu_Enable, TRUE);
    menuBar->Check(Menu_Menu_Check, FALSE);

    // associate the menu bar with the frame
    SetMenuBar(menuBar);
}

wxMenu *MyFrame::CreateDummyMenu(wxString *title)
{
    wxMenu *menu = new wxMenu;
    menu->Append(Menu_Dummy_First, "First item\tCtrl-F1");
    menu->AppendSeparator();
    menu->Append(Menu_Dummy_Second, "Second item\tCtrl-F2", "", TRUE);

    if ( title )
    {
        title->Printf("Dummy menu &%d", ++m_countDummy);
    }

    return menu;
}

wxMenuItem *MyFrame::GetLastMenuItem() const
{
    wxMenuBar *menubar = GetMenuBar();
    wxMenu *menu = menubar->GetMenu(menubar->GetMenuCount() - 1);

    wxMenuItemList::Node *node = menu->GetMenuItems().GetLast();
    if ( !node )
    {
        wxLogWarning("No last item in the last menu!");

        return NULL;
    }
    else
    {
        return node->GetData();
    }
}

void MyFrame::OnQuit(wxCommandEvent& WXUNUSED(event))
{
    Close(TRUE);
}

void MyFrame::OnAbout(wxCommandEvent& WXUNUSED(event))
{
    (void)wxMessageBox("wxWindows toolbar sample",
                       "About wxWindows menu sample",
                       wxICON_INFORMATION);
}

void MyFrame::OnDeleteMenu(wxCommandEvent& WXUNUSED(event))
{
    wxMenuBar *mbar = GetMenuBar();

    size_t count = mbar->GetMenuCount();
    if ( count == 2 )
    {
        // don't let delete the first 2 menus
        wxLogError("Can't delete any more menus");
    }
    else
    {
        delete mbar->Remove(count - 1);
    }
}

void MyFrame::OnInsertMenu(wxCommandEvent& WXUNUSED(event))
{
    wxString title;
    wxMenu *menu = CreateDummyMenu(&title);
    GetMenuBar()->Insert(0, menu, title);
}

void MyFrame::OnAppendMenu(wxCommandEvent& WXUNUSED(event))
{
    wxString title;
    wxMenu *menu = CreateDummyMenu(&title);
    GetMenuBar()->Append(menu, title);
}

void MyFrame::OnToggleMenu(wxCommandEvent& WXUNUSED(event))
{
    wxMenuBar *mbar = GetMenuBar();
    if ( !m_menu )
    {
        // hide the menu
        m_menu = mbar->Remove(0);
    }
    else
    {
        // restore it
        mbar->Insert(0, m_menu, "&File");
        m_menu = NULL;
    }
}

void MyFrame::OnEnableMenu(wxCommandEvent& WXUNUSED(event))
{
    wxMenuBar *mbar = GetMenuBar();
    size_t count = mbar->GetMenuCount();

    static bool s_enabled = TRUE;

    s_enabled = !s_enabled;
    mbar->EnableTop(count - 1, s_enabled);
}

void MyFrame::OnGetLabelMenu(wxCommandEvent& WXUNUSED(event))
{
    wxMenuBar *mbar = GetMenuBar();
    size_t count = mbar->GetMenuCount();

    wxLogMessage("The label of the last menu item is '%s'",
                 mbar->GetLabelTop(count - 1).c_str());
}

void MyFrame::OnSetLabelMenu(wxCommandEvent& WXUNUSED(event))
{
    wxMenuBar *mbar = GetMenuBar();
    size_t count = mbar->GetMenuCount();

    mbar->SetLabelTop(count - 1, "Dummy label &0");
}

void MyFrame::OnDummy(wxCommandEvent& event)
{
    wxString s;
    s.Printf("Dummy item #%d", event.GetId() - Menu_Dummy_First + 1);
    wxMessageBox(s, "Menu sample", wxICON_INFORMATION);
}

void MyFrame::OnAppendMenuItem(wxCommandEvent& WXUNUSED(event))
{
    wxMenuBar *menubar = GetMenuBar();
    wxMenu *menu = menubar->GetMenu(menubar->GetMenuCount() - 1);

    menu->AppendSeparator();
    menu->Append(Menu_Dummy_Third, "Third dummy item\tCtrl-F3",
                 "Checkable item", TRUE);
}

void MyFrame::OnAppendSubMenu(wxCommandEvent& WXUNUSED(event))
{
    wxMenuBar *menubar = GetMenuBar();
    
    wxMenu *menu = menubar->GetMenu(menubar->GetMenuCount() - 1);
    
    menu->Append(Menu_Dummy_Last, "Dummy sub menu\tCtrl-F2",
                 CreateDummyMenu(NULL));
}

void MyFrame::OnDeleteMenuItem(wxCommandEvent& WXUNUSED(event))
{
    wxMenuBar *menubar = GetMenuBar();
    wxMenu *menu = menubar->GetMenu(menubar->GetMenuCount() - 1);

    size_t count = menu->GetMenuItemCount();
    if ( !count )
    {
        wxLogWarning("No items to delete!");
    }
    else
    {
        menu->Destroy(menu->GetMenuItems().Item(count - 1)->GetData());
    }
}

void MyFrame::OnInsertMenuItem(wxCommandEvent& WXUNUSED(event))
{
    wxMenuBar *menubar = GetMenuBar();
    wxMenu *menu = menubar->GetMenu(menubar->GetMenuCount() - 1);

    menu->Insert(0, wxMenuItem::New(menu, Menu_Dummy_Fourth,
                                    "Fourth dummy item\tCtrl-F4"));
    menu->Insert(1, wxMenuItem::New(menu, wxID_SEPARATOR, ""));
}

void MyFrame::OnEnableMenuItem(wxCommandEvent& WXUNUSED(event))
{
    wxMenuItem *item = GetLastMenuItem();

    if ( item )
    {
        item->Enable(!item->IsEnabled());
    }
}

void MyFrame::OnCheckMenuItem(wxCommandEvent& WXUNUSED(event))
{
    wxMenuItem *item = GetLastMenuItem();

    item->Toggle();
}

void MyFrame::OnUpdateCheckMenuItemUI(wxUpdateUIEvent& event)
{
    wxLogNull nolog;

    wxMenuItem *item = GetLastMenuItem();

    event.Enable(item && item->IsCheckable());
}

void MyFrame::OnGetLabelMenuItem(wxCommandEvent& WXUNUSED(event))
{
    wxMenuItem *item = GetLastMenuItem();

    if ( item )
    {
        wxLogMessage("The label of the last menu item is '%s'",
                     item->GetLabel().c_str());
    }
}

void MyFrame::OnSetLabelMenuItem(wxCommandEvent& WXUNUSED(event))
{
    wxMenuItem *item = GetLastMenuItem();

    if ( item )
    {
        item->SetText("Dummy menu item text");
    }
}

void MyFrame::OnGetMenuItemInfo(wxCommandEvent& WXUNUSED(event))
{
    wxMenuItem *item = GetLastMenuItem();

    if ( item )
    {
        wxString msg;
        msg << "The item is " << (item->IsEnabled() ? "enabled"
                                                    : "disabled")
            << '\n';
                                            
        if ( item->IsCheckable() )
        {
            msg << "It is checkable and " << (item->IsChecked() ? "" : "un")
                << "checked\n";
        }

#if wxUSE_ACCEL
        wxAcceleratorEntry *accel = item->GetAccel();
        if ( accel )
        {
            msg << "Its accelerator is ";

            int flags = accel->GetFlags();
            if ( flags & wxACCEL_ALT )
                msg << wxT("Alt-");
            if ( flags & wxACCEL_CTRL )
                msg << wxT("Ctrl-");
            if ( flags & wxACCEL_SHIFT )
                msg << wxT("Shift-");

            int code = accel->GetKeyCode();
            switch ( code )
            {
                case WXK_F1:
                case WXK_F2:
                case WXK_F3:
                case WXK_F4:
                case WXK_F5:
                case WXK_F6:
                case WXK_F7:
                case WXK_F8:
                case WXK_F9:
                case WXK_F10:
                case WXK_F11:
                case WXK_F12:
                    msg << wxT('F') << code - WXK_F1 + 1;
                    break;

                // if there are any other keys wxGetAccelFromString() may return,
                // we should process them here

                default:
                    if ( wxIsalnum(code) )
                    {
                        msg << (wxChar)code;

                        break;
                    }

                    wxFAIL_MSG( wxT("unknown keyboard accel") );
            }

            delete accel;
        }
        else
        {
            msg << "It doesn't have an accelerator";
        }
#endif // wxUSE_ACCEL

        wxLogMessage(msg);
    }
}

void MyFrame::OnRightDown(wxMouseEvent &event )
{
    wxMenu menu("Test popup");

    menu.Append(Menu_Help_About, "&About");
    menu.Append(Menu_Popup_Submenu, "Submenu", CreateDummyMenu(NULL));
    menu.Append(Menu_Popup_ToBeDeleted, "To be deleted");
    menu.Append(Menu_Popup_ToBeChecked, "To be checked", "", TRUE);
    menu.Append(Menu_Popup_ToBeGreyed, "To be greyed");
    menu.AppendSeparator();
    menu.Append(Menu_File_Quit, "E&xit");

    //menu.Delete(Menu_Popup_ToBeDeleted);
    menu.Check(Menu_Popup_ToBeChecked, TRUE);
    menu.Enable(Menu_Popup_ToBeGreyed, FALSE);

    PopupMenu( &menu, event.GetX(), event.GetY() );
}
Commit	Line	Data
717a57c2 VZ	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/wx.h>
	29
	30	#include <wx/log.h>
	31	#endif
	32
	33	// ----------------------------------------------------------------------------
	34	// classes
	35	// ----------------------------------------------------------------------------
	36
	37	// Define a new application
	38	class MyApp: public wxApp
	39	{
	40	public:
	41	bool OnInit();
	42	};
	43
	44	// Define a new frame
	45	class MyFrame: public wxFrame
	46	{
	47	public:
	48	MyFrame();
	49
	50	virtual ~MyFrame() { delete m_menu; }
	51
	52	void OnQuit(wxCommandEvent& event);
	53	void OnAbout(wxCommandEvent& event);
	54
	55	void OnDummy(wxCommandEvent& event);
	56
	57	void OnAppendMenuItem(wxCommandEvent& event);
	58	void OnAppendSubMenu(wxCommandEvent& event);
	59	void OnDeleteMenuItem(wxCommandEvent& event);
	60	void OnInsertMenuItem(wxCommandEvent& event);
	61	void OnCheckMenuItem(wxCommandEvent& event);
	62	void OnEnableMenuItem(wxCommandEvent& event);
	63	void OnGetLabelMenuItem(wxCommandEvent& event);
	64	void OnSetLabelMenuItem(wxCommandEvent& event);
a80c322c	65	void OnGetMenuItemInfo(wxCommandEvent& event);
717a57c2 VZ	66
717a57c2 VZ	67	void OnAppendMenu(wxCommandEvent& event);
f03ec224	68	void OnInsertMenu(wxCommandEvent& event);
717a57c2 VZ	69	void OnDeleteMenu(wxCommandEvent& event);
	70	void OnToggleMenu(wxCommandEvent& event);
	71	void OnEnableMenu(wxCommandEvent& event);
	72	void OnGetLabelMenu(wxCommandEvent& event);
	73	void OnSetLabelMenu(wxCommandEvent& event);
	74
	75	void OnRightDown(wxMouseEvent& event);
	76
	77	void OnUpdateCheckMenuItemUI(wxUpdateUIEvent& event);
	78
	79	private:
f03ec224	80	wxMenu CreateDummyMenu(wxString title);
717a57c2 VZ	81
	82	wxMenuItem *GetLastMenuItem() const;
	83
	84	wxMenu *m_menu;
	85
f03ec224 VZ	86	size_t m_countDummy;
f03ec224 VZ	87
717a57c2 VZ	88	DECLARE_EVENT_TABLE()
	89	};
	90
	91	// ----------------------------------------------------------------------------
	92	// constants
	93	// ----------------------------------------------------------------------------
	94
	95	enum
	96	{
	97	Menu_File_Quit = 100,
	98
	99	Menu_MenuBar_Toggle = 200,
	100	Menu_MenuBar_Append,
f03ec224	101	Menu_MenuBar_Insert,
717a57c2 VZ	102	Menu_MenuBar_Delete,
	103	Menu_MenuBar_Enable,
	104	Menu_MenuBar_GetLabel,
	105	Menu_MenuBar_SetLabel,
	106
	107	Menu_Menu_Append = 300,
	108	Menu_Menu_AppendSub,
	109	Menu_Menu_Insert,
	110	Menu_Menu_Delete,
	111	Menu_Menu_Enable,
	112	Menu_Menu_Check,
	113	Menu_Menu_GetLabel,
	114	Menu_Menu_SetLabel,
a80c322c	115	Menu_Menu_GetInfo,
717a57c2 VZ	116
	117	Menu_Dummy_First = 400,
	118	Menu_Dummy_Second,
	119	Menu_Dummy_Third,
	120	Menu_Dummy_Fourth,
	121	Menu_Dummy_Last,
	122
	123	Menu_Help_About = 1000,
	124
	125	Menu_Popup_ToBeDeleted = 2000,
	126	Menu_Popup_ToBeGreyed,
	127	Menu_Popup_ToBeChecked,
	128	Menu_Popup_Submenu,
	129
	130	Menu_Max
	131	};
	132
	133	// ----------------------------------------------------------------------------
	134	// event tables
	135	// ----------------------------------------------------------------------------
	136
	137	BEGIN_EVENT_TABLE(MyFrame, wxFrame)
	138	EVT_MENU(Menu_File_Quit, MyFrame::OnQuit)
	139
	140	EVT_MENU(Menu_Help_About, MyFrame::OnAbout)
	141
	142	EVT_MENU(Menu_MenuBar_Toggle, MyFrame::OnToggleMenu)
	143	EVT_MENU(Menu_MenuBar_Append, MyFrame::OnAppendMenu)
f03ec224	144	EVT_MENU(Menu_MenuBar_Insert, MyFrame::OnInsertMenu)
717a57c2 VZ	145	EVT_MENU(Menu_MenuBar_Delete, MyFrame::OnDeleteMenu)
	146	EVT_MENU(Menu_MenuBar_Enable, MyFrame::OnEnableMenu)
	147	EVT_MENU(Menu_MenuBar_GetLabel, MyFrame::OnGetLabelMenu)
	148	EVT_MENU(Menu_MenuBar_SetLabel, MyFrame::OnSetLabelMenu)
	149
	150	EVT_MENU(Menu_Menu_Append, MyFrame::OnAppendMenuItem)
	151	EVT_MENU(Menu_Menu_AppendSub, MyFrame::OnAppendSubMenu)
	152	EVT_MENU(Menu_Menu_Insert, MyFrame::OnInsertMenuItem)
	153	EVT_MENU(Menu_Menu_Delete, MyFrame::OnDeleteMenuItem)
	154	EVT_MENU(Menu_Menu_Enable, MyFrame::OnEnableMenuItem)
a80c322c	155	EVT_MENU(Menu_Menu_Check, MyFrame::OnCheckMenuItem)
717a57c2 VZ	156	EVT_MENU(Menu_Menu_GetLabel, MyFrame::OnGetLabelMenuItem)
717a57c2 VZ	157	EVT_MENU(Menu_Menu_SetLabel, MyFrame::OnSetLabelMenuItem)
a80c322c	158	EVT_MENU(Menu_Menu_GetInfo, MyFrame::OnGetMenuItemInfo)
717a57c2 VZ	159
	160	EVT_MENU_RANGE(Menu_Dummy_First, Menu_Dummy_Last, MyFrame::OnDummy)
	161
	162	EVT_UPDATE_UI(Menu_Menu_Check, MyFrame::OnUpdateCheckMenuItemUI)
	163
	164	EVT_RIGHT_DOWN(MyFrame::OnRightDown)
	165	END_EVENT_TABLE()
	166
	167	// ============================================================================
	168	// implementation
	169	// ============================================================================
	170
	171	// ----------------------------------------------------------------------------
	172	// MyApp
	173	// ----------------------------------------------------------------------------
	174
	175	IMPLEMENT_APP(MyApp)
	176
	177	// The `main program' equivalent, creating the windows and returning the
	178	// main frame
	179	bool MyApp::OnInit()
	180	{
	181	// Create the main frame window
	182	MyFrame* frame = new MyFrame;
	183
	184	frame->Show(TRUE);
	185
	186	frame->SetStatusText("Hello, wxWindows");
	187
	188	SetTopWindow(frame);
	189
	190	return TRUE;
	191	}
	192
	193	// ----------------------------------------------------------------------------
	194	// MyFrame
	195	// ----------------------------------------------------------------------------
	196
	197	// Define my frame constructor
	198	MyFrame::MyFrame()
	199	: wxFrame((wxFrame *)NULL, -1, "wxWindows menu sample",
	200	wxDefaultPosition, wxSize(300, 200))
	201	{
	202	m_menu = NULL;
f03ec224	203	m_countDummy = 0;
717a57c2 VZ	204
	205	CreateStatusBar();
	206
	207	// create the menubar
	208	wxMenu *fileMenu = new wxMenu;
	209	fileMenu->Append(Menu_File_Quit, "E&xit\tAlt-X", "Quit toolbar sample" );
	210
	211	wxMenu *menubarMenu = new wxMenu;
	212	menubarMenu->Append(Menu_MenuBar_Append, "&Append menu\tCtrl-A",
	213	"Append a menu to the menubar");
f03ec224 VZ	214	menubarMenu->Append(Menu_MenuBar_Insert, "&Insert menu\tCtrl-I",
f03ec224 VZ	215	"Insert a menu into the menubar");
717a57c2 VZ	216	menubarMenu->Append(Menu_MenuBar_Delete, "&Delete menu\tCtrl-D",
	217	"Delete the last menu from the menubar");
	218	menubarMenu->Append(Menu_MenuBar_Toggle, "&Toggle menu\tCtrl-T",
	219	"Toggle the first menu in the menubar", TRUE);
	220	menubarMenu->AppendSeparator();
	221	menubarMenu->Append(Menu_MenuBar_Enable, "&Enable menu\tCtrl-E",
	222	"Enable or disable the last menu", TRUE);
	223	menubarMenu->AppendSeparator();
	224	menubarMenu->Append(Menu_MenuBar_GetLabel, "&Get menu label\tCtrl-G",
	225	"Get the label of the last menu");
	226	menubarMenu->Append(Menu_MenuBar_SetLabel, "&Set menu label\tCtrl-S",
	227	"Change the label of the last menu");
	228
	229	wxMenu *menuMenu = new wxMenu;
	230	menuMenu->Append(Menu_Menu_Append, "&Append menu item\tAlt-A",
	231	"Append a menu item to the last menu");
	232	menuMenu->Append(Menu_Menu_AppendSub, "&Append sub menu\tAlt-S",
	233	"Append a sub menu to the last menu");
	234	menuMenu->Append(Menu_Menu_Insert, "&Insert menu item\tAlt-I",
	235	"Insert a menu item in head of the last menu");
	236	menuMenu->Append(Menu_Menu_Delete, "&Delete menu item\tAlt-D",
	237	"Delete the last menu item from the last menu");
	238	menuMenu->AppendSeparator();
	239	menuMenu->Append(Menu_Menu_Enable, "&Enable menu item\tAlt-E",
	240	"Enable or disable the last menu item", TRUE);
	241	menuMenu->Append(Menu_Menu_Check, "&Check menu item\tAlt-C",
	242	"Check or uncheck the last menu item", TRUE);
	243	menuMenu->AppendSeparator();
	244	menuMenu->Append(Menu_Menu_GetLabel, "&Get menu item label\tAlt-G",
	245	"Get the label of the last menu item");
	246	menuMenu->Append(Menu_Menu_SetLabel, "&Set menu item label\tAlt-S",
	247	"Change the label of the last menu item");
a80c322c VZ	248	menuMenu->AppendSeparator();
	249	menuMenu->Append(Menu_Menu_GetInfo, "Get menu item in&fo\tAlt-F",
	250	"Show the state of the last menu item");
717a57c2 VZ	251
	252	wxMenu *helpMenu = new wxMenu;
	253	helpMenu->Append(Menu_Help_About, "&About\tF1", "About menu sample");
	254
	255	wxMenuBar* menuBar = new wxMenuBar( wxMB_DOCKABLE );
	256
	257	menuBar->Append(fileMenu, "&File");
	258	menuBar->Append(menubarMenu, "Menu&bar");
	259	menuBar->Append(menuMenu, "&Menu");
	260	menuBar->Append(helpMenu, "&Help");
	261
	262	// these items should be initially checked
	263	menuBar->Check(Menu_MenuBar_Toggle, TRUE);
	264	menuBar->Check(Menu_MenuBar_Enable, TRUE);
	265	menuBar->Check(Menu_Menu_Enable, TRUE);
	266	menuBar->Check(Menu_Menu_Check, FALSE);
	267
	268	// associate the menu bar with the frame
	269	SetMenuBar(menuBar);
	270	}
	271
f03ec224	272	wxMenu MyFrame::CreateDummyMenu(wxString title)
717a57c2 VZ	273	{
	274	wxMenu *menu = new wxMenu;
	275	menu->Append(Menu_Dummy_First, "First item\tCtrl-F1");
	276	menu->AppendSeparator();
	277	menu->Append(Menu_Dummy_Second, "Second item\tCtrl-F2", "", TRUE);
	278
f03ec224 VZ	279	if ( title )
	280	{
	281	title->Printf("Dummy menu &%d", ++m_countDummy);
	282	}
	283
717a57c2 VZ	284	return menu;
	285	}
	286
	287	wxMenuItem *MyFrame::GetLastMenuItem() const
	288	{
	289	wxMenuBar *menubar = GetMenuBar();
	290	wxMenu *menu = menubar->GetMenu(menubar->GetMenuCount() - 1);
	291
	292	wxMenuItemList::Node *node = menu->GetMenuItems().GetLast();
	293	if ( !node )
	294	{
	295	wxLogWarning("No last item in the last menu!");
	296
	297	return NULL;
	298	}
	299	else
	300	{
	301	return node->GetData();
	302	}
	303	}
	304
	305	void MyFrame::OnQuit(wxCommandEvent& WXUNUSED(event))
	306	{
	307	Close(TRUE);
	308	}
	309
	310	void MyFrame::OnAbout(wxCommandEvent& WXUNUSED(event))
	311	{
	312	(void)wxMessageBox("wxWindows toolbar sample",
	313	"About wxWindows menu sample",
	314	wxICON_INFORMATION);
	315	}
	316
	317	void MyFrame::OnDeleteMenu(wxCommandEvent& WXUNUSED(event))
	318	{
	319	wxMenuBar *mbar = GetMenuBar();
	320
	321	size_t count = mbar->GetMenuCount();
	322	if ( count == 2 )
	323	{
	324	// don't let delete the first 2 menus
	325	wxLogError("Can't delete any more menus");
	326	}
	327	else
	328	{
	329	delete mbar->Remove(count - 1);
	330	}
	331	}
	332
f03ec224	333	void MyFrame::OnInsertMenu(wxCommandEvent& WXUNUSED(event))
717a57c2	334	{
717a57c2	335	wxString title;
f03ec224 VZ	336	wxMenu *menu = CreateDummyMenu(&title);
	337	GetMenuBar()->Insert(0, menu, title);
	338	}
717a57c2	339
f03ec224 VZ	340	void MyFrame::OnAppendMenu(wxCommandEvent& WXUNUSED(event))
	341	{
	342	wxString title;
	343	wxMenu *menu = CreateDummyMenu(&title);
	344	GetMenuBar()->Append(menu, title);
717a57c2 VZ	345	}
	346
	347	void MyFrame::OnToggleMenu(wxCommandEvent& WXUNUSED(event))
	348	{
	349	wxMenuBar *mbar = GetMenuBar();
	350	if ( !m_menu )
	351	{
	352	// hide the menu
	353	m_menu = mbar->Remove(0);
	354	}
	355	else
	356	{
	357	// restore it
	358	mbar->Insert(0, m_menu, "&File");
	359	m_menu = NULL;
	360	}
	361	}
	362
	363	void MyFrame::OnEnableMenu(wxCommandEvent& WXUNUSED(event))
	364	{
	365	wxMenuBar *mbar = GetMenuBar();
	366	size_t count = mbar->GetMenuCount();
	367
	368	static bool s_enabled = TRUE;
	369
	370	s_enabled = !s_enabled;
	371	mbar->EnableTop(count - 1, s_enabled);
	372	}
	373
	374	void MyFrame::OnGetLabelMenu(wxCommandEvent& WXUNUSED(event))
	375	{
	376	wxMenuBar *mbar = GetMenuBar();
	377	size_t count = mbar->GetMenuCount();
	378
	379	wxLogMessage("The label of the last menu item is '%s'",
1987af7e	380	mbar->GetLabelTop(count - 1).c_str());
717a57c2 VZ	381	}
	382
	383	void MyFrame::OnSetLabelMenu(wxCommandEvent& WXUNUSED(event))
	384	{
	385	wxMenuBar *mbar = GetMenuBar();
	386	size_t count = mbar->GetMenuCount();
	387
	388	mbar->SetLabelTop(count - 1, "Dummy label &0");
	389	}
	390
	391	void MyFrame::OnDummy(wxCommandEvent& event)
	392	{
	393	wxString s;
	394	s.Printf("Dummy item #%d", event.GetId() - Menu_Dummy_First + 1);
	395	wxMessageBox(s, "Menu sample", wxICON_INFORMATION);
	396	}
	397
	398	void MyFrame::OnAppendMenuItem(wxCommandEvent& WXUNUSED(event))
	399	{
	400	wxMenuBar *menubar = GetMenuBar();
	401	wxMenu *menu = menubar->GetMenu(menubar->GetMenuCount() - 1);
	402
	403	menu->AppendSeparator();
	404	menu->Append(Menu_Dummy_Third, "Third dummy item\tCtrl-F3",
	405	"Checkable item", TRUE);
	406	}
	407
	408	void MyFrame::OnAppendSubMenu(wxCommandEvent& WXUNUSED(event))
	409	{
	410	wxMenuBar *menubar = GetMenuBar();
a583e623	411
717a57c2	412	wxMenu *menu = menubar->GetMenu(menubar->GetMenuCount() - 1);
a583e623 RR	413
a583e623 RR	414	menu->Append(Menu_Dummy_Last, "Dummy sub menu\tCtrl-F2",
f03ec224	415	CreateDummyMenu(NULL));
717a57c2 VZ	416	}
	417
	418	void MyFrame::OnDeleteMenuItem(wxCommandEvent& WXUNUSED(event))
	419	{
	420	wxMenuBar *menubar = GetMenuBar();
	421	wxMenu *menu = menubar->GetMenu(menubar->GetMenuCount() - 1);
	422
	423	size_t count = menu->GetMenuItemCount();
	424	if ( !count )
	425	{
	426	wxLogWarning("No items to delete!");
	427	}
	428	else
	429	{
	430	menu->Destroy(menu->GetMenuItems().Item(count - 1)->GetData());
	431	}
	432	}
	433
	434	void MyFrame::OnInsertMenuItem(wxCommandEvent& WXUNUSED(event))
	435	{
	436	wxMenuBar *menubar = GetMenuBar();
	437	wxMenu *menu = menubar->GetMenu(menubar->GetMenuCount() - 1);
	438
	439	menu->Insert(0, wxMenuItem::New(menu, Menu_Dummy_Fourth,
	440	"Fourth dummy item\tCtrl-F4"));
	441	menu->Insert(1, wxMenuItem::New(menu, wxID_SEPARATOR, ""));
	442	}
	443
	444	void MyFrame::OnEnableMenuItem(wxCommandEvent& WXUNUSED(event))
	445	{
	446	wxMenuItem *item = GetLastMenuItem();
	447
	448	if ( item )
	449	{
	450	item->Enable(!item->IsEnabled());
	451	}
	452	}
	453
	454	void MyFrame::OnCheckMenuItem(wxCommandEvent& WXUNUSED(event))
	455	{
	456	wxMenuItem *item = GetLastMenuItem();
	457
	458	item->Toggle();
	459	}
	460
	461	void MyFrame::OnUpdateCheckMenuItemUI(wxUpdateUIEvent& event)
	462	{
32db328c VZ	463	wxLogNull nolog;
32db328c VZ	464
717a57c2 VZ	465	wxMenuItem *item = GetLastMenuItem();
	466
	467	event.Enable(item && item->IsCheckable());
	468	}
	469
	470	void MyFrame::OnGetLabelMenuItem(wxCommandEvent& WXUNUSED(event))
	471	{
	472	wxMenuItem *item = GetLastMenuItem();
	473
	474	if ( item )
	475	{
	476	wxLogMessage("The label of the last menu item is '%s'",
1987af7e	477	item->GetLabel().c_str());
717a57c2 VZ	478	}
	479	}
	480
	481	void MyFrame::OnSetLabelMenuItem(wxCommandEvent& WXUNUSED(event))
	482	{
	483	wxMenuItem *item = GetLastMenuItem();
	484
	485	if ( item )
	486	{
	487	item->SetText("Dummy menu item text");
	488	}
	489	}
	490
a80c322c VZ	491	void MyFrame::OnGetMenuItemInfo(wxCommandEvent& WXUNUSED(event))
	492	{
	493	wxMenuItem *item = GetLastMenuItem();
	494
	495	if ( item )
	496	{
	497	wxString msg;
	498	msg << "The item is " << (item->IsEnabled() ? "enabled"
	499	: "disabled")
	500	<< '\n';
	501
	502	if ( item->IsCheckable() )
	503	{
	504	msg << "It is checkable and " << (item->IsChecked() ? "" : "un")
	505	<< "checked\n";
	506	}
	507
	508	#if wxUSE_ACCEL
	509	wxAcceleratorEntry *accel = item->GetAccel();
	510	if ( accel )
	511	{
	512	msg << "Its accelerator is ";
	513
	514	int flags = accel->GetFlags();
	515	if ( flags & wxACCEL_ALT )
	516	msg << wxT("Alt-");
	517	if ( flags & wxACCEL_CTRL )
	518	msg << wxT("Ctrl-");
	519	if ( flags & wxACCEL_SHIFT )
	520	msg << wxT("Shift-");
	521
	522	int code = accel->GetKeyCode();
	523	switch ( code )
	524	{
	525	case WXK_F1:
	526	case WXK_F2:
	527	case WXK_F3:
	528	case WXK_F4:
	529	case WXK_F5:
	530	case WXK_F6:
	531	case WXK_F7:
	532	case WXK_F8:
	533	case WXK_F9:
	534	case WXK_F10:
	535	case WXK_F11:
	536	case WXK_F12:
	537	msg << wxT('F') << code - WXK_F1 + 1;
	538	break;
	539
	540	// if there are any other keys wxGetAccelFromString() may return,
	541	// we should process them here
	542
	543	default:
	544	if ( wxIsalnum(code) )
	545	{
	546	msg << (wxChar)code;
	547
	548	break;
	549	}
	550
	551	wxFAIL_MSG( wxT("unknown keyboard accel") );
	552	}
	553
	554	delete accel;
555	}
556	else
557	{
558	msg << "It doesn't have an accelerator";
559	}
560	#endif // wxUSE_ACCEL
561
562	wxLogMessage(msg);
563	}
564	}
565
717a57c2 VZ	566	void MyFrame::OnRightDown(wxMouseEvent &event )
	567	{
	568	wxMenu menu("Test popup");
	569
	570	menu.Append(Menu_Help_About, "&About");
f03ec224	571	menu.Append(Menu_Popup_Submenu, "Submenu", CreateDummyMenu(NULL));
717a57c2 VZ	572	menu.Append(Menu_Popup_ToBeDeleted, "To be deleted");
	573	menu.Append(Menu_Popup_ToBeChecked, "To be checked", "", TRUE);
	574	menu.Append(Menu_Popup_ToBeGreyed, "To be greyed");
	575	menu.AppendSeparator();
	576	menu.Append(Menu_File_Quit, "E&xit");
	577
e66ad5c6	578	//menu.Delete(Menu_Popup_ToBeDeleted);
717a57c2 VZ	579	menu.Check(Menu_Popup_ToBeChecked, TRUE);
	580	menu.Enable(Menu_Popup_ToBeGreyed, FALSE);
	581
	582	PopupMenu( &menu, event.GetX(), event.GetY() );
	583	}