| Version: 3.2.2

Hello World Example

This page shows a very simple wxWidgets program that can be used as a skeleton for your own code.

While it does nothing very useful, it introduces a couple of important concepts and explains how to write a working wxWidgets application. Trying building and running this application is also a good way of checking that wxWidgets is correctly installed on your system. And if you haven't installed wxWidgets yet, please do it first.

Note that this simple example creates the UI entirely from C++ code which is fine for a simple example, but more realistic examples will typically define their UI at least partially in XRC resource files.

First, you have to include wxWidgets' header files, of course. This can be done on a file by file basis (such as `wx/window.h`) or using one global include (`wx/wx.h`) which includes most of the commonly needed headers (although not all of them as there are simply too many wxWidgets headers to pull in all of them). For the platforms with support for precompiled headers, as indicated by `WX_PRECOMP`, this global header is already included by `wx/wxprec.h` so we only include it for the other ones:

// wxWidgets "Hello World" Program
// For compilers that support precompilation, includes "wx/wx.h".
#include <wx/wxprec.h>
#ifndef WX_PRECOMP
#include <wx/wx.h>
#endif

Practically every app should define a new class derived from wxApp. By overriding wxApp's OnInit() virtual method the program can be initialized, e.g. by creating a new main window.

class MyApp : public wxApp
{
public:
virtual bool OnInit();
};
wxAppConsole::OnInit
virtual bool OnInit()
This must be provided by the application, and will usually create the application's main window,...
wxApp
The wxApp class represents the application itself when wxUSE_GUI=1.
Definition: app.h:822

The main window is created by deriving a class from wxFrame and giving it a menu and a status bar in its constructor. Also, any class that wishes to respond to an "event" (such as mouse clicks, messages from the menu, or a button) must declare an event table using the macro below.

