C H A P T E R
3
Event Handling
This  chapter  explains  the  principles  behind  event-driven  programming  in
wxWidgets, including how events are generated, how an application handles
them using event tables, and where window identifiers fit in.We’ll also discuss
plug-in and dynamic event handlers, and we’ll describe how you can create
your own event class, types, and macros.
E
VENT
-D
RIVEN
P
ROGRAMMING
When programmers encountered an Apple Macintosh for the first time, they
were astonished at how different it was from the conventional computer expe-
rience of the period. Moving the pointer from one window to another, playing
with scrollbars, menus, text controls and so on, it was hard to imagine how the
underlying code sorted out this fabulous complexity. It seemed that many dif-
ferent things were going on in parallel—in reality, a clever illusion. For many
people, the Macintosh was their first introduction to the world of event-driven
programming.
All GUI applications are event-driven. That is to say, the application sits
in a loop waiting for events initiated by the user or from some other source
(such as a window needing to be refreshed, or a socket connection), and then
dispatches the event to an appropriate function that handles it. Although it
may seem that windows are being updated simultaneously, most GUI applica-
tions are not multithreaded, so each task is being done in turn—as becomes
painfully obvious when something slows your computer to a crawl and you can
see each window being repainted, one after the other.
Different frameworks have different ways of exposing event handling to
the developer—the primary method in wxWidgets is the use of event tables, as
explained in the next section.
25
Pdf extract images - Select, copy, paste PDF images in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support PDF Image Extraction from a Page, a Region on a Page, and PDF Document
extract image from pdf; extract images from pdf acrobat
Pdf extract images - VB.NET PDF Image Extract Library: Select, copy, paste PDF images in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support PDF Image Extraction from a Page, a Region on a Page, and PDF Document
extract images from pdf c#; how to extract a picture from a pdf
26
Event Handling Chapter 3
E
VENT
T
ABLES AND
H
ANDLERS
The wxWidgets event processing system is a more flexible mechanism than
virtual functions, allowing us to avoid declaring all possible event handlers in
a base class, which would be totally impractical as well as inefficient.
Every class  that  derives from 
wxEvtHandler
,including frames, buttons,
menus,and even documents,can contain an event table to tell wxWidgets how
events  are  routed  to  handler  functions. All  window  classes  (derived  from
wxWindow
), and the application class, are derived from 
wxEvtHandler
.
To create a static event table (one that’s created at compile time),you need to
1. Declare a new class that is derived directly or indirectly from 
wxEvtHandler
.
2. Add a member function for each event that must be handled.
3. Declare the event table in the class with 
DECLARE_EVENT_TABLE
.
4. Implement the event table in the source file  with 
BEGIN_EVENT_TABLE
...
END_EVENT_TABLE
.
5. Add event table entries to the table (such as 
EVT_BUTTON
), mapping each
event to the appropriate member function.
All event handler functions have the same form—their return type is void,
they are not virtual, and they take a single event object argument. (If you’re
familiar with MFC, this will come as a relief, because there is no standard sig-
nature  for message handlers in  MFC.) The type of  this  argument changes
according to the type of event being handled; for example, simple control com-
mands  and  menu  commands  share  the 
wxCommandEvent
class. A  size  event
(caused by a window being resized either by the program or by the user) is rep-
resented by the 
wxSizeEvent
class. Each event type has different accessors that
you can use to learn about the cause of the event or the resulting UI change,
such as a change in the value of a text control. In simple cases (such as a but-
ton press), you can often ignore the event object.
Expanding on the example from the previous chapter, let’s add a handler
for frame sizing, plus an OK button. A simple class declaration for an event-
handling class looks like this:
// Declare our main frame class
class MyFrame : public wxFrame
{
public:
// Constructor
MyFrame(const wxString& title);
// Event handlers
void OnQuit(wxCommandEvent& event);
void OnAbout(wxCommandEvent& event);
void OnSize(wxSizeEvent& event);
void OnButtonOK(wxCommandEvent& event);
private:
// This class handles events
DECLARE_EVENT_TABLE()
};
C# PDF Text Extract Library: extract text content from PDF file in
Ability to extract highlighted text out of PDF document. Image text extraction control provides text extraction from PDF images and image files.
some pdf image extract; extract jpeg from pdf
VB.NET PDF Text Extract Library: extract text content from PDF
Extract highlighted text out of PDF document. Image text extraction control provides text extraction from PDF images and image files.
extract images from pdf c#; extract image from pdf using
The  code  to  add  menu  items  will  be  similar  to the  code  in  the  previous 
chapter, while code to add an OK button might look like this, in the frame 
constructor:
wxButton* button = new wxButton(this, wxID_OK, wxT(“OK”),
wxPoint(200, 200));
Here’s the event table, allowing the frame to handle menu, button, and size
events.
// Event table for MyFrame
BEGIN_EVENT_TABLE(MyFrame, wxFrame)
EVT_MENU     (wxID_ABOUT,    MyFrame::OnAbout)
EVT_MENU     (wxID_EXIT,
MyFrame::OnQuit)
EVT_SIZE     (              MyFrame::OnSize)
EVT_BUTTON   (wxID_OK,       MyFrame::OnButtonOK)
END_EVENT_TABLE()
When the user clicks on the About or Quit menu items, the event is sent to the
frame, and 
MyFrame
’s event table tells wxWidgets that a menu event with iden-
tifier 
wxID_ABOUT
should be sent to 
MyFrame::OnAbout
,and a menu event with
identifier 
wxID_EXIT
should be sent to 
MyFrame::OnQuit
.In other words, these
functions will be called with a single argument (in this case,
wxCommandEvent
)
when the event loop processes the events.
The 
EVT_SIZE
macro does not take an identifier argument because a size
event can only be handled by the object that generated it.
The 
EVT_BUTTON
entry will cause 
OnButtonOK
to be called when a button in
the frame’s window hierarchy with identifier 
wxID_OK
is pressed. This example
shows that the event can be processed by a window other than the source of
the event. Let’s assume the button is a child of 
MyFrame
.When the button is
pressed, wxWidgets will check the 
wxButton
class for a suitable handler. When
one is not found, it checks the parent of the button—in this case, a 
MyFrame
instance. The  event  matches  an  entry  in  the  event  table, so
MyFrame::OnButtonOK
is called. This search of the window component hierarchy,
as well as the inheritance hierarchy, means that you can choose where you
handle  events. For example, if you  are designing a dialog class that  must
respond to commands such as 
wxID_OK
,but you need to leave the creation of the
actual controls  to  other programmers using your code, you can still define
default behavior for the controls as long as they have the expected identifiers.
The  generation  of  a  button  click  event  and  its  subsequent  matching
against an appropriate event table entry is illustrated in Figure 3-1. Two class
hierarchies are shown, for 
wxButton
and 
MyFrame
.Each class has its own event
table that potentially contains the entry that will match the event. When the
user clicks on the OK button, a new 
wxCommandEvent
object is created that con-
tains  the  identifier  (
wxID_OK
 and  the  type  of  event  (
wxEVT_COMMAND_BUTTON_
CLICKED
). Now the event tables are searched using 
wxEvtHandler::ProcessEvent
;
Event Tables and Handlers
27
C# Create PDF from images Library to convert Jpeg, png images to
Create PDF from Images. |. Home ›› XDoc.PDF ›› C# PDF: Create PDF from Images. C#.NET PDF - Create PDF from Images in C# with XDoc.NET PDF Control.
extract color image from pdf in c#; pdf image extractor c#
VB.NET PDF Page Extract Library: copy, paste, cut PDF pages in vb.
VB.NET: Extract All Images from PDF Document. This is an example that you can use it to extract all images from PDF document. ' Get page 3 from the document.
extract jpg pdf; how to extract text from pdf image file
all  of  the 
wxButton
’s  event  table  events  are  tried, then 
wxControl
’s, then
wxWindow
’s.If no appropriate entry is found that matches against the event type
and identifier, wxWidgets tries the parent of the button and starts searching
its event table. It has a matching entry:
EVT_BUTTON(wxID_OK,MyFrame::OnButtonOK)
so 
MyFrame::OnButtonOK
is called.
Note that only command events (whose event classes are based directly
or indirectly on 
wxCommandEvent
) are recursively applied to the window parent’s
event handler. As this quite often causes confusion for users, here is a list of
system events that will not get sent to the parent’s event handler:
wxActivate
Event
,
wxCloseEvent
,
wxEraseEvent
,
wxFocusEvent
,
wxKeyEvent
,
wxIdleEvent
,
wxInitDialogEvent
,
wxJoystickEvent
,
wxMenuEvent
,
wxMouseEvent
,
wxMoveEvent
,
wxPaintEvent
,
wxQueryLayoutInfoEvent, wxSizeEvent, wxScrollWinEvent,
and
wxSysColourChangedEvent.
These events do not propagate because they are meant for a particular
window, and sending a child’s paint event to its parent, for example, does not
make sense.
28
Event Handling Chapter 3
Event table
Event table
Event table
Event table
Event table
Event table
Event table
wxCommandEvent
wxEVT_COMMAND_BUTTON_CLICKED
id=wxID_OK
2.Event tables
are searched.
wxButton
wxControl
wxWindow
Instance of MyFrame
OK
MyFrame
wxFrame
wxTopLevelWindow
wxWindow
child of
wxCommandEvent
wxEVT_..._CLICKED
id=wxID_OK
MyFrame::OnButtonOK
1. Clicking OK
generates an
event.   
3. An entry
matched and the
function is called.
Figure 3-1 Processing a button click event
C# PDF Convert to Images SDK: Convert PDF to png, gif images in C#
C#.NET PDF SDK - Convert & Render PDF to Images in C#.NET. Free .NET DLLs for converting PDF to images in both .NET WinForms and ASP.NET application.
extract images pdf acrobat; how to extract images from pdf in acrobat
C# PDF Page Extract Library: copy, paste, cut PDF pages in C#.net
|. Home ›› XDoc.PDF ›› C# PDF: Extract, Copy and Paste PDF Pages. C#.NET Sample Code: Extract PDF Pages and Save into a New PDF File in C#.NET.
extract image from pdf java; extract pictures pdf
S
KIPPING
E
VENTS
The wxWidgets event processing system implements something very close to
virtual methods in normal C++, which means that it is possible to alter the
behavior of a class by overriding its event handling functions. In many cases,
this works even for changing the behavior of native controls. For example, it is
possible to filter out selected keystroke events sent by the system to a native
text control by overriding 
wxTextCtrl
and defining a handler for key events
using 
EVT_KEY_DOWN
.This would indeed prevent any key events from being sent
to the native control, which might not be what is desired. In this case, the
event handler function has to call 
wxEvent::Skip
to indicate that the search for
the event handler should continue.
To summarize, instead of explicitly calling the base class version, as you
would have done with C++ virtual functions, you should instead call 
Skip
on
the event object.
For example, to make the derived text control only accept “a” to “z” and
“A” to “Z,” we would use this code:
void MyTextCtrl::OnChar(wxKeyEvent& event)
{
if ( wxIsalpha( event.KeyCode() ) )
{
// Keycode is within range, so do normal processing.
event.Skip();
}
else
{
// Illegal keystroke. We don’t call event.Skip() so the
// event is not processed anywhere else.
wxBell();
}
}
P
LUGGABLE
E
VENT
H
ANDLERS
You don’t have to derive a new class from a window class in order to process
events. Instead, you  can  derive  a new  class  from 
wxEvtHandler
, define  the
appropriate event table, and then call 
wxWindow::PushEventHandler
to add this
object to the window’s stack of event handlers. Your new event handler will
catch events first;if they are not processed,the next event handler in the stack
will be searched, and so on. Use 
wxWindow::PopEventHandler
to pop the topmost
event handler off the stack, passing 
true
if you want it to be deleted.
With this method, you can avoid a lot of class derivation and potentially
use  the  same  event  handler  object  to  handle  events  from  instances  of 
different classes.
Pluggable Event Handlers
29
VB.NET Create PDF from images Library to convert Jpeg, png images
Create PDF from Images. |. Home ›› XDoc.PDF ›› VB.NET PDF: Create PDF from Images. NET converter control for exporting high quality PDF from images.
how to extract a picture from a pdf; extract jpg from pdf
C# PDF Convert to Jpeg SDK: Convert PDF to JPEG images in C#.net
Following demo code will show how to convert all PDF pages to Jpeg images with C# .NET. // Load a PDF file. String inputFilePath
some pdf image extractor; extract photo from pdf
Normally, the value returned from 
wxWindow::GetEventHandler
is the win-
dow itself, but if you have used 
PushEventHandler
,this will not be the case. If
you ever have to call a window’s event handler manually, use the 
GetEvent
Handler
function to retrieve the window’s topmost event handler and use that
to call the member function in order to ensure correct processing of the event
handler stack.
One use of 
PushEventHandler
is to temporarily or permanently change the
behavior of the GUI. For example, you might want to invoke a dialog editor in
your application. You can grab all the mouse input for an existing dialog box
and its controls, processing events for dragging sizing handles and moving
controls, before restoring the dialog’s normal mouse behavior. This could be a
useful technique for online tutorials, where you take a user through a series of
steps and don’t want them to diverge from the lesson. Here, you can examine
the events coming from buttons and windows and, if acceptable, pass them
through to the original event handler using 
wxEvent::Skip
.Events not handled
by your event handler will pass through to the window’s event table.
D
YNAMIC
E
VENT
H
ANDLERS
We  have  discussed  event  handling  mostly  in  terms  of  static  event  tables
because this is the most common way to handle events. However, you can also
specify the mapping between events and their handlers at runtime.You might
use this method because you want to use different event handlers at different
times in your program, or because you are using a different language (such as
Python) that can’t use static event tables, or simply because  you prefer it.
Event handlers allow greater granularity—you can turn individual event han-
dlers on and off at runtime, whereas 
PushEventHandler
and 
PopEventHandler
deal with a whole event table. Plus, they allow sharing of event handler func-
tions between different objects.
There  are  two  functions  associated  with  dynamic  event  tables:
wxEvtHandler::Connect
and 
wxEvtHandler::Disconnect
.Often, you won’t need to
call 
wxEvtHandler::Disconnect
because the disconnection will happen when the
window object is destroyed.
Let’s use our simple frame class with two event handlers as an example.
// Declare our main frame class
class MyFrame : public wxFrame
{
public:
// Constructor
MyFrame(const wxString& title);
// Event handlers
void OnQuit(wxCommandEvent& event);
void OnAbout(wxCommandEvent& event);
private:
};
30
Event Handling Chapter 3
Notice that this time, we do not use the 
DECLARE_EVENT_TABLE
macro. To specify
event handling dynamically, we add a couple of lines to our application class’s
OnInit
function:
frame->Connect( wxID_EXIT,
wxEVT_COMMAND_MENU_SELECTED,
wxCommandEventHandler(MyFrame::OnQuit) );
frame->Connect( wxID_ABOUT,
wxEVT_COMMAND_MENU_SELECTED,
wxCommandEventHandler(MyFrame::OnAbout) );
We pass to 
Connect
the window identifier, the event identifier, and finally a
pointer  to  the  event  handler  function. Note  that  the  event  identifier
(
wxEVT_COMMAND_MENU_SELECTED
 is  different  from  the  event  table  macro
(
EVT_MENU
); the event table macro makes use of the event identifier internally.
The 
wxCommandEventHandler
macro around the function name is necessary to
appease the compiler—casts are done by static event table macros automati-
cally. In general, if you have a handler that takes an event called 
wxXYZEvent
,
then  in  your 
Connect
call, you  will  wrap  the  function  name  in  the  macro
wxXYZEventHandler
.
If we want to remove the mapping between event and handler function,
we can use the 
wxEvtHandler::Disconnect
function, as follows:
frame->Disconnect( wxID_EXIT,
wxEVT_COMMAND_MENU_SELECTED,
wxCommandEventHandler(MyFrame::OnQuit) );
frame->Disconnect( wxID_ABOUT,
wxEVT_COMMAND_MENU_SELECTED,
wxCommandEventFunction(MyFrame::OnAbout) );
W
INDOW
I
DENTIFIERS
Window identifiers are integers, and are used to uniquely determine window
identity in the event system.In fact,identifiers do not need to be unique across
your entire application, just  unique  within a particular context, such  as  a
frame and its children.You may use the 
wxID_OK
identifier, for example, on any
number of dialogs as long as you don’t have several within the same dialog.
If you pass 
wxID_ANY
to a window constructor, an identifier will be gener-
ated for you automatically by wxWidgets. This is useful when you don’t care
about the exact identifier, either because you’re not going to process the events
from the control being created at all, or because you process the events from
all controls in one place. In this case, you should specify 
wxID_ANY
in the event
table  or 
wxEvtHandler::Connect
call  as  well. The  generated  identifiers  are
Window Identifiers
31
Table 3-1 Standard Window Identifiers
Identifier Name
Description
wxID_ANY
This may be passed to a window constructor as an
identifier, and wxWidgets will generate an appro-
priate identifier
wxID_LOWEST
The lowest standard identifier value (4999)
wxID_HIGHEST
The highest standard identifier value (5999)
wxID_OPEN
File open
wxID_CLOSE
Window close
wxID_NEW
New window, file or document
wxID_SAVE
File save
wxID_SAVEAS
File save as (prompts for a save dialog)
wxID_REVERT
Revert (revert to file on disk)
wxID_EXIT
Exit application
wxID_UNDO
Undo the last operation
wxID_REDO
Redo the last undo
wxID_HELP
General help (for example, for dialog Help 
buttons)
wxID_PRINT
Print
wxID_PRINT_SETUP
Print setup dialog
wxID_PREVIEW
Print preview
wxID_ABOUT
Show a dialog describing the application
wxID_HELP_CONTENTS
Show the help contents
wxID_HELP_COMMANDS
Show the application commands
wxID_HELP_PROCEDURES
Show the application procedures
always negative, so they will never conflict with the user-specified identifiers,
which must always be positive.
wxWidgets supplies the standard identifiers listed in Table 3-1. Use the
standard identifiers wherever possible: some systems can use the information
to provide standard graphics (such as the OK and Cancel buttons on GTK+) or
default  behavior  (such  as  responding  to  the  Escape  key  by  emulating  a
wxID_CANCEL
event). On Mac OS X,
wxID_ABOUT
,
wxID_PREFERENCES
and 
wxID_EXIT
menu items are interpreted specially and transferred to the application menu.
Some wxWidgets components, such as 
wxTextCtrl
,know how to handle menu
items or buttons with identifiers such as 
wxID_COPY
,
wxID_PASTE
,
wxID_UNDO
.
You can use 
wxID_HIGHEST
to determine the number above which it is safe
to define your own identifiers, or you can use identifiers below 
wxID_LOWEST
.
32
Event Handling Chapter 3
Identifier Name
Description
wxID_HELP_CONTEXT
Unused
wxID_CUT
Cut
wxID_COPY
Copy
wxID_PASTE
Paste
wxID_CLEAR
Clear
wxID_FIND
Find
wxID_DUPLICATE
Duplicate
wxID_SELECTALL
Select all
wxID_DELETE
Delete (cut without copying)
wxID_REPLACE
Replace
wxID_REPLACE_ALL
Replace all
wxID_PROPERTIES
Show properties for the selection
wxID_VIEW_DETAILS
View details in a list control
wxID_VIEW_LARGEICONS
View as large icons in a list control
wxID_VIEW_SMALLICONS
View as small icons in a list control
wxID_VIEW_LIST
View as a list in a list control
wxID_VIEW_SORTDATE
Sort by date
wxID_VIEW_SORTNAME
Sort by name
wxID_VIEW_SORTSIZE
Sort by size
wxID_VIEW_SORTTYPE
Sort by type
wxID_FILE1
to 
wxID_FILE9
View recent file
wxID_OK
Confirms dialog selections
wxID_CANCEL
Vetoes dialog selections
wxID_APPLY
Applies selections to data
wxID_YES
Identifier for a Yes button
wxID_NO
Identifier for a No button
wxID_STATIC
Identifier for static text or bitmap control
wxID_FORWARD
Navigate forward
wxID_BACKWARD
Navigate backward
wxID_DEFAULT
Restore default settings
wxID_MORE
View more settings
wxID_SETUP
View a setup dialog
wxID_RESET
Reset settings
Window Identifiers
33
(continues)
Table 3-1 Standard Window Identifiers
(Continued)
Identifier Name
Description
wxID_CONTEXT_HELP
Show context-sensitive help
wxID_YESTOALL
Reply yes to all prompts
wxID_NOTOALL
Reply no to all prompts
wxID_ABORT
Abort the current operation
wxID_RETRY
Retry the operation
wxID_IGNORE
Ignore an error condition
wxID_UP
Navigate up
wxID_DOWN
Navigate down
wxID_HOME
Navigate home
wxID_REFRESH
Refresh
wxID_STOP
Stop the current operation
wxID_INDEX
Show an index
wxID_BOLD
Highlight in bold
wxID_ITALIC
Highlight in italic
wxID_JUSTIFY_CENTER
Center
wxID_JUSTIFY_FILL
Format
wxID_JUSTIFY_RIGHT
Right align
wxID_JUSTIFY_LEFT
Left align
wxID_UNDERLINE
Underline
wxID_INDENT
Indent
wxID_UNINDENT
Unindent
wxID_ZOOM_100
Zoom to 100%
wxID_ZOOM_FIT
Fit to page
wxID_ZOOM_IN
Zoom in
wxID_ZOOM_OUT
Zoom out
wxID_UNDELETE
Undelete
wxID_REVERT_TO_SAVED
Revert to saved state
34
Event Handling Chapter 3
D
EFINING
C
USTOM
E
VENTS
If you want to define your own event class and macros, you need to follow these
steps:
1. Derive your class from a suitable class, declaring dynamic type informa-
tion and including a 
Clone
function.You may or may not want to add data
members and accessors. Derive from 
wxCommandEvent
if you want the event
Documents you may be interested
Documents you may be interested