Programming with wxWindows - Using events

Fl_Menu_Item menuitems[] = 
 { { "&File", 0,0,0, FL_SUBMENU},
    { "&New", FL_ALT + 'n', (Fl_Callback *) new_cb }, 
    ...    
...

void new_cb(void)
{
  if (changed)
   if ( !check_save() ) return;

  filename[0] = '\0';
  input->value("");
  set_changed(0);

}

The progam fragment shows a menu item which has a function associated with it new_cb. The function is type-cast as a pointer to Fl_Callback. When the application receives a message from the operating system indicating that the New menu item was selected then the application can call new_cb().

The Win32 API also has a similar mechanism. A window that needs to respond to events has a function that is declared as a CALLBACK type function.

BEGIN_EVENT_TABLE (BasicFrame, wxFrame)
  EVT_MENU ( BASIC_EXIT,  BasicFrame::OnExit)
  EVT_MENU ( BASIC_ABOUT, BasicFrame::OnAbout)
  EVT_MENU ( BASIC_OPEN,  BasicFrame::OnOpenFile)
END_EVENT_TABLE()

#ifndef BASIC_H
#define BASIC_H

#include <wx/wx.h>

static const wxChar
 *TITLE =
    _T("Basic - Step 3: Responding to events");

class BasicApplication : public wxApp
{
  public:
	virtual bool OnInit();
};

class BasicFrame : public wxFrame
{
  public:
	BasicFrame( const wxChar *title, 
                    int xpos, int ypos,
                    int width, int height);
	~BasicFrame();

	wxTextCtrl *theText;
	wxMenuBar  *menuBar;
	wxMenu     *fileMenu;

	void OnOpenFile (wxCommandEvent & event);
	void OnAbout    (wxCommandEvent & event);
	void OnExit     (wxCommandEvent & event);

  DECLARE_EVENT_TABLE()
};

enum
{ BASIC_EXIT   	=   1,
  BASIC_OPEN	= 100,
  BASIC_ABOUT	= 200
};
#endif

Here is the header file, you will see a number of new things here and not all of them are related to events.

The first thing is the this odd piece of work:

static const wxChar
 *TITLE =
   _T("Basic - Step 3: Responding to events");

You can guess that we are declaring a pointer to a char, that it is a constant value and that it is static. In this particular example there is not much point to declaring the variable to be static. The reason for this is that we typically use static to ensure the value is retained between invocations of a function (internal static) or hide variables from other files (external static). Since we aren't using any other files in this example the static memory class is redundant. Nonetheless it is good practice to declare external or global variables, ie variables declared outside a function, as being static. The reason is that we might use this file elsewhere and want to head off the possibility of name clashes. See External variables - static and automatic to review the material on static variables.

The macro _T is a pseudonym for another macro wxTRANSLATE which has something to do with locale information, but what I don't yet know! But now to the event table matter:

You can see to the left we have three member functions, each is a void function and each has a wxCommandEvent argument. These are effectively our callback functions. There is also a macro DECLARE_EVENT_TABLE() which alerts the compiler to the fact that this class will have an event table. Last there is an enumerated range which we use to give some meaningful identifiers to some numeric values.

#include "basic.h"

IMPLEMENT_APP(BasicApplication)

bool BasicApplication::OnInit()
{
 ...
}

BasicFrame::BasicFrame
 ...
{
   ...

  fileMenu = new wxMenu;
  fileMenu->Append(BASIC_OPEN, "&Open file");
  fileMenu->Append(BASIC_ABOUT,"&About");
  fileMenu->AppendSeparator();
  fileMenu->Append(BASIC_EXIT, "E&xit");

  menuBar = new wxMenuBar;
  menuBar->Append(fileMenu, "&File");
  SetMenuBar(menuBar);
  CreateStatusBar(3);  
}

BasicFrame::~BasicFrame()
 ...

BEGIN_EVENT_TABLE (BasicFrame, wxFrame)
  EVT_MENU ( BASIC_EXIT,  BasicFrame::OnExit)
  EVT_MENU ( BASIC_ABOUT, BasicFrame::OnAbout)
  EVT_MENU ( BASIC_OPEN,  BasicFrame::OnOpenFile)
END_EVENT_TABLE()

void BasicFrame::OnOpenFile (wxCommandEvent & event)
{
  theText->LoadFile("data.txt");
}


void BasicFrame::OnAbout (wxCommandEvent & event)
{ wxString t = TITLE;

  t.append( _T("\nDB 2001"));
  
  wxMessageDialog
   aboutDialog
    ( this, t, "About Basic", wxOK | wxCANCEL);
  aboutDialog.ShowModal();
}

void BasicFrame::OnExit (wxCommandEvent & event)
{
  Close(TRUE);
}

To the left is the implementation file. Nothing has changed here except that we have added:

• An event table to map events to functions
• The member functions to handle the events

One way in which wxWindows helps the programmer to distinguish between the different kinds of events is in the provision of different kinds of macros. The table contains three EVT_MENU() macros which deal specifically with menu events. Amongst the other macros are:

• EVT_BUTTON
• EVT_CHECKBOX
• EVT_RADIOBUTTON
• EVT_SLIDER
• EVT_SCROLLBAR

The OnOpenFile method demonstrates how useful wxTextCtrl is. It has a method that will directly load the contents of a file into the control. When we click the "Open file" item of the File menu this triggers an event, the operating system catches it and notifies our application which then calls the appropriate function - load a file into theText.

The OnAbout method uses a new class wxMessageDialog. I am going to look at this class and the wxCommandEvent class later in this session. For now you can download the files wxbasic3.zip if you would like to try the example out.

wxWindows has an event macro which helps handle window sizing:

 EVT_SIZE ( BasicFrame::OnSize )

Add the size event to the example, create the OnSize event handler and in the handler write some code to get the window size and display it in the window title bar.

Hint: You might want to use a wxString and the wxString::Printf() method.

There is a sample if you get stuck wxbasic3a.zip.