Finally, reacting to such events is done via "event handlers" which are just functions (or functors, including lambdas if you're using C++11) taking the `event` parameter of the type corresponding to the event being handled, e.g. wxCommandEvent for the events from simple controls such as buttons, text fields and also menu items. In our example, we react to three menu items: our custom "Hello", and the "Exit" and "About" items (any program should normally implement the latter two). Notice that these handlers don't need to be virtual or public.

class MyFrame : public wxFrame
{
public:
MyFrame();
private:
void OnHello(wxCommandEvent& event);
void OnExit(wxCommandEvent& event);
void OnAbout(wxCommandEvent& event);
};
wxCommandEvent
This event class contains information about command events, which originate from a variety of simple ...
Definition: event.h:2032
wxFrame
A frame is a window whose size and position can (usually) be changed by the user.
Definition: frame.h:164

In order to be able to react to a menu command, it must be given a unique identifier which can be defined as a const variable or an enum element. The latter is often used because typically many such constants will be needed:

enum
{
ID_Hello = 1
};

Notice that you don't need to define identifiers for "About" and "Exit", as wxWidgets already predefines standard values such as wxID_ABOUT and wxID_EXIT. You should use these whenever possible, as they can be handled in a special way by a particular platform.

As in all programs, there must be a "main" function. Under wxWidgets, main is implemented inside the wxIMPLEMENT_APP() macro, which creates an application instance of the specified class and starts running the GUI event loop. It is used simply as:

wxIMPLEMENT_APP(MyApp);
wxIMPLEMENT_APP
#define wxIMPLEMENT_APP(className)
This macro defines the application entry point and tells wxWidgets which application class should be ...
Definition: app.h:1237

As mentioned above, wxApp::OnInit() is called upon startup and should be used to initialize the program, maybe showing a "splash screen" and creating the main window (or several). Frames are created hidden by default, to allow the creation of child windows before displaying them. We thus need to explicitly show them. Finally, we return true from this method to indicate successful initialization:

bool MyApp::OnInit()
{
MyFrame *frame = new MyFrame();
frame->Show(true);
return true;
}

In the constructor of the main window (or later on), we create a menu with our menu items, as well as a status bar to be shown at the bottom of the main window. Both have to be bound to the frame with respective calls.

MyFrame::MyFrame()
: wxFrame(NULL, wxID_ANY, "Hello World")
{
wxMenu *menuFile = new wxMenu;
menuFile->Append(ID_Hello, "&Hello...\tCtrl-H",
"Help string shown in status bar for this menu item");
menuFile->AppendSeparator();
menuFile->Append(wxID_EXIT);
wxMenu *menuHelp = new wxMenu;
menuHelp->Append(wxID_ABOUT);
wxMenuBar *menuBar = new wxMenuBar;
menuBar->Append(menuFile, "&File");
menuBar->Append(menuHelp, "&Help");
SetMenuBar(menuBar);
CreateStatusBar();
SetStatusText("Welcome to wxWidgets!");
... continued below ...
wxID_ANY
@ wxID_ANY
Any id: means that we don't care about the id, whether when installing an event handler or when creat...
Definition: defs.h:597
wxID_EXIT
@ wxID_EXIT
Definition: defs.h:612
wxID_ABOUT
@ wxID_ABOUT
Definition: defs.h:620

Notice that we don't need to specify the labels for the standard menu items `wxID_ABOUT` and `wxID_EXIT` — they will be given standard (even correctly translated) labels and standard accelerators correct for the current platform, making our program behaviour more native. For this reason, you should prefer reusing the standard ids (see Stock Items) where possible.

We also have to connect our event handlers to the events we want to handle in them. We do this by calling Bind() to send all the menu events (identified by wxEVT_MENU event type) with the specified ID to the given function. The parameters we pass to Bind() are

1. The event type, e.g. wxEVT_MENU, wxEVT_BUTTON, wxEVT_SIZE, or one of many other events used by wxWidgets.
2. A Pointer to the method to call, and the object to call it on. In this case, we just call our own function, and pass the `this` pointer for the object itself. We could instead call the method of another object, or a non-member function — in fact, any object that can be called with a wxCommandEvent, can be used here.
3. An optional identifier, allowing us to select just some events of wxEVT_MENU type, namely those from the menu item with the given ID, instead of handling all of them in the provided handler. This is mainly useful with menu items and rarely with other kinds of events.

... continued from above ...
Bind(wxEVT_MENU, &MyFrame::OnHello, this, ID_Hello);
Bind(wxEVT_MENU, &MyFrame::OnAbout, this, wxID_ABOUT);
Bind(wxEVT_MENU, &MyFrame::OnExit, this, wxID_EXIT);
}
wxEVT_MENU
wxEventType wxEVT_MENU
Definition: event.h:5139

Here are the standard event handlers implementations. MyFrame::OnExit() closes the main window by calling Close(). The parameter true indicates that other windows have no veto power such as after asking "Do you really want to close?". If there is no other main window left, the application will quit.

void MyFrame::OnExit(wxCommandEvent& event)
{
Close(true);
}

MyFrame::OnAbout() will display a small window with some text in it. In this case a typical "About" window with information about the program.

void MyFrame::OnAbout(wxCommandEvent& event)
{
wxMessageBox("This is a wxWidgets Hello World example",
"About Hello World", wxOK | wxICON_INFORMATION);
}
wxICON_INFORMATION
#define wxICON_INFORMATION
Definition: defs.h:469
wxOK
#define wxOK
Definition: defs.h:452
wxMessageBox
int wxMessageBox(const wxString &message, const wxString &caption=wxMessageBoxCaptionStr, int style=wxOK|wxCENTRE, wxWindow *parent=NULL, int x=wxDefaultCoord, int y=wxDefaultCoord)
Show a general purpose message dialog.

The implementation of custom menu command handler may perform whatever task your program needs to do, in this case we will simply show a message from it as befits a Hello World example:

void MyFrame::OnHello(wxCommandEvent& event)
{
wxLogMessage("Hello world from wxWidgets!");
}
wxLogMessage
void wxLogMessage(const char *formatString,...)
For all normal, informational messages.

Note
  In C++11 programs, it can be convenient to use unnamed lambdas instead of functions for event handlers, especially when handling events from the controls as this allows to keep the code creating the control and handling its event together in the same place. Here, for example, we could replace the wxID_EXIT handler with just

Bind(wxEVT_MENU, [=](wxCommandEvent&) { Close(true); }, wxID_EXIT);

Here is the entire program that can be copied and pasted:

// wxWidgets "Hello World" Program
// For compilers that support precompilation, includes "wx/wx.h".
#include <wx/wxprec.h>
#ifndef WX_PRECOMP
#include <wx/wx.h>
#endif
class MyApp : public wxApp
{
public:
virtual bool OnInit();
};
class MyFrame : public wxFrame
{
public:
MyFrame();
private:
void OnHello(wxCommandEvent& event);
void OnExit(wxCommandEvent& event);
void OnAbout(wxCommandEvent& event);
};
enum
{
ID_Hello = 1
};
wxIMPLEMENT_APP(MyApp);
bool MyApp::OnInit()
{
MyFrame *frame = new MyFrame();
frame->Show(true);
return true;
}
MyFrame::MyFrame()
: wxFrame(NULL, wxID_ANY, "Hello World")
{
wxMenu *menuFile = new wxMenu;
menuFile->Append(ID_Hello, "&Hello...\tCtrl-H",
"Help string shown in status bar for this menu item");
menuFile->AppendSeparator();
menuFile->Append(wxID_EXIT);
wxMenu *menuHelp = new wxMenu;
menuHelp->Append(wxID_ABOUT);
wxMenuBar *menuBar = new wxMenuBar;
menuBar->Append(menuFile, "&File");
menuBar->Append(menuHelp, "&Help");
SetMenuBar( menuBar );
CreateStatusBar();
SetStatusText("Welcome to wxWidgets!");
Bind(wxEVT_MENU, &MyFrame::OnHello, this, ID_Hello);
Bind(wxEVT_MENU, &MyFrame::OnAbout, this, wxID_ABOUT);
Bind(wxEVT_MENU, &MyFrame::OnExit, this, wxID_EXIT);
}
void MyFrame::OnExit(wxCommandEvent& event)
{
Close(true);
}
void MyFrame::OnAbout(wxCommandEvent& event)
{
wxMessageBox("This is a wxWidgets Hello World example",
"About Hello World", wxOK | wxICON_INFORMATION);
}
void MyFrame::OnHello(wxCommandEvent& event)
{
wxLogMessage("Hello world from wxWidgets!");
}