]> git.saurik.com Git - wxWidgets.git/blame_incremental - include/wx/event.h
streamlining code
[wxWidgets.git] / include / wx / event.h
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: wx/event.h
3// Purpose: Event classes
4// Author: Julian Smart
5// Modified by:
6// Created: 01/02/97
7// RCS-ID: $Id$
8// Copyright: (c) wxWidgets team
9// Licence: wxWindows licence
10/////////////////////////////////////////////////////////////////////////////
11
12#ifndef _WX_EVENT_H_
13#define _WX_EVENT_H_
14
15#include "wx/defs.h"
16#include "wx/cpp.h"
17#include "wx/object.h"
18#include "wx/clntdata.h"
19
20#if wxUSE_GUI
21 #include "wx/gdicmn.h"
22 #include "wx/cursor.h"
23 #include "wx/mousestate.h"
24#endif
25
26#include "wx/dynarray.h"
27#include "wx/thread.h"
28#include "wx/tracker.h"
29
30#if !wxEVENTS_COMPATIBILITY_2_8
31 #include "wx/meta/convertible.h"
32#endif
33
34// ----------------------------------------------------------------------------
35// forward declarations
36// ----------------------------------------------------------------------------
37
38class WXDLLIMPEXP_FWD_BASE wxList;
39class WXDLLIMPEXP_FWD_BASE wxEvent;
40#if wxUSE_GUI
41 class WXDLLIMPEXP_FWD_CORE wxDC;
42 class WXDLLIMPEXP_FWD_CORE wxMenu;
43 class WXDLLIMPEXP_FWD_CORE wxWindow;
44 class WXDLLIMPEXP_FWD_CORE wxWindowBase;
45#endif // wxUSE_GUI
46
47// We operate with pointer to members of wxEvtHandler (such functions are used
48// as event handlers in the event tables or as arguments to Connect()) but by
49// default MSVC uses a restricted (but more efficient) representation of
50// pointers to members which can't deal with multiple base classes. To avoid
51// mysterious (as the compiler is not good enough to detect this and give a
52// sensible error message) errors in the user code as soon as it defines
53// classes inheriting from both wxEvtHandler (possibly indirectly, e.g. via
54// wxWindow) and something else (including our own wxTrackable but not limited
55// to it), we use the special MSVC keyword telling the compiler to use a more
56// general pointer to member representation for the classes inheriting from
57// wxEvtHandler.
58#ifdef __VISUALC__
59 #define wxMSVC_FWD_MULTIPLE_BASES __multiple_inheritance
60#else
61 #define wxMSVC_FWD_MULTIPLE_BASES
62#endif
63
64class WXDLLIMPEXP_FWD_BASE wxMSVC_FWD_MULTIPLE_BASES wxEvtHandler;
65class wxEventConnectionRef;
66
67// ----------------------------------------------------------------------------
68// Event types
69// ----------------------------------------------------------------------------
70
71typedef int wxEventType;
72
73#define wxEVT_ANY ((wxEventType)-1)
74
75// this is used to make the event table entry type safe, so that for an event
76// handler only a function with proper parameter list can be given. See also
77// the wxEVENT_HANDLER_CAST-macro.
78#define wxStaticCastEvent(type, val) static_cast<type>(val)
79
80#define DECLARE_EVENT_TABLE_ENTRY(type, winid, idLast, fn, obj) \
81 wxEventTableEntry(type, winid, idLast, wxNewEventFunctor(type, fn), obj)
82
83#define DECLARE_EVENT_TABLE_TERMINATOR() \
84 wxEventTableEntry(wxEVT_NULL, 0, 0, 0, 0)
85
86// obsolete event declaration/definition macros, we don't need them any longer
87// but we keep them for compatibility as it doesn't cost us anything anyhow
88#define BEGIN_DECLARE_EVENT_TYPES()
89#define END_DECLARE_EVENT_TYPES()
90#define DECLARE_EXPORTED_EVENT_TYPE(expdecl, name, value) \
91 extern expdecl const wxEventType name;
92#define DECLARE_EVENT_TYPE(name, value) \
93 DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_CORE, name, value)
94#define DECLARE_LOCAL_EVENT_TYPE(name, value) \
95 DECLARE_EXPORTED_EVENT_TYPE(wxEMPTY_PARAMETER_VALUE, name, value)
96#define DEFINE_EVENT_TYPE(name) const wxEventType name = wxNewEventType();
97#define DEFINE_LOCAL_EVENT_TYPE(name) DEFINE_EVENT_TYPE(name)
98
99// generate a new unique event type
100extern WXDLLIMPEXP_BASE wxEventType wxNewEventType();
101
102// New macros to create templatized event types:
103
104#if wxEVENTS_COMPATIBILITY_2_8
105
106 // Define/Declare a wxEventType-based event type:
107
108 #define wxDEFINE_EVENT( name, type ) \
109 const wxEventType name( wxNewEventType() )
110
111 #define wxDECLARE_EXPORTED_EVENT( expdecl, name, type ) \
112 extern const expdecl wxEventType name
113
114 // Define/Declare a wxEventType-based event type and initialize it with a
115 // predefined event type. (Only used for wxEVT_SPIN_XXX for backward
116 // compatibility)
117
118 #define wxDEFINE_EVENT_ALIAS( name, type, value ) \
119 const wxEventType name = value
120
121 #define wxDECLARE_EXPORTED_EVENT_ALIAS( expdecl, name, type ) \
122 extern const expdecl wxEventType name
123
124 // Declare a local (not exported) wxEventType-based event type:
125
126 #define wxDECLARE_EVENT( name, type ) \
127 wxDECLARE_EXPORTED_EVENT( wxEMPTY_PARAMETER_VALUE, name, type );
128
129#else
130 // Define/Declare a templatized event type with the corresponding event as
131 // a nested typedef:
132
133 #define wxDEFINE_EVENT( name, type ) \
134 const wxEventTypeTag< type > name( wxNewEventType() )
135
136 #define wxDECLARE_EXPORTED_EVENT( expdecl, name, type ) \
137 extern const expdecl wxEventTypeTag< type > name
138
139 // Define/Declare a templatized event type and initialize it with a
140 // predefined event type. (Only used for wxEVT_SPIN_XXX for backward
141 // compatibility)
142
143 #define wxDEFINE_EVENT_ALIAS( name, type, value ) \
144 const wxEventTypeTag< type > name( value )
145
146 #define wxDECLARE_EXPORTED_EVENT_ALIAS( expdecl, name, type ) \
147 extern const expdecl wxEventTypeTag< type > name
148
149 // Declare a local (not exported) templatized event type:
150
151 #define wxDECLARE_EVENT( name, type ) \
152 wxDECLARE_EXPORTED_EVENT( wxEMPTY_PARAMETER_VALUE, name, type );
153
154#endif
155
156// Try to cast the given event handler to the correct handler type:
157
158#define wxEVENT_HANDLER_CAST( functype, func ) \
159 ( wxObjectEventFunction )( wxEventFunction )wxStaticCastEvent( functype, &func )
160
161// Template which associates the correct event object with the event type
162
163#if !wxEVENTS_COMPATIBILITY_2_8
164
165// The tag is a type associated to the event type (which is an integer itself,
166// in spite of its name) value. It exists in order to be used as a template
167// parameter and provide a mapping between the event type values and their
168// corresponding wxEvent-derived classes.
169template <typename T>
170class wxEventTypeTag
171{
172public:
173 // The class of wxEvent-derived class carried by the events of this type.
174 typedef T EventClass;
175
176 wxEventTypeTag(wxEventType type) { m_type = type; }
177
178 // Return a wxEventType reference for the initialization of the static
179 // event tables. See wxEventTableEntry::m_eventType for a more thorough
180 // explanation.
181 operator const wxEventType&() const { return m_type; }
182
183private:
184 wxEventType m_type;
185};
186
187#endif // !wxEVENTS_COMPATIBILITY_2_8
188
189// These are needed for the functor definitions
190typedef void (wxEvtHandler::*wxEventFunction)(wxEvent&);
191
192// We had some trouble (specifically with eVC for ARM WinCE build) with using
193// wxEventFunction in the past so we had introduced wxObjectEventFunction which
194// used to be a typedef for a member of wxObject and not wxEvtHandler to work
195// around this but as eVC is not really supported any longer we now only keep
196// this for backwards compatibility and, despite its name, this is a typedef
197// for wxEvtHandler member now -- but if we have the same problem with another
198// compiler we can restore its old definition for it.
199typedef wxEventFunction wxObjectEventFunction;
200
201
202// The event functor which is stored in the static and dynamic event tables:
203class WXDLLIMPEXP_BASE wxEventFunctor
204{
205public:
206 virtual ~wxEventFunctor();
207
208 // Invoke the actual event handler:
209 virtual void operator()(wxEvtHandler *, wxEvent&) = 0;
210
211 // this function tests whether this functor is matched, for the purpose of
212 // finding it in an event table in Disconnect(), by the given func
213 virtual bool Matches(const wxEventFunctor& func) const = 0;
214
215 // these functions are used for functors comparison in Matches()
216 virtual void *GetHandler() const { return GetEvtHandler(); }
217 virtual wxEventFunction GetMethod() const { return NULL; }
218
219 // this one is also used elsewhere in the code and should be overridden to
220 // return non-NULL if we are indeed associated with an wxEvtHandler
221 virtual wxEvtHandler *GetEvtHandler() const { return NULL; }
222};
223
224// A plain method functor: notice that it is used even with the new events as
225// it is reused as a specialization of wxEventFunctorMethod for legacy untyped
226// event types
227class WXDLLIMPEXP_BASE wxObjectEventFunctor : public wxEventFunctor
228{
229public:
230 wxObjectEventFunctor(wxObjectEventFunction method, wxEvtHandler *handler)
231 {
232 m_handler = handler;
233 m_method = method;
234 }
235
236 virtual void operator()(wxEvtHandler *handler, wxEvent& event);
237
238 virtual bool Matches(const wxEventFunctor& func) const
239 {
240 void * const handler = func.GetHandler();
241 if ( handler && GetHandler() != handler )
242 return false;
243
244 const wxEventFunction method = GetMethod();
245
246 // FIXME-VC6: amazing but true: replacing "method == NULL" here with
247 // "!method" makes VC6 crash with an ICE in DLL build (only!)
248 return method == NULL || GetMethod() == method;
249 }
250
251 virtual wxEvtHandler *GetEvtHandler() const { return m_handler; }
252 virtual wxEventFunction GetMethod() const { return m_method; }
253
254private:
255 wxEvtHandler *m_handler;
256 wxEventFunction m_method;
257};
258
259#if wxEVENTS_COMPATIBILITY_2_8
260
261// Create a functor for the legacy events: handler can be NULL and its default
262// value is used by the event table macros
263
264inline wxObjectEventFunctor *
265wxNewEventFunctor(const wxEventType& WXUNUSED(evtType),
266 wxObjectEventFunction method,
267 wxEvtHandler *handler = NULL)
268{
269 return new wxObjectEventFunctor(method, handler);
270}
271
272inline wxObjectEventFunctor
273wxMakeEventFunctor(const wxEventType& WXUNUSED(evtType),
274 wxObjectEventFunction method,
275 wxEvtHandler *handler)
276{
277 return wxObjectEventFunctor(method, handler);
278}
279
280#else // !wxEVENTS_COMPATIBILITY_2_8
281
282// functor forwarding the event to anything callable (function, static method,
283// generalized functor...)
284template <typename EventTag, typename Functor>
285class wxEventFunctorFunction : public wxEventFunctor
286{
287public:
288 typedef typename EventTag::EventClass EventArg;
289
290 wxEventFunctorFunction(Functor handler)
291 {
292 m_handler = handler;
293 }
294
295 virtual void operator()(wxEvtHandler *WXUNUSED(handler), wxEvent& event)
296 {
297 m_handler(static_cast<EventArg&>(event));
298 }
299
300 virtual bool Matches(const wxEventFunctor& WXUNUSED(func)) const
301 {
302 // we have no way to compare arbitrary functors so just consider them
303 // to be equal: this means that disconnecting a functor will always
304 // find the last functor connected which in turn implies that it's
305 // probably a bad idea to connect more than one functor if you plan to
306 // disconnect them but this limitation doesn't seem very important in
307 // practice
308 return true;
309 }
310
311private:
312 Functor m_handler;
313};
314
315namespace wxPrivate
316{
317
318// helper template defining nested "type" typedef as the event class
319// corresponding to the given event type
320template <typename T> struct EventClassOf;
321
322// the typed events provide the information about the class of the events they
323// carry themselves:
324template <typename T>
325struct EventClassOf< wxEventTypeTag<T> >
326{
327 typedef typename wxEventTypeTag<T>::EventClass type;
328};
329
330// for the old untyped events we don't have information about the exact event
331// class carried by them
332template <>
333struct EventClassOf<wxEventType>
334{
335 typedef wxEvent type;
336};
337
338
339// helper class defining operations different for method functors using an
340// object of wxEvtHandler-derived class as handler and the others
341template <typename T, typename A, bool> struct HandlerImpl;
342
343// specialization for handlers deriving from wxEvtHandler
344template <typename T, typename A>
345struct HandlerImpl<T, A, true>
346{
347 static bool IsEvtHandler()
348 { return true; }
349 static T *ConvertFromEvtHandler(wxEvtHandler *p)
350 { return static_cast<T *>(p); }
351 static wxEvtHandler *ConvertToEvtHandler(T *p)
352 { return p; }
353 static wxEventFunction ConvertToEvtFunction(void (T::*f)(A&))
354 { return static_cast<wxEventFunction>(
355 reinterpret_cast<void (T::*)(wxEvent&)>(f)); }
356};
357
358// specialization for handlers not deriving from wxEvtHandler
359template <typename T, typename A>
360struct HandlerImpl<T, A, false>
361{
362 static bool IsEvtHandler()
363 { return false; }
364 static T *ConvertFromEvtHandler(wxEvtHandler *)
365 { return NULL; }
366 static wxEvtHandler *ConvertToEvtHandler(T *)
367 { return NULL; }
368 static wxEventFunction ConvertToEvtFunction(void (T::*)(A&))
369 { return NULL; }
370};
371
372} // namespace wxPrivate
373
374// functor forwarding the event to a method of the given object
375//
376// notice that the object class may be different from the class in which the
377// method is defined but it must be convertible to this class
378//
379// also, the type of the handler parameter doesn't need to be exactly the same
380// as EventTag::EventClass but it must be its base class -- this is explicitly
381// allowed to handle different events in the same handler taking wxEvent&, for
382// example
383template
384 <typename EventTag, typename Class, typename EventArg, typename EventHandler>
385class wxEventFunctorMethod
386 : public wxEventFunctor,
387 private wxPrivate::HandlerImpl
388 <
389 Class,
390 EventArg,
391 wxConvertibleTo<Class, wxEvtHandler>::value != 0
392 >
393{
394private:
395 static void CheckHandlerArgument(EventArg *) { }
396
397public:
398 // the event class associated with the given event tag
399 typedef typename wxPrivate::EventClassOf<EventTag>::type EventClass;
400
401
402 wxEventFunctorMethod(void (Class::*method)(EventArg&), EventHandler *handler)
403 {
404 wxASSERT_MSG( handler || this->IsEvtHandler(),
405 "handlers defined in non-wxEvtHandler-derived classes "
406 "must be connected with a valid sink object" );
407
408 // if you get an error here it means that the signature of the handler
409 // you're trying to use is not compatible with (i.e. is not the same as
410 // or a base class of) the real event class used for this event type
411 CheckHandlerArgument(static_cast<EventClass *>(NULL));
412
413 m_handler = handler;
414 m_method = method;
415 }
416
417 virtual void operator()(wxEvtHandler *handler, wxEvent& event)
418 {
419 Class * realHandler = m_handler;
420 if ( !realHandler )
421 {
422 realHandler = this->ConvertFromEvtHandler(handler);
423
424 // this is not supposed to happen but check for it nevertheless
425 wxCHECK_RET( realHandler, "invalid event handler" );
426 }
427
428 // the real (run-time) type of event is EventClass and we checked in
429 // the ctor that EventClass can be converted to EventArg, so this cast
430 // is always valid
431 (realHandler->*m_method)(static_cast<EventArg&>(event));
432 }
433
434 virtual bool Matches(const wxEventFunctor& func) const
435 {
436 void * const handler = func.GetHandler();
437 if ( handler && GetHandler() != handler )
438 return false;
439
440 const wxEventFunction method = GetMethod();
441 return !method || GetMethod() == method;
442 }
443
444 virtual void *GetHandler() const
445 {
446 return m_handler;
447 }
448
449 virtual wxEventFunction GetMethod() const
450 {
451 return this->ConvertToEvtFunction(m_method);
452 }
453
454 virtual wxEvtHandler *GetEvtHandler() const
455 {
456 return this->ConvertToEvtHandler(m_handler);
457 }
458
459private:
460 EventHandler *m_handler;
461 void (Class::*m_method)(EventArg&);
462};
463
464
465// Create functors for the templatized events, either allocated on the heap for
466// wxNewXXX() variants (this is needed in wxEvtHandler::Bind<>() to store them
467// in dynamic event table) or just by returning them as temporary objects (this
468// is enough for Unbind<>() and we avoid unnecessary heap allocation like this).
469
470
471// Create functors wrapping other functors (including functions):
472template <typename EventTag, typename Functor>
473inline wxEventFunctorFunction<EventTag, Functor> *
474wxNewEventFunctor(const EventTag&, Functor func)
475{
476 return new wxEventFunctorFunction<EventTag, Functor>(func);
477}
478
479template <typename EventTag, typename Functor>
480inline wxEventFunctorFunction<EventTag, Functor>
481wxMakeEventFunctor(const EventTag&, Functor func)
482{
483 return wxEventFunctorFunction<EventTag, Functor>(func);
484}
485
486
487// Create functors for methods:
488template
489 <typename EventTag, typename Class, typename EventArg, typename EventHandler>
490inline wxEventFunctorMethod<EventTag, Class, EventArg, EventHandler> *
491wxNewEventFunctor(const EventTag&,
492 void (Class::*method)(EventArg&),
493 EventHandler *handler)
494{
495 return new wxEventFunctorMethod<EventTag, Class, EventArg, EventHandler>(
496 method, handler);
497}
498
499template
500 <typename EventTag, typename Class, typename EventArg, typename EventHandler>
501inline wxEventFunctorMethod<EventTag, Class, EventArg, EventHandler>
502wxMakeEventFunctor(const EventTag&,
503 void (Class::*method)(EventArg&),
504 EventHandler *handler)
505{
506 return wxEventFunctorMethod<EventTag, Class, EventArg, EventHandler>(
507 method, handler);
508}
509
510// Special case for the wxNewEventFunctor() calls used inside the event table
511// macros: they don't specify the handler so EventHandler can't be deduced
512template <typename EventTag, typename Class, typename EventArg>
513inline wxEventFunctorMethod<EventTag, Class, EventArg, Class> *
514wxNewEventFunctor(const EventTag&, void (Class::*method)(EventArg&))
515{
516 return new wxEventFunctorMethod<EventTag, Class, EventArg, Class>(
517 method, NULL);
518}
519
520template
521 <typename EventTag, typename Class, typename EventArg, typename EventHandler>
522inline wxEventFunctorMethod<EventTag, Class, EventArg, Class>
523wxMakeEventFunctor(const EventTag&, void (Class::*method)(EventArg&))
524{
525 return wxEventFunctorMethod<EventTag, Class, EventArg, Class>(
526 method, NULL);
527}
528
529#endif // !wxEVENTS_COMPATIBILITY_2_8
530
531
532// many, but not all, standard event types
533
534 // some generic events
535extern WXDLLIMPEXP_BASE const wxEventType wxEVT_NULL;
536extern WXDLLIMPEXP_BASE const wxEventType wxEVT_FIRST;
537extern WXDLLIMPEXP_BASE const wxEventType wxEVT_USER_FIRST;
538
539 // Need events declared to do this
540class WXDLLIMPEXP_FWD_CORE wxCommandEvent;
541class WXDLLIMPEXP_FWD_CORE wxThreadEvent;
542class WXDLLIMPEXP_FWD_CORE wxMouseEvent;
543class WXDLLIMPEXP_FWD_CORE wxFocusEvent;
544class WXDLLIMPEXP_FWD_CORE wxChildFocusEvent;
545class WXDLLIMPEXP_FWD_CORE wxKeyEvent;
546class WXDLLIMPEXP_FWD_CORE wxNavigationKeyEvent;
547class WXDLLIMPEXP_FWD_CORE wxSetCursorEvent;
548class WXDLLIMPEXP_FWD_CORE wxScrollEvent;
549class WXDLLIMPEXP_FWD_CORE wxSpinEvent;
550class WXDLLIMPEXP_FWD_CORE wxScrollWinEvent;
551class WXDLLIMPEXP_FWD_CORE wxSizeEvent;
552class WXDLLIMPEXP_FWD_CORE wxMoveEvent;
553class WXDLLIMPEXP_FWD_CORE wxCloseEvent;
554class WXDLLIMPEXP_FWD_CORE wxActivateEvent;
555class WXDLLIMPEXP_FWD_CORE wxWindowCreateEvent;
556class WXDLLIMPEXP_FWD_CORE wxWindowDestroyEvent;
557class WXDLLIMPEXP_FWD_CORE wxShowEvent;
558class WXDLLIMPEXP_FWD_CORE wxIconizeEvent;
559class WXDLLIMPEXP_FWD_CORE wxMaximizeEvent;
560class WXDLLIMPEXP_FWD_CORE wxMouseCaptureChangedEvent;
561class WXDLLIMPEXP_FWD_CORE wxMouseCaptureLostEvent;
562class WXDLLIMPEXP_FWD_CORE wxPaintEvent;
563class WXDLLIMPEXP_FWD_CORE wxEraseEvent;
564class WXDLLIMPEXP_FWD_CORE wxNcPaintEvent;
565class WXDLLIMPEXP_FWD_CORE wxMenuEvent;
566class WXDLLIMPEXP_FWD_CORE wxContextMenuEvent;
567class WXDLLIMPEXP_FWD_CORE wxSysColourChangedEvent;
568class WXDLLIMPEXP_FWD_CORE wxDisplayChangedEvent;
569class WXDLLIMPEXP_FWD_CORE wxQueryNewPaletteEvent;
570class WXDLLIMPEXP_FWD_CORE wxPaletteChangedEvent;
571class WXDLLIMPEXP_FWD_CORE wxJoystickEvent;
572class WXDLLIMPEXP_FWD_CORE wxDropFilesEvent;
573class WXDLLIMPEXP_FWD_CORE wxInitDialogEvent;
574class WXDLLIMPEXP_FWD_CORE wxIdleEvent;
575class WXDLLIMPEXP_FWD_CORE wxUpdateUIEvent;
576class WXDLLIMPEXP_FWD_CORE wxClipboardTextEvent;
577class WXDLLIMPEXP_FWD_CORE wxHelpEvent;
578
579
580 // Command events
581wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEvent);
582wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEvent);
583wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_COMMAND_CHOICE_SELECTED, wxCommandEvent);
584wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_COMMAND_LISTBOX_SELECTED, wxCommandEvent);
585wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_COMMAND_LISTBOX_DOUBLECLICKED, wxCommandEvent);
586wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_COMMAND_CHECKLISTBOX_TOGGLED, wxCommandEvent);
587wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_COMMAND_MENU_SELECTED, wxCommandEvent);
588wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_COMMAND_SLIDER_UPDATED, wxCommandEvent);
589wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_COMMAND_RADIOBOX_SELECTED, wxCommandEvent);
590wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_COMMAND_RADIOBUTTON_SELECTED, wxCommandEvent);
591
592// wxEVT_COMMAND_SCROLLBAR_UPDATED is deprecated, use wxEVT_SCROLL... events
593wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_COMMAND_SCROLLBAR_UPDATED, wxCommandEvent);
594wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_COMMAND_VLBOX_SELECTED, wxCommandEvent);
595wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_COMMAND_COMBOBOX_SELECTED, wxCommandEvent);
596wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_COMMAND_TOOL_RCLICKED, wxCommandEvent);
597wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_COMMAND_TOOL_DROPDOWN_CLICKED, wxCommandEvent);
598wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_COMMAND_TOOL_ENTER, wxCommandEvent);
599wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_COMMAND_COMBOBOX_DROPDOWN, wxCommandEvent);
600wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_COMMAND_COMBOBOX_CLOSEUP, wxCommandEvent);
601
602 // Thread events
603wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_COMMAND_THREAD, wxThreadEvent);
604
605 // Mouse event types
606wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_LEFT_DOWN, wxMouseEvent);
607wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_LEFT_UP, wxMouseEvent);
608wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_MIDDLE_DOWN, wxMouseEvent);
609wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_MIDDLE_UP, wxMouseEvent);
610wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_RIGHT_DOWN, wxMouseEvent);
611wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_RIGHT_UP, wxMouseEvent);
612wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_MOTION, wxMouseEvent);
613wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_ENTER_WINDOW, wxMouseEvent);
614wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_LEAVE_WINDOW, wxMouseEvent);
615wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_LEFT_DCLICK, wxMouseEvent);
616wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_MIDDLE_DCLICK, wxMouseEvent);
617wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_RIGHT_DCLICK, wxMouseEvent);
618wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_SET_FOCUS, wxFocusEvent);
619wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_KILL_FOCUS, wxFocusEvent);
620wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_CHILD_FOCUS, wxChildFocusEvent);
621wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_MOUSEWHEEL, wxMouseEvent);
622wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_AUX1_DOWN, wxMouseEvent);
623wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_AUX1_UP, wxMouseEvent);
624wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_AUX1_DCLICK, wxMouseEvent);
625wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_AUX2_DOWN, wxMouseEvent);
626wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_AUX2_UP, wxMouseEvent);
627wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_AUX2_DCLICK, wxMouseEvent);
628
629 // Character input event type
630wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_CHAR, wxKeyEvent);
631wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_CHAR_HOOK, wxKeyEvent);
632wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_NAVIGATION_KEY, wxNavigationKeyEvent);
633wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_KEY_DOWN, wxKeyEvent);
634wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_KEY_UP, wxKeyEvent);
635#if wxUSE_HOTKEY
636wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_HOTKEY, wxKeyEvent);
637#endif
638 // Set cursor event
639wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_SET_CURSOR, wxSetCursorEvent);
640
641 // wxScrollBar and wxSlider event identifiers
642wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_SCROLL_TOP, wxScrollEvent);
643wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_SCROLL_BOTTOM, wxScrollEvent);
644wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_SCROLL_LINEUP, wxScrollEvent);
645wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_SCROLL_LINEDOWN, wxScrollEvent);
646wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_SCROLL_PAGEUP, wxScrollEvent);
647wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_SCROLL_PAGEDOWN, wxScrollEvent);
648wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_SCROLL_THUMBTRACK, wxScrollEvent);
649wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_SCROLL_THUMBRELEASE, wxScrollEvent);
650wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_SCROLL_CHANGED, wxScrollEvent);
651
652// Due to a bug in older wx versions, wxSpinEvents were being sent with type of
653// wxEVT_SCROLL_LINEUP, wxEVT_SCROLL_LINEDOWN and wxEVT_SCROLL_THUMBTRACK. But
654// with the type-safe events in place, these event types are associated with
655// wxScrollEvent. To allow handling of spin events, new event types have been
656// defined in spinbutt.h/spinnbuttcmn.cpp. To maintain backward compatibility
657// the spin event types are being initialized with the scroll event types.
658
659#if wxUSE_SPINBTN
660
661wxDECLARE_EXPORTED_EVENT_ALIAS( WXDLLIMPEXP_CORE, wxEVT_SPIN_UP, wxSpinEvent );
662wxDECLARE_EXPORTED_EVENT_ALIAS( WXDLLIMPEXP_CORE, wxEVT_SPIN_DOWN, wxSpinEvent );
663wxDECLARE_EXPORTED_EVENT_ALIAS( WXDLLIMPEXP_CORE, wxEVT_SPIN, wxSpinEvent );
664
665#endif
666
667 // Scroll events from wxWindow
668wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_SCROLLWIN_TOP, wxScrollWinEvent);
669wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_SCROLLWIN_BOTTOM, wxScrollWinEvent);
670wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_SCROLLWIN_LINEUP, wxScrollWinEvent);
671wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_SCROLLWIN_LINEDOWN, wxScrollWinEvent);
672wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_SCROLLWIN_PAGEUP, wxScrollWinEvent);
673wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_SCROLLWIN_PAGEDOWN, wxScrollWinEvent);
674wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_SCROLLWIN_THUMBTRACK, wxScrollWinEvent);
675wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_SCROLLWIN_THUMBRELEASE, wxScrollWinEvent);
676
677 // System events
678wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_SIZE, wxSizeEvent);
679wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_MOVE, wxMoveEvent);
680wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_CLOSE_WINDOW, wxCloseEvent);
681wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_END_SESSION, wxCloseEvent);
682wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_QUERY_END_SESSION, wxCloseEvent);
683wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_ACTIVATE_APP, wxActivateEvent);
684wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_ACTIVATE, wxActivateEvent);
685wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_CREATE, wxWindowCreateEvent);
686wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_DESTROY, wxWindowDestroyEvent);
687wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_SHOW, wxShowEvent);
688wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_ICONIZE, wxIconizeEvent);
689wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_MAXIMIZE, wxMaximizeEvent);
690wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_MOUSE_CAPTURE_CHANGED, wxMouseCaptureChangedEvent);
691wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_MOUSE_CAPTURE_LOST, wxMouseCaptureLostEvent);
692wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_PAINT, wxPaintEvent);
693wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_ERASE_BACKGROUND, wxEraseEvent);
694wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_NC_PAINT, wxNcPaintEvent);
695wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_MENU_OPEN, wxMenuEvent);
696wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_MENU_CLOSE, wxMenuEvent);
697wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_MENU_HIGHLIGHT, wxMenuEvent);
698wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_CONTEXT_MENU, wxContextMenuEvent);
699wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_SYS_COLOUR_CHANGED, wxSysColourChangedEvent);
700wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_DISPLAY_CHANGED, wxDisplayChangedEvent);
701wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_QUERY_NEW_PALETTE, wxQueryNewPaletteEvent);
702wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_PALETTE_CHANGED, wxPaletteChangedEvent);
703wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_JOY_BUTTON_DOWN, wxJoystickEvent);
704wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_JOY_BUTTON_UP, wxJoystickEvent);
705wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_JOY_MOVE, wxJoystickEvent);
706wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_JOY_ZMOVE, wxJoystickEvent);
707wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_DROP_FILES, wxDropFilesEvent);
708wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_INIT_DIALOG, wxInitDialogEvent);
709wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_BASE, wxEVT_IDLE, wxIdleEvent);
710wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_UPDATE_UI, wxUpdateUIEvent);
711wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_SIZING, wxSizeEvent);
712wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_MOVING, wxMoveEvent);
713wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_MOVE_START, wxMoveEvent);
714wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_MOVE_END, wxMoveEvent);
715wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_HIBERNATE, wxActivateEvent);
716
717 // Clipboard events
718wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_COMMAND_TEXT_COPY, wxClipboardTextEvent);
719wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_COMMAND_TEXT_CUT, wxClipboardTextEvent);
720wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_COMMAND_TEXT_PASTE, wxClipboardTextEvent);
721
722 // Generic command events
723 // Note: a click is a higher-level event than button down/up
724wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_COMMAND_LEFT_CLICK, wxCommandEvent);
725wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_COMMAND_LEFT_DCLICK, wxCommandEvent);
726wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_COMMAND_RIGHT_CLICK, wxCommandEvent);
727wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_COMMAND_RIGHT_DCLICK, wxCommandEvent);
728wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_COMMAND_SET_FOCUS, wxCommandEvent);
729wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_COMMAND_KILL_FOCUS, wxCommandEvent);
730wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_COMMAND_ENTER, wxCommandEvent);
731
732 // Help events
733wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_HELP, wxHelpEvent);
734wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_DETAILED_HELP, wxHelpEvent);
735
736// these 2 events are the same
737#define wxEVT_COMMAND_TOOL_CLICKED wxEVT_COMMAND_MENU_SELECTED
738
739// ----------------------------------------------------------------------------
740// Compatibility
741// ----------------------------------------------------------------------------
742
743// this event is also used by wxComboBox and wxSpinCtrl which don't include
744// wx/textctrl.h in all ports [yet], so declare it here as well
745//
746// still, any new code using it should include wx/textctrl.h explicitly
747wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_COMMAND_TEXT_UPDATED, wxCommandEvent);
748
749
750// ----------------------------------------------------------------------------
751// wxEvent(-derived) classes
752// ----------------------------------------------------------------------------
753
754// the predefined constants for the number of times we propagate event
755// upwards window child-parent chain
756enum wxEventPropagation
757{
758 // don't propagate it at all
759 wxEVENT_PROPAGATE_NONE = 0,
760
761 // propagate it until it is processed
762 wxEVENT_PROPAGATE_MAX = INT_MAX
763};
764
765// The different categories for a wxEvent; see wxEvent::GetEventCategory.
766// NOTE: they are used as OR-combinable flags by wxEventLoopBase::YieldFor
767enum wxEventCategory
768{
769 // this is the category for those events which are generated to update
770 // the appearance of the GUI but which (usually) do not comport data
771 // processing, i.e. which do not provide input or output data
772 // (e.g. size events, scroll events, etc).
773 // They are events NOT directly generated by the user's input devices.
774 wxEVT_CATEGORY_UI = 1,
775
776 // this category groups those events which are generated directly from the
777 // user through input devices like mouse and keyboard and usually result in
778 // data to be processed from the application.
779 // (e.g. mouse clicks, key presses, etc)
780 wxEVT_CATEGORY_USER_INPUT = 2,
781
782 // this category is for wxSocketEvent
783 wxEVT_CATEGORY_SOCKET = 4,
784
785 // this category is for wxTimerEvent
786 wxEVT_CATEGORY_TIMER = 8,
787
788 // this category is for any event used to send notifications from the
789 // secondary threads to the main one or in general for notifications among
790 // different threads (which may or may not be user-generated)
791 wxEVT_CATEGORY_THREAD = 16,
792
793
794 // implementation only
795
796 // used in the implementations of wxEventLoopBase::YieldFor
797 wxEVT_CATEGORY_UNKNOWN = 32,
798
799 // a special category used as an argument to wxEventLoopBase::YieldFor to indicate that
800 // Yield() should leave all wxEvents on the queue while emptying the native event queue
801 // (native events will be processed but the wxEvents they generate will be queued)
802 wxEVT_CATEGORY_CLIPBOARD = 64,
803
804
805 // shortcut masks
806
807 // this category groups those events which are emitted in response to
808 // events of the native toolkit and which typically are not-"delayable".
809 wxEVT_CATEGORY_NATIVE_EVENTS = wxEVT_CATEGORY_UI|wxEVT_CATEGORY_USER_INPUT,
810
811 // used in wxEventLoopBase::YieldFor to specify all event categories should be processed:
812 wxEVT_CATEGORY_ALL =
813 wxEVT_CATEGORY_UI|wxEVT_CATEGORY_USER_INPUT|wxEVT_CATEGORY_SOCKET| \
814 wxEVT_CATEGORY_TIMER|wxEVT_CATEGORY_THREAD|wxEVT_CATEGORY_UNKNOWN| \
815 wxEVT_CATEGORY_CLIPBOARD
816};
817
818/*
819 * wxWidgets events, covering all interesting things that might happen
820 * (button clicking, resizing, setting text in widgets, etc.).
821 *
822 * For each completely new event type, derive a new event class.
823 * An event CLASS represents a C++ class defining a range of similar event TYPES;
824 * examples are canvas events, panel item command events.
825 * An event TYPE is a unique identifier for a particular system event,
826 * such as a button press or a listbox deselection.
827 *
828 */
829
830class WXDLLIMPEXP_BASE wxEvent : public wxObject
831{
832public:
833 wxEvent(int winid = 0, wxEventType commandType = wxEVT_NULL );
834
835 void SetEventType(wxEventType typ) { m_eventType = typ; }
836 wxEventType GetEventType() const { return m_eventType; }
837
838 wxObject *GetEventObject() const { return m_eventObject; }
839 void SetEventObject(wxObject *obj) { m_eventObject = obj; }
840
841 long GetTimestamp() const { return m_timeStamp; }
842 void SetTimestamp(long ts = 0) { m_timeStamp = ts; }
843
844 int GetId() const { return m_id; }
845 void SetId(int Id) { m_id = Id; }
846
847 // Can instruct event processor that we wish to ignore this event
848 // (treat as if the event table entry had not been found): this must be done
849 // to allow the event processing by the base classes (calling event.Skip()
850 // is the analog of calling the base class version of a virtual function)
851 void Skip(bool skip = true) { m_skipped = skip; }
852 bool GetSkipped() const { return m_skipped; }
853
854 // This function is used to create a copy of the event polymorphically and
855 // all derived classes must implement it because otherwise wxPostEvent()
856 // for them wouldn't work (it needs to do a copy of the event)
857 virtual wxEvent *Clone() const = 0;
858
859 // this function is used to selectively process events in wxEventLoopBase::YieldFor
860 // NOTE: by default it returns wxEVT_CATEGORY_UI just because the major
861 // part of wxWidgets events belong to that category.
862 virtual wxEventCategory GetEventCategory() const
863 { return wxEVT_CATEGORY_UI; }
864
865 // Implementation only: this test is explicitly anti OO and this function
866 // exists only for optimization purposes.
867 bool IsCommandEvent() const { return m_isCommandEvent; }
868
869 // Determine if this event should be propagating to the parent window.
870 bool ShouldPropagate() const
871 { return m_propagationLevel != wxEVENT_PROPAGATE_NONE; }
872
873 // Stop an event from propagating to its parent window, returns the old
874 // propagation level value
875 int StopPropagation()
876 {
877 int propagationLevel = m_propagationLevel;
878 m_propagationLevel = wxEVENT_PROPAGATE_NONE;
879 return propagationLevel;
880 }
881
882 // Resume the event propagation by restoring the propagation level
883 // (returned by StopPropagation())
884 void ResumePropagation(int propagationLevel)
885 {
886 m_propagationLevel = propagationLevel;
887 }
888
889
890 // This is for internal use only and is only called by
891 // wxEvtHandler::ProcessEvent() to check whether it's the first time this
892 // event is being processed
893 bool WasProcessed()
894 {
895 if ( m_wasProcessed )
896 return true;
897
898 m_wasProcessed = true;
899
900 return false;
901 }
902
903protected:
904 wxObject* m_eventObject;
905 wxEventType m_eventType;
906 long m_timeStamp;
907 int m_id;
908
909public:
910 // m_callbackUserData is for internal usage only
911 wxObject* m_callbackUserData;
912
913protected:
914 // the propagation level: while it is positive, we propagate the event to
915 // the parent window (if any)
916 int m_propagationLevel;
917
918 bool m_skipped;
919 bool m_isCommandEvent;
920
921 // initially false but becomes true as soon as WasProcessed() is called for
922 // the first time, as this is done only by ProcessEvent() it explains the
923 // variable name: it becomes true after ProcessEvent() was called at least
924 // once for this event
925 bool m_wasProcessed;
926
927protected:
928 wxEvent(const wxEvent&); // for implementing Clone()
929 wxEvent& operator=(const wxEvent&); // for derived classes operator=()
930
931private:
932 // it needs to access our m_propagationLevel
933 friend class WXDLLIMPEXP_FWD_BASE wxPropagateOnce;
934
935 DECLARE_ABSTRACT_CLASS(wxEvent)
936};
937
938/*
939 * Helper class to temporarily change an event not to propagate.
940 */
941class WXDLLIMPEXP_BASE wxPropagationDisabler
942{
943public:
944 wxPropagationDisabler(wxEvent& event) : m_event(event)
945 {
946 m_propagationLevelOld = m_event.StopPropagation();
947 }
948
949 ~wxPropagationDisabler()
950 {
951 m_event.ResumePropagation(m_propagationLevelOld);
952 }
953
954private:
955 wxEvent& m_event;
956 int m_propagationLevelOld;
957
958 wxDECLARE_NO_COPY_CLASS(wxPropagationDisabler);
959};
960
961/*
962 * Another one to temporarily lower propagation level.
963 */
964class WXDLLIMPEXP_BASE wxPropagateOnce
965{
966public:
967 wxPropagateOnce(wxEvent& event) : m_event(event)
968 {
969 wxASSERT_MSG( m_event.m_propagationLevel > 0,
970 _T("shouldn't be used unless ShouldPropagate()!") );
971
972 m_event.m_propagationLevel--;
973 }
974
975 ~wxPropagateOnce()
976 {
977 m_event.m_propagationLevel++;
978 }
979
980private:
981 wxEvent& m_event;
982
983 wxDECLARE_NO_COPY_CLASS(wxPropagateOnce);
984};
985
986
987#if wxUSE_GUI
988
989
990// Item or menu event class
991/*
992 wxEVT_COMMAND_BUTTON_CLICKED
993 wxEVT_COMMAND_CHECKBOX_CLICKED
994 wxEVT_COMMAND_CHOICE_SELECTED
995 wxEVT_COMMAND_LISTBOX_SELECTED
996 wxEVT_COMMAND_LISTBOX_DOUBLECLICKED
997 wxEVT_COMMAND_TEXT_UPDATED
998 wxEVT_COMMAND_TEXT_ENTER
999 wxEVT_COMMAND_MENU_SELECTED
1000 wxEVT_COMMAND_SLIDER_UPDATED
1001 wxEVT_COMMAND_RADIOBOX_SELECTED
1002 wxEVT_COMMAND_RADIOBUTTON_SELECTED
1003 wxEVT_COMMAND_SCROLLBAR_UPDATED
1004 wxEVT_COMMAND_VLBOX_SELECTED
1005 wxEVT_COMMAND_COMBOBOX_SELECTED
1006 wxEVT_COMMAND_TOGGLEBUTTON_CLICKED
1007*/
1008
1009class WXDLLIMPEXP_CORE wxCommandEvent : public wxEvent
1010{
1011public:
1012 wxCommandEvent(wxEventType commandType = wxEVT_NULL, int winid = 0);
1013
1014 wxCommandEvent(const wxCommandEvent& event)
1015 : wxEvent(event),
1016 m_cmdString(event.m_cmdString),
1017 m_commandInt(event.m_commandInt),
1018 m_extraLong(event.m_extraLong),
1019 m_clientData(event.m_clientData),
1020 m_clientObject(event.m_clientObject)
1021 { }
1022
1023 // Set/Get client data from controls
1024 void SetClientData(void* clientData) { m_clientData = clientData; }
1025 void *GetClientData() const { return m_clientData; }
1026
1027 // Set/Get client object from controls
1028 void SetClientObject(wxClientData* clientObject) { m_clientObject = clientObject; }
1029 wxClientData *GetClientObject() const { return m_clientObject; }
1030
1031 // Get listbox selection if single-choice
1032 int GetSelection() const { return m_commandInt; }
1033
1034 // Set/Get listbox/choice selection string
1035 void SetString(const wxString& s) { m_cmdString = s; }
1036 wxString GetString() const;
1037
1038 // Get checkbox value
1039 bool IsChecked() const { return m_commandInt != 0; }
1040
1041 // true if the listbox event was a selection.
1042 bool IsSelection() const { return (m_extraLong != 0); }
1043
1044 void SetExtraLong(long extraLong) { m_extraLong = extraLong; }
1045 long GetExtraLong() const { return m_extraLong; }
1046
1047 void SetInt(int i) { m_commandInt = i; }
1048 int GetInt() const { return m_commandInt; }
1049
1050 virtual wxEvent *Clone() const { return new wxCommandEvent(*this); }
1051 virtual wxEventCategory GetEventCategory() const { return wxEVT_CATEGORY_USER_INPUT; }
1052
1053protected:
1054 wxString m_cmdString; // String event argument
1055 int m_commandInt;
1056 long m_extraLong; // Additional information (e.g. select/deselect)
1057 void* m_clientData; // Arbitrary client data
1058 wxClientData* m_clientObject; // Arbitrary client object
1059
1060private:
1061 DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxCommandEvent)
1062};
1063
1064// this class adds a possibility to react (from the user) code to a control
1065// notification: allow or veto the operation being reported.
1066class WXDLLIMPEXP_CORE wxNotifyEvent : public wxCommandEvent
1067{
1068public:
1069 wxNotifyEvent(wxEventType commandType = wxEVT_NULL, int winid = 0)
1070 : wxCommandEvent(commandType, winid)
1071 { m_bAllow = true; }
1072
1073 wxNotifyEvent(const wxNotifyEvent& event)
1074 : wxCommandEvent(event)
1075 { m_bAllow = event.m_bAllow; }
1076
1077 // veto the operation (usually it's allowed by default)
1078 void Veto() { m_bAllow = false; }
1079
1080 // allow the operation if it was disabled by default
1081 void Allow() { m_bAllow = true; }
1082
1083 // for implementation code only: is the operation allowed?
1084 bool IsAllowed() const { return m_bAllow; }
1085
1086 virtual wxEvent *Clone() const { return new wxNotifyEvent(*this); }
1087
1088private:
1089 bool m_bAllow;
1090
1091private:
1092 DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxNotifyEvent)
1093};
1094
1095
1096// Thread event
1097
1098class WXDLLIMPEXP_CORE wxThreadEvent : public wxCommandEvent
1099{
1100public:
1101 wxThreadEvent(wxEventType eventType = wxEVT_COMMAND_THREAD, int id = wxID_ANY)
1102 : wxCommandEvent(eventType, id)
1103 { }
1104
1105 wxThreadEvent(const wxThreadEvent& event)
1106 : wxCommandEvent(event)
1107 {
1108 // make sure our string member (which uses COW, aka refcounting) is not
1109 // shared by other wxString instances:
1110 SetString(GetString().c_str());
1111 }
1112
1113 virtual wxEvent *Clone() const
1114 {
1115 wxThreadEvent* ev = new wxThreadEvent(*this);
1116
1117 // make sure our string member (which uses COW, aka refcounting) is not
1118 // shared by other wxString instances:
1119 ev->SetString(GetString().c_str());
1120 return ev;
1121 }
1122
1123 // this is important to avoid that calling wxEventLoopBase::YieldFor thread events
1124 // gets processed when this is unwanted:
1125 virtual wxEventCategory GetEventCategory() const
1126 { return wxEVT_CATEGORY_THREAD; }
1127
1128private:
1129 DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxThreadEvent)
1130};
1131
1132
1133
1134// Scroll event class, derived form wxCommandEvent. wxScrollEvents are
1135// sent by wxSlider and wxScrollBar.
1136/*
1137 wxEVT_SCROLL_TOP
1138 wxEVT_SCROLL_BOTTOM
1139 wxEVT_SCROLL_LINEUP
1140 wxEVT_SCROLL_LINEDOWN
1141 wxEVT_SCROLL_PAGEUP
1142 wxEVT_SCROLL_PAGEDOWN
1143 wxEVT_SCROLL_THUMBTRACK
1144 wxEVT_SCROLL_THUMBRELEASE
1145 wxEVT_SCROLL_CHANGED
1146*/
1147
1148class WXDLLIMPEXP_CORE wxScrollEvent : public wxCommandEvent
1149{
1150public:
1151 wxScrollEvent(wxEventType commandType = wxEVT_NULL,
1152 int winid = 0, int pos = 0, int orient = 0);
1153
1154 int GetOrientation() const { return (int) m_extraLong; }
1155 int GetPosition() const { return m_commandInt; }
1156 void SetOrientation(int orient) { m_extraLong = (long) orient; }
1157 void SetPosition(int pos) { m_commandInt = pos; }
1158
1159 virtual wxEvent *Clone() const { return new wxScrollEvent(*this); }
1160
1161private:
1162 DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxScrollEvent)
1163};
1164
1165// ScrollWin event class, derived fom wxEvent. wxScrollWinEvents
1166// are sent by wxWindow.
1167/*
1168 wxEVT_SCROLLWIN_TOP
1169 wxEVT_SCROLLWIN_BOTTOM
1170 wxEVT_SCROLLWIN_LINEUP
1171 wxEVT_SCROLLWIN_LINEDOWN
1172 wxEVT_SCROLLWIN_PAGEUP
1173 wxEVT_SCROLLWIN_PAGEDOWN
1174 wxEVT_SCROLLWIN_THUMBTRACK
1175 wxEVT_SCROLLWIN_THUMBRELEASE
1176*/
1177
1178class WXDLLIMPEXP_CORE wxScrollWinEvent : public wxEvent
1179{
1180public:
1181 wxScrollWinEvent(wxEventType commandType = wxEVT_NULL,
1182 int pos = 0, int orient = 0);
1183 wxScrollWinEvent(const wxScrollWinEvent& event) : wxEvent(event)
1184 { m_commandInt = event.m_commandInt;
1185 m_extraLong = event.m_extraLong; }
1186
1187 int GetOrientation() const { return (int) m_extraLong; }
1188 int GetPosition() const { return m_commandInt; }
1189 void SetOrientation(int orient) { m_extraLong = (long) orient; }
1190 void SetPosition(int pos) { m_commandInt = pos; }
1191
1192 virtual wxEvent *Clone() const { return new wxScrollWinEvent(*this); }
1193
1194protected:
1195 int m_commandInt;
1196 long m_extraLong;
1197
1198private:
1199 DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxScrollWinEvent)
1200};
1201
1202
1203
1204// Mouse event class
1205
1206/*
1207 wxEVT_LEFT_DOWN
1208 wxEVT_LEFT_UP
1209 wxEVT_MIDDLE_DOWN
1210 wxEVT_MIDDLE_UP
1211 wxEVT_RIGHT_DOWN
1212 wxEVT_RIGHT_UP
1213 wxEVT_MOTION
1214 wxEVT_ENTER_WINDOW
1215 wxEVT_LEAVE_WINDOW
1216 wxEVT_LEFT_DCLICK
1217 wxEVT_MIDDLE_DCLICK
1218 wxEVT_RIGHT_DCLICK
1219 wxEVT_NC_LEFT_DOWN
1220 wxEVT_NC_LEFT_UP,
1221 wxEVT_NC_MIDDLE_DOWN,
1222 wxEVT_NC_MIDDLE_UP,
1223 wxEVT_NC_RIGHT_DOWN,
1224 wxEVT_NC_RIGHT_UP,
1225 wxEVT_NC_MOTION,
1226 wxEVT_NC_ENTER_WINDOW,
1227 wxEVT_NC_LEAVE_WINDOW,
1228 wxEVT_NC_LEFT_DCLICK,
1229 wxEVT_NC_MIDDLE_DCLICK,
1230 wxEVT_NC_RIGHT_DCLICK,
1231*/
1232
1233// the symbolic names for the mouse buttons
1234enum
1235{
1236 wxMOUSE_BTN_ANY = -1,
1237 wxMOUSE_BTN_NONE = 0,
1238 wxMOUSE_BTN_LEFT = 1,
1239 wxMOUSE_BTN_MIDDLE = 2,
1240 wxMOUSE_BTN_RIGHT = 3,
1241 wxMOUSE_BTN_AUX1 = 4,
1242 wxMOUSE_BTN_AUX2 = 5,
1243 wxMOUSE_BTN_MAX
1244};
1245
1246class WXDLLIMPEXP_CORE wxMouseEvent : public wxEvent,
1247 public wxMouseState
1248{
1249public:
1250 wxMouseEvent(wxEventType mouseType = wxEVT_NULL);
1251 wxMouseEvent(const wxMouseEvent& event)
1252 : wxEvent(event),
1253 wxMouseState(event)
1254 {
1255 Assign(event);
1256 }
1257
1258 // Was it a button event? (*doesn't* mean: is any button *down*?)
1259 bool IsButton() const { return Button(wxMOUSE_BTN_ANY); }
1260
1261 // Was it a down event from this (or any) button?
1262 bool ButtonDown(int but = wxMOUSE_BTN_ANY) const;
1263
1264 // Was it a dclick event from this (or any) button?
1265 bool ButtonDClick(int but = wxMOUSE_BTN_ANY) const;
1266
1267 // Was it a up event from this (or any) button?
1268 bool ButtonUp(int but = wxMOUSE_BTN_ANY) const;
1269
1270 // Was the given button?
1271 bool Button(int but) const;
1272
1273 // Was the given button in Down state?
1274 bool ButtonIsDown(int but) const;
1275
1276 // Get the button which is changing state (wxMOUSE_BTN_NONE if none)
1277 int GetButton() const;
1278
1279 // Find which event was just generated
1280 bool LeftDown() const { return (m_eventType == wxEVT_LEFT_DOWN); }
1281 bool MiddleDown() const { return (m_eventType == wxEVT_MIDDLE_DOWN); }
1282 bool RightDown() const { return (m_eventType == wxEVT_RIGHT_DOWN); }
1283 bool Aux1Down() const { return (m_eventType == wxEVT_AUX1_DOWN); }
1284 bool Aux2Down() const { return (m_eventType == wxEVT_AUX2_DOWN); }
1285
1286 bool LeftUp() const { return (m_eventType == wxEVT_LEFT_UP); }
1287 bool MiddleUp() const { return (m_eventType == wxEVT_MIDDLE_UP); }
1288 bool RightUp() const { return (m_eventType == wxEVT_RIGHT_UP); }
1289 bool Aux1Up() const { return (m_eventType == wxEVT_AUX1_UP); }
1290 bool Aux2Up() const { return (m_eventType == wxEVT_AUX2_UP); }
1291
1292 bool LeftDClick() const { return (m_eventType == wxEVT_LEFT_DCLICK); }
1293 bool MiddleDClick() const { return (m_eventType == wxEVT_MIDDLE_DCLICK); }
1294 bool RightDClick() const { return (m_eventType == wxEVT_RIGHT_DCLICK); }
1295 bool Aux1DClick() const { return (m_eventType == wxEVT_AUX1_UP); }
1296 bool Aux2DClick() const { return (m_eventType == wxEVT_AUX2_UP); }
1297
1298 // Find the current state of the mouse buttons (regardless
1299 // of current event type)
1300 bool LeftIsDown() const { return m_leftDown; }
1301 bool MiddleIsDown() const { return m_middleDown; }
1302 bool RightIsDown() const { return m_rightDown; }
1303 bool Aux1IsDown() const { return m_aux1Down; }
1304 bool Aux2IsDown() const { return m_aux2Down; }
1305
1306 // True if a button is down and the mouse is moving
1307 bool Dragging() const
1308 {
1309 return (m_eventType == wxEVT_MOTION) && ButtonIsDown(wxMOUSE_BTN_ANY);
1310 }
1311
1312 // True if the mouse is moving, and no button is down
1313 bool Moving() const
1314 {
1315 return (m_eventType == wxEVT_MOTION) && !ButtonIsDown(wxMOUSE_BTN_ANY);
1316 }
1317
1318 // True if the mouse is just entering the window
1319 bool Entering() const { return (m_eventType == wxEVT_ENTER_WINDOW); }
1320
1321 // True if the mouse is just leaving the window
1322 bool Leaving() const { return (m_eventType == wxEVT_LEAVE_WINDOW); }
1323
1324 // Returns the number of mouse clicks associated with this event.
1325 int GetClickCount() const { return m_clickCount; }
1326
1327
1328 // Find the position of the event
1329 void GetPosition(wxCoord *xpos, wxCoord *ypos) const
1330 {
1331 if (xpos)
1332 *xpos = m_x;
1333 if (ypos)
1334 *ypos = m_y;
1335 }
1336
1337 void GetPosition(long *xpos, long *ypos) const
1338 {
1339 if (xpos)
1340 *xpos = (long)m_x;
1341 if (ypos)
1342 *ypos = (long)m_y;
1343 }
1344
1345 // Find the position of the event
1346 wxPoint GetPosition() const { return wxPoint(m_x, m_y); }
1347
1348 // Find the logical position of the event given the DC
1349 wxPoint GetLogicalPosition(const wxDC& dc) const;
1350
1351 // Get X position
1352 wxCoord GetX() const { return m_x; }
1353
1354 // Get Y position
1355 wxCoord GetY() const { return m_y; }
1356
1357 // Get wheel rotation, positive or negative indicates direction of
1358 // rotation. Current devices all send an event when rotation is equal to
1359 // +/-WheelDelta, but this allows for finer resolution devices to be
1360 // created in the future. Because of this you shouldn't assume that one
1361 // event is equal to 1 line or whatever, but you should be able to either
1362 // do partial line scrolling or wait until +/-WheelDelta rotation values
1363 // have been accumulated before scrolling.
1364 int GetWheelRotation() const { return m_wheelRotation; }
1365
1366 // Get wheel delta, normally 120. This is the threshold for action to be
1367 // taken, and one such action (for example, scrolling one increment)
1368 // should occur for each delta.
1369 int GetWheelDelta() const { return m_wheelDelta; }
1370
1371 // Gets the axis the wheel operation concerns, 0 being the y axis as on
1372 // most mouse wheels, 1 is the x axis for things like MightyMouse scrolls
1373 // or horizontal trackpad scrolling
1374 int GetWheelAxis() const { return m_wheelAxis; }
1375
1376 // Returns the configured number of lines (or whatever) to be scrolled per
1377 // wheel action. Defaults to one.
1378 int GetLinesPerAction() const { return m_linesPerAction; }
1379
1380 // Is the system set to do page scrolling?
1381 bool IsPageScroll() const { return ((unsigned int)m_linesPerAction == UINT_MAX); }
1382
1383 virtual wxEvent *Clone() const { return new wxMouseEvent(*this); }
1384 virtual wxEventCategory GetEventCategory() const { return wxEVT_CATEGORY_USER_INPUT; }
1385
1386 wxMouseEvent& operator=(const wxMouseEvent& event)
1387 {
1388 if (&event != this)
1389 Assign(event);
1390 return *this;
1391 }
1392
1393public:
1394 wxCoord m_x, m_y;
1395
1396 bool m_leftDown;
1397 bool m_middleDown;
1398 bool m_rightDown;
1399 bool m_aux1Down;
1400 bool m_aux2Down;
1401
1402 int m_clickCount;
1403
1404 int m_wheelAxis;
1405 int m_wheelRotation;
1406 int m_wheelDelta;
1407 int m_linesPerAction;
1408
1409protected:
1410 void Assign(const wxMouseEvent& evt);
1411
1412private:
1413 DECLARE_DYNAMIC_CLASS(wxMouseEvent)
1414};
1415
1416// Cursor set event
1417
1418/*
1419 wxEVT_SET_CURSOR
1420 */
1421
1422class WXDLLIMPEXP_CORE wxSetCursorEvent : public wxEvent
1423{
1424public:
1425 wxSetCursorEvent(wxCoord x = 0, wxCoord y = 0)
1426 : wxEvent(0, wxEVT_SET_CURSOR),
1427 m_x(x), m_y(y), m_cursor()
1428 { }
1429
1430 wxSetCursorEvent(const wxSetCursorEvent& event)
1431 : wxEvent(event),
1432 m_x(event.m_x),
1433 m_y(event.m_y),
1434 m_cursor(event.m_cursor)
1435 { }
1436
1437 wxCoord GetX() const { return m_x; }
1438 wxCoord GetY() const { return m_y; }
1439
1440 void SetCursor(const wxCursor& cursor) { m_cursor = cursor; }
1441 const wxCursor& GetCursor() const { return m_cursor; }
1442 bool HasCursor() const { return m_cursor.Ok(); }
1443
1444 virtual wxEvent *Clone() const { return new wxSetCursorEvent(*this); }
1445
1446private:
1447 wxCoord m_x, m_y;
1448 wxCursor m_cursor;
1449
1450private:
1451 DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxSetCursorEvent)
1452};
1453
1454// Keyboard input event class
1455
1456/*
1457 wxEVT_CHAR
1458 wxEVT_CHAR_HOOK
1459 wxEVT_KEY_DOWN
1460 wxEVT_KEY_UP
1461 wxEVT_HOTKEY
1462 */
1463
1464class WXDLLIMPEXP_CORE wxKeyEvent : public wxEvent,
1465 public wxKeyboardState
1466{
1467public:
1468 wxKeyEvent(wxEventType keyType = wxEVT_NULL);
1469 wxKeyEvent(const wxKeyEvent& evt);
1470
1471 // get the key code: an ASCII7 char or an element of wxKeyCode enum
1472 int GetKeyCode() const { return (int)m_keyCode; }
1473
1474#if wxUSE_UNICODE
1475 // get the Unicode character corresponding to this key
1476 wxChar GetUnicodeKey() const { return m_uniChar; }
1477#endif // wxUSE_UNICODE
1478
1479 // get the raw key code (platform-dependent)
1480 wxUint32 GetRawKeyCode() const { return m_rawCode; }
1481
1482 // get the raw key flags (platform-dependent)
1483 wxUint32 GetRawKeyFlags() const { return m_rawFlags; }
1484
1485 // Find the position of the event
1486 void GetPosition(wxCoord *xpos, wxCoord *ypos) const
1487 {
1488 if (xpos) *xpos = m_x;
1489 if (ypos) *ypos = m_y;
1490 }
1491
1492 void GetPosition(long *xpos, long *ypos) const
1493 {
1494 if (xpos) *xpos = (long)m_x;
1495 if (ypos) *ypos = (long)m_y;
1496 }
1497
1498 wxPoint GetPosition() const
1499 { return wxPoint(m_x, m_y); }
1500
1501 // Get X position
1502 wxCoord GetX() const { return m_x; }
1503
1504 // Get Y position
1505 wxCoord GetY() const { return m_y; }
1506
1507 virtual wxEvent *Clone() const { return new wxKeyEvent(*this); }
1508 virtual wxEventCategory GetEventCategory() const { return wxEVT_CATEGORY_USER_INPUT; }
1509
1510 // we do need to copy wxKeyEvent sometimes (in wxTreeCtrl code, for
1511 // example)
1512 wxKeyEvent& operator=(const wxKeyEvent& evt)
1513 {
1514 if ( &evt != this )
1515 {
1516 wxEvent::operator=(evt);
1517
1518 // Borland C++ 5.82 doesn't compile an explicit call to an
1519 // implicitly defined operator=() so need to do it this way:
1520 *static_cast<wxKeyboardState *>(this) = evt;
1521
1522 m_x = evt.m_x;
1523 m_y = evt.m_y;
1524
1525 m_keyCode = evt.m_keyCode;
1526
1527 m_rawCode = evt.m_rawCode;
1528 m_rawFlags = evt.m_rawFlags;
1529#if wxUSE_UNICODE
1530 m_uniChar = evt.m_uniChar;
1531#endif
1532 }
1533 return *this;
1534 }
1535
1536public:
1537 wxCoord m_x, m_y;
1538
1539 long m_keyCode;
1540
1541#if wxUSE_UNICODE
1542 // This contains the full Unicode character
1543 // in a character events in Unicode mode
1544 wxChar m_uniChar;
1545#endif
1546
1547 // these fields contain the platform-specific information about
1548 // key that was pressed
1549 wxUint32 m_rawCode;
1550 wxUint32 m_rawFlags;
1551
1552private:
1553 DECLARE_DYNAMIC_CLASS(wxKeyEvent)
1554};
1555
1556// Size event class
1557/*
1558 wxEVT_SIZE
1559 */
1560
1561class WXDLLIMPEXP_CORE wxSizeEvent : public wxEvent
1562{
1563public:
1564 wxSizeEvent() : wxEvent(0, wxEVT_SIZE)
1565 { }
1566 wxSizeEvent(const wxSize& sz, int winid = 0)
1567 : wxEvent(winid, wxEVT_SIZE),
1568 m_size(sz)
1569 { }
1570 wxSizeEvent(const wxSizeEvent& event)
1571 : wxEvent(event),
1572 m_size(event.m_size), m_rect(event.m_rect)
1573 { }
1574 wxSizeEvent(const wxRect& rect, int id = 0)
1575 : m_size(rect.GetSize()), m_rect(rect)
1576 { m_eventType = wxEVT_SIZING; m_id = id; }
1577
1578 wxSize GetSize() const { return m_size; }
1579 wxRect GetRect() const { return m_rect; }
1580 void SetRect(const wxRect& rect) { m_rect = rect; }
1581
1582 virtual wxEvent *Clone() const { return new wxSizeEvent(*this); }
1583
1584public:
1585 // For internal usage only. Will be converted to protected members.
1586 wxSize m_size;
1587 wxRect m_rect; // Used for wxEVT_SIZING
1588
1589private:
1590 DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxSizeEvent)
1591};
1592
1593// Move event class
1594
1595/*
1596 wxEVT_MOVE
1597 */
1598
1599class WXDLLIMPEXP_CORE wxMoveEvent : public wxEvent
1600{
1601public:
1602 wxMoveEvent()
1603 : wxEvent(0, wxEVT_MOVE)
1604 { }
1605 wxMoveEvent(const wxPoint& pos, int winid = 0)
1606 : wxEvent(winid, wxEVT_MOVE),
1607 m_pos(pos)
1608 { }
1609 wxMoveEvent(const wxMoveEvent& event)
1610 : wxEvent(event),
1611 m_pos(event.m_pos)
1612 { }
1613 wxMoveEvent(const wxRect& rect, int id = 0)
1614 : m_pos(rect.GetPosition()), m_rect(rect)
1615 { m_eventType = wxEVT_MOVING; m_id = id; }
1616
1617 wxPoint GetPosition() const { return m_pos; }
1618 void SetPosition(const wxPoint& pos) { m_pos = pos; }
1619 wxRect GetRect() const { return m_rect; }
1620 void SetRect(const wxRect& rect) { m_rect = rect; }
1621
1622 virtual wxEvent *Clone() const { return new wxMoveEvent(*this); }
1623
1624protected:
1625 wxPoint m_pos;
1626 wxRect m_rect;
1627
1628private:
1629 DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxMoveEvent)
1630};
1631
1632// Paint event class
1633/*
1634 wxEVT_PAINT
1635 wxEVT_NC_PAINT
1636 wxEVT_PAINT_ICON
1637 */
1638
1639#if wxDEBUG_LEVEL && (defined(__WXMSW__) || defined(__WXPM__))
1640 #define wxHAS_PAINT_DEBUG
1641
1642 // see comments in src/msw|os2/dcclient.cpp where g_isPainting is defined
1643 extern WXDLLIMPEXP_CORE int g_isPainting;
1644#endif // debug
1645
1646class WXDLLIMPEXP_CORE wxPaintEvent : public wxEvent
1647{
1648public:
1649 wxPaintEvent(int Id = 0)
1650 : wxEvent(Id, wxEVT_PAINT)
1651 {
1652#ifdef wxHAS_PAINT_DEBUG
1653 // set the internal flag for the duration of redrawing
1654 g_isPainting++;
1655#endif // debug
1656 }
1657
1658 // default copy ctor and dtor are normally fine, we only need them to keep
1659 // g_isPainting updated in debug build
1660#ifdef wxHAS_PAINT_DEBUG
1661 wxPaintEvent(const wxPaintEvent& event)
1662 : wxEvent(event)
1663 {
1664 g_isPainting++;
1665 }
1666
1667 virtual ~wxPaintEvent()
1668 {
1669 g_isPainting--;
1670 }
1671#endif // debug
1672
1673 virtual wxEvent *Clone() const { return new wxPaintEvent(*this); }
1674
1675private:
1676 DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxPaintEvent)
1677};
1678
1679class WXDLLIMPEXP_CORE wxNcPaintEvent : public wxEvent
1680{
1681public:
1682 wxNcPaintEvent(int winid = 0)
1683 : wxEvent(winid, wxEVT_NC_PAINT)
1684 { }
1685
1686 virtual wxEvent *Clone() const { return new wxNcPaintEvent(*this); }
1687
1688private:
1689 DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxNcPaintEvent)
1690};
1691
1692// Erase background event class
1693/*
1694 wxEVT_ERASE_BACKGROUND
1695 */
1696
1697class WXDLLIMPEXP_CORE wxEraseEvent : public wxEvent
1698{
1699public:
1700 wxEraseEvent(int Id = 0, wxDC *dc = NULL)
1701 : wxEvent(Id, wxEVT_ERASE_BACKGROUND),
1702 m_dc(dc)
1703 { }
1704
1705 wxEraseEvent(const wxEraseEvent& event)
1706 : wxEvent(event),
1707 m_dc(event.m_dc)
1708 { }
1709
1710 wxDC *GetDC() const { return m_dc; }
1711
1712 virtual wxEvent *Clone() const { return new wxEraseEvent(*this); }
1713
1714protected:
1715 wxDC *m_dc;
1716
1717private:
1718 DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxEraseEvent)
1719};
1720
1721// Focus event class
1722/*
1723 wxEVT_SET_FOCUS
1724 wxEVT_KILL_FOCUS
1725 */
1726
1727class WXDLLIMPEXP_CORE wxFocusEvent : public wxEvent
1728{
1729public:
1730 wxFocusEvent(wxEventType type = wxEVT_NULL, int winid = 0)
1731 : wxEvent(winid, type)
1732 { m_win = NULL; }
1733
1734 wxFocusEvent(const wxFocusEvent& event)
1735 : wxEvent(event)
1736 { m_win = event.m_win; }
1737
1738 // The window associated with this event is the window which had focus
1739 // before for SET event and the window which will have focus for the KILL
1740 // one. NB: it may be NULL in both cases!
1741 wxWindow *GetWindow() const { return m_win; }
1742 void SetWindow(wxWindow *win) { m_win = win; }
1743
1744 virtual wxEvent *Clone() const { return new wxFocusEvent(*this); }
1745
1746private:
1747 wxWindow *m_win;
1748
1749private:
1750 DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxFocusEvent)
1751};
1752
1753// wxChildFocusEvent notifies the parent that a child has got the focus: unlike
1754// wxFocusEvent it is propagated upwards the window chain
1755class WXDLLIMPEXP_CORE wxChildFocusEvent : public wxCommandEvent
1756{
1757public:
1758 wxChildFocusEvent(wxWindow *win = NULL);
1759
1760 wxWindow *GetWindow() const { return (wxWindow *)GetEventObject(); }
1761
1762 virtual wxEvent *Clone() const { return new wxChildFocusEvent(*this); }
1763
1764private:
1765 DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxChildFocusEvent)
1766};
1767
1768// Activate event class
1769/*
1770 wxEVT_ACTIVATE
1771 wxEVT_ACTIVATE_APP
1772 wxEVT_HIBERNATE
1773 */
1774
1775class WXDLLIMPEXP_CORE wxActivateEvent : public wxEvent
1776{
1777public:
1778 wxActivateEvent(wxEventType type = wxEVT_NULL, bool active = true, int Id = 0)
1779 : wxEvent(Id, type)
1780 { m_active = active; }
1781 wxActivateEvent(const wxActivateEvent& event)
1782 : wxEvent(event)
1783 { m_active = event.m_active; }
1784
1785 bool GetActive() const { return m_active; }
1786
1787 virtual wxEvent *Clone() const { return new wxActivateEvent(*this); }
1788
1789private:
1790 bool m_active;
1791
1792private:
1793 DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxActivateEvent)
1794};
1795
1796// InitDialog event class
1797/*
1798 wxEVT_INIT_DIALOG
1799 */
1800
1801class WXDLLIMPEXP_CORE wxInitDialogEvent : public wxEvent
1802{
1803public:
1804 wxInitDialogEvent(int Id = 0)
1805 : wxEvent(Id, wxEVT_INIT_DIALOG)
1806 { }
1807
1808 virtual wxEvent *Clone() const { return new wxInitDialogEvent(*this); }
1809
1810private:
1811 DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxInitDialogEvent)
1812};
1813
1814// Miscellaneous menu event class
1815/*
1816 wxEVT_MENU_OPEN,
1817 wxEVT_MENU_CLOSE,
1818 wxEVT_MENU_HIGHLIGHT,
1819*/
1820
1821class WXDLLIMPEXP_CORE wxMenuEvent : public wxEvent
1822{
1823public:
1824 wxMenuEvent(wxEventType type = wxEVT_NULL, int winid = 0, wxMenu* menu = NULL)
1825 : wxEvent(winid, type)
1826 { m_menuId = winid; m_menu = menu; }
1827 wxMenuEvent(const wxMenuEvent& event)
1828 : wxEvent(event)
1829 { m_menuId = event.m_menuId; m_menu = event.m_menu; }
1830
1831 // only for wxEVT_MENU_HIGHLIGHT
1832 int GetMenuId() const { return m_menuId; }
1833
1834 // only for wxEVT_MENU_OPEN/CLOSE
1835 bool IsPopup() const { return m_menuId == wxID_ANY; }
1836
1837 // only for wxEVT_MENU_OPEN/CLOSE
1838 wxMenu* GetMenu() const { return m_menu; }
1839
1840 virtual wxEvent *Clone() const { return new wxMenuEvent(*this); }
1841
1842private:
1843 int m_menuId;
1844 wxMenu* m_menu;
1845
1846 DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxMenuEvent)
1847};
1848
1849// Window close or session close event class
1850/*
1851 wxEVT_CLOSE_WINDOW,
1852 wxEVT_END_SESSION,
1853 wxEVT_QUERY_END_SESSION
1854 */
1855
1856class WXDLLIMPEXP_CORE wxCloseEvent : public wxEvent
1857{
1858public:
1859 wxCloseEvent(wxEventType type = wxEVT_NULL, int winid = 0)
1860 : wxEvent(winid, type),
1861 m_loggingOff(true),
1862 m_veto(false), // should be false by default
1863 m_canVeto(true) {}
1864
1865 wxCloseEvent(const wxCloseEvent& event)
1866 : wxEvent(event),
1867 m_loggingOff(event.m_loggingOff),
1868 m_veto(event.m_veto),
1869 m_canVeto(event.m_canVeto) {}
1870
1871 void SetLoggingOff(bool logOff) { m_loggingOff = logOff; }
1872 bool GetLoggingOff() const
1873 {
1874 // m_loggingOff flag is only used by wxEVT_[QUERY_]END_SESSION, it
1875 // doesn't make sense for wxEVT_CLOSE_WINDOW
1876 wxASSERT_MSG( m_eventType != wxEVT_CLOSE_WINDOW,
1877 _T("this flag is for end session events only") );
1878
1879 return m_loggingOff;
1880 }
1881
1882 void Veto(bool veto = true)
1883 {
1884 // GetVeto() will return false anyhow...
1885 wxCHECK_RET( m_canVeto,
1886 wxT("call to Veto() ignored (can't veto this event)") );
1887
1888 m_veto = veto;
1889 }
1890 void SetCanVeto(bool canVeto) { m_canVeto = canVeto; }
1891 bool CanVeto() const { return m_canVeto; }
1892 bool GetVeto() const { return m_canVeto && m_veto; }
1893
1894 virtual wxEvent *Clone() const { return new wxCloseEvent(*this); }
1895
1896protected:
1897 bool m_loggingOff,
1898 m_veto,
1899 m_canVeto;
1900
1901private:
1902 DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxCloseEvent)
1903};
1904
1905/*
1906 wxEVT_SHOW
1907 */
1908
1909class WXDLLIMPEXP_CORE wxShowEvent : public wxEvent
1910{
1911public:
1912 wxShowEvent(int winid = 0, bool show = false)
1913 : wxEvent(winid, wxEVT_SHOW)
1914 { m_show = show; }
1915 wxShowEvent(const wxShowEvent& event)
1916 : wxEvent(event)
1917 { m_show = event.m_show; }
1918
1919 void SetShow(bool show) { m_show = show; }
1920
1921 // return true if the window was shown, false if hidden
1922 bool IsShown() const { return m_show; }
1923
1924#if WXWIN_COMPATIBILITY_2_8
1925 wxDEPRECATED( bool GetShow() const { return IsShown(); } )
1926#endif
1927
1928 virtual wxEvent *Clone() const { return new wxShowEvent(*this); }
1929
1930protected:
1931 bool m_show;
1932
1933private:
1934 DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxShowEvent)
1935};
1936
1937/*
1938 wxEVT_ICONIZE
1939 */
1940
1941class WXDLLIMPEXP_CORE wxIconizeEvent : public wxEvent
1942{
1943public:
1944 wxIconizeEvent(int winid = 0, bool iconized = true)
1945 : wxEvent(winid, wxEVT_ICONIZE)
1946 { m_iconized = iconized; }
1947 wxIconizeEvent(const wxIconizeEvent& event)
1948 : wxEvent(event)
1949 { m_iconized = event.m_iconized; }
1950
1951#if WXWIN_COMPATIBILITY_2_8
1952 wxDEPRECATED( bool Iconized() const { return IsIconized(); } )
1953#endif
1954 // return true if the frame was iconized, false if restored
1955 bool IsIconized() const { return m_iconized; }
1956
1957 virtual wxEvent *Clone() const { return new wxIconizeEvent(*this); }
1958
1959protected:
1960 bool m_iconized;
1961
1962private:
1963 DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxIconizeEvent)
1964};
1965/*
1966 wxEVT_MAXIMIZE
1967 */
1968
1969class WXDLLIMPEXP_CORE wxMaximizeEvent : public wxEvent
1970{
1971public:
1972 wxMaximizeEvent(int winid = 0)
1973 : wxEvent(winid, wxEVT_MAXIMIZE)
1974 { }
1975
1976 virtual wxEvent *Clone() const { return new wxMaximizeEvent(*this); }
1977
1978private:
1979 DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxMaximizeEvent)
1980};
1981
1982// Joystick event class
1983/*
1984 wxEVT_JOY_BUTTON_DOWN,
1985 wxEVT_JOY_BUTTON_UP,
1986 wxEVT_JOY_MOVE,
1987 wxEVT_JOY_ZMOVE
1988*/
1989
1990// Which joystick? Same as Windows ids so no conversion necessary.
1991enum
1992{
1993 wxJOYSTICK1,
1994 wxJOYSTICK2
1995};
1996
1997// Which button is down?
1998enum
1999{
2000 wxJOY_BUTTON_ANY = -1,
2001 wxJOY_BUTTON1 = 1,
2002 wxJOY_BUTTON2 = 2,
2003 wxJOY_BUTTON3 = 4,
2004 wxJOY_BUTTON4 = 8
2005};
2006
2007class WXDLLIMPEXP_CORE wxJoystickEvent : public wxEvent
2008{
2009protected:
2010 wxPoint m_pos;
2011 int m_zPosition;
2012 int m_buttonChange; // Which button changed?
2013 int m_buttonState; // Which buttons are down?
2014 int m_joyStick; // Which joystick?
2015
2016public:
2017 wxJoystickEvent(wxEventType type = wxEVT_NULL,
2018 int state = 0,
2019 int joystick = wxJOYSTICK1,
2020 int change = 0)
2021 : wxEvent(0, type),
2022 m_pos(),
2023 m_zPosition(0),
2024 m_buttonChange(change),
2025 m_buttonState(state),
2026 m_joyStick(joystick)
2027 {
2028 }
2029 wxJoystickEvent(const wxJoystickEvent& event)
2030 : wxEvent(event),
2031 m_pos(event.m_pos),
2032 m_zPosition(event.m_zPosition),
2033 m_buttonChange(event.m_buttonChange),
2034 m_buttonState(event.m_buttonState),
2035 m_joyStick(event.m_joyStick)
2036 { }
2037
2038 wxPoint GetPosition() const { return m_pos; }
2039 int GetZPosition() const { return m_zPosition; }
2040 int GetButtonState() const { return m_buttonState; }
2041 int GetButtonChange() const { return m_buttonChange; }
2042 int GetJoystick() const { return m_joyStick; }
2043
2044 void SetJoystick(int stick) { m_joyStick = stick; }
2045 void SetButtonState(int state) { m_buttonState = state; }
2046 void SetButtonChange(int change) { m_buttonChange = change; }
2047 void SetPosition(const wxPoint& pos) { m_pos = pos; }
2048 void SetZPosition(int zPos) { m_zPosition = zPos; }
2049
2050 // Was it a button event? (*doesn't* mean: is any button *down*?)
2051 bool IsButton() const { return ((GetEventType() == wxEVT_JOY_BUTTON_DOWN) ||
2052 (GetEventType() == wxEVT_JOY_BUTTON_UP)); }
2053
2054 // Was it a move event?
2055 bool IsMove() const { return (GetEventType() == wxEVT_JOY_MOVE); }
2056
2057 // Was it a zmove event?
2058 bool IsZMove() const { return (GetEventType() == wxEVT_JOY_ZMOVE); }
2059
2060 // Was it a down event from button 1, 2, 3, 4 or any?
2061 bool ButtonDown(int but = wxJOY_BUTTON_ANY) const
2062 { return ((GetEventType() == wxEVT_JOY_BUTTON_DOWN) &&
2063 ((but == wxJOY_BUTTON_ANY) || (but == m_buttonChange))); }
2064
2065 // Was it a up event from button 1, 2, 3 or any?
2066 bool ButtonUp(int but = wxJOY_BUTTON_ANY) const
2067 { return ((GetEventType() == wxEVT_JOY_BUTTON_UP) &&
2068 ((but == wxJOY_BUTTON_ANY) || (but == m_buttonChange))); }
2069
2070 // Was the given button 1,2,3,4 or any in Down state?
2071 bool ButtonIsDown(int but = wxJOY_BUTTON_ANY) const
2072 { return (((but == wxJOY_BUTTON_ANY) && (m_buttonState != 0)) ||
2073 ((m_buttonState & but) == but)); }
2074
2075 virtual wxEvent *Clone() const { return new wxJoystickEvent(*this); }
2076
2077private:
2078 DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxJoystickEvent)
2079};
2080
2081// Drop files event class
2082/*
2083 wxEVT_DROP_FILES
2084 */
2085
2086class WXDLLIMPEXP_CORE wxDropFilesEvent : public wxEvent
2087{
2088public:
2089 int m_noFiles;
2090 wxPoint m_pos;
2091 wxString* m_files;
2092
2093 wxDropFilesEvent(wxEventType type = wxEVT_NULL,
2094 int noFiles = 0,
2095 wxString *files = NULL)
2096 : wxEvent(0, type),
2097 m_noFiles(noFiles),
2098 m_pos(),
2099 m_files(files)
2100 { }
2101
2102 // we need a copy ctor to avoid deleting m_files pointer twice
2103 wxDropFilesEvent(const wxDropFilesEvent& other)
2104 : wxEvent(other),
2105 m_noFiles(other.m_noFiles),
2106 m_pos(other.m_pos),
2107 m_files(NULL)
2108 {
2109 m_files = new wxString[m_noFiles];
2110 for ( int n = 0; n < m_noFiles; n++ )
2111 {
2112 m_files[n] = other.m_files[n];
2113 }
2114 }
2115
2116 virtual ~wxDropFilesEvent()
2117 {
2118 delete [] m_files;
2119 }
2120
2121 wxPoint GetPosition() const { return m_pos; }
2122 int GetNumberOfFiles() const { return m_noFiles; }
2123 wxString *GetFiles() const { return m_files; }
2124
2125 virtual wxEvent *Clone() const { return new wxDropFilesEvent(*this); }
2126
2127private:
2128 DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxDropFilesEvent)
2129};
2130
2131// Update UI event
2132/*
2133 wxEVT_UPDATE_UI
2134 */
2135
2136// Whether to always send update events to windows, or
2137// to only send update events to those with the
2138// wxWS_EX_PROCESS_UI_UPDATES style.
2139
2140enum wxUpdateUIMode
2141{
2142 // Send UI update events to all windows
2143 wxUPDATE_UI_PROCESS_ALL,
2144
2145 // Send UI update events to windows that have
2146 // the wxWS_EX_PROCESS_UI_UPDATES flag specified
2147 wxUPDATE_UI_PROCESS_SPECIFIED
2148};
2149
2150class WXDLLIMPEXP_CORE wxUpdateUIEvent : public wxCommandEvent
2151{
2152public:
2153 wxUpdateUIEvent(wxWindowID commandId = 0)
2154 : wxCommandEvent(wxEVT_UPDATE_UI, commandId)
2155 {
2156 m_checked =
2157 m_enabled =
2158 m_shown =
2159 m_setEnabled =
2160 m_setShown =
2161 m_setText =
2162 m_setChecked = false;
2163 }
2164 wxUpdateUIEvent(const wxUpdateUIEvent& event)
2165 : wxCommandEvent(event),
2166 m_checked(event.m_checked),
2167 m_enabled(event.m_enabled),
2168 m_shown(event.m_shown),
2169 m_setEnabled(event.m_setEnabled),
2170 m_setShown(event.m_setShown),
2171 m_setText(event.m_setText),
2172 m_setChecked(event.m_setChecked),
2173 m_text(event.m_text)
2174 { }
2175
2176 bool GetChecked() const { return m_checked; }
2177 bool GetEnabled() const { return m_enabled; }
2178 bool GetShown() const { return m_shown; }
2179 wxString GetText() const { return m_text; }
2180 bool GetSetText() const { return m_setText; }
2181 bool GetSetChecked() const { return m_setChecked; }
2182 bool GetSetEnabled() const { return m_setEnabled; }
2183 bool GetSetShown() const { return m_setShown; }
2184
2185 void Check(bool check) { m_checked = check; m_setChecked = true; }
2186 void Enable(bool enable) { m_enabled = enable; m_setEnabled = true; }
2187 void Show(bool show) { m_shown = show; m_setShown = true; }
2188 void SetText(const wxString& text) { m_text = text; m_setText = true; }
2189
2190 // Sets the interval between updates in milliseconds.
2191 // Set to -1 to disable updates, or to 0 to update as frequently as possible.
2192 static void SetUpdateInterval(long updateInterval) { sm_updateInterval = updateInterval; }
2193
2194 // Returns the current interval between updates in milliseconds
2195 static long GetUpdateInterval() { return sm_updateInterval; }
2196
2197 // Can we update this window?
2198 static bool CanUpdate(wxWindowBase *win);
2199
2200 // Reset the update time to provide a delay until the next
2201 // time we should update
2202 static void ResetUpdateTime();
2203
2204 // Specify how wxWidgets will send update events: to
2205 // all windows, or only to those which specify that they
2206 // will process the events.
2207 static void SetMode(wxUpdateUIMode mode) { sm_updateMode = mode; }
2208
2209 // Returns the UI update mode
2210 static wxUpdateUIMode GetMode() { return sm_updateMode; }
2211
2212 virtual wxEvent *Clone() const { return new wxUpdateUIEvent(*this); }
2213
2214protected:
2215 bool m_checked;
2216 bool m_enabled;
2217 bool m_shown;
2218 bool m_setEnabled;
2219 bool m_setShown;
2220 bool m_setText;
2221 bool m_setChecked;
2222 wxString m_text;
2223#if wxUSE_LONGLONG
2224 static wxLongLong sm_lastUpdate;
2225#endif
2226 static long sm_updateInterval;
2227 static wxUpdateUIMode sm_updateMode;
2228
2229private:
2230 DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxUpdateUIEvent)
2231};
2232
2233/*
2234 wxEVT_SYS_COLOUR_CHANGED
2235 */
2236
2237// TODO: shouldn't all events record the window ID?
2238class WXDLLIMPEXP_CORE wxSysColourChangedEvent : public wxEvent
2239{
2240public:
2241 wxSysColourChangedEvent()
2242 : wxEvent(0, wxEVT_SYS_COLOUR_CHANGED)
2243 { }
2244
2245 virtual wxEvent *Clone() const { return new wxSysColourChangedEvent(*this); }
2246
2247private:
2248 DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxSysColourChangedEvent)
2249};
2250
2251/*
2252 wxEVT_MOUSE_CAPTURE_CHANGED
2253 The window losing the capture receives this message
2254 (even if it released the capture itself).
2255 */
2256
2257class WXDLLIMPEXP_CORE wxMouseCaptureChangedEvent : public wxEvent
2258{
2259public:
2260 wxMouseCaptureChangedEvent(wxWindowID winid = 0, wxWindow* gainedCapture = NULL)
2261 : wxEvent(winid, wxEVT_MOUSE_CAPTURE_CHANGED),
2262 m_gainedCapture(gainedCapture)
2263 { }
2264
2265 wxMouseCaptureChangedEvent(const wxMouseCaptureChangedEvent& event)
2266 : wxEvent(event),
2267 m_gainedCapture(event.m_gainedCapture)
2268 { }
2269
2270 virtual wxEvent *Clone() const { return new wxMouseCaptureChangedEvent(*this); }
2271
2272 wxWindow* GetCapturedWindow() const { return m_gainedCapture; }
2273
2274private:
2275 wxWindow* m_gainedCapture;
2276
2277 DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxMouseCaptureChangedEvent)
2278};
2279
2280/*
2281 wxEVT_MOUSE_CAPTURE_LOST
2282 The window losing the capture receives this message, unless it released it
2283 it itself or unless wxWindow::CaptureMouse was called on another window
2284 (and so capture will be restored when the new capturer releases it).
2285 */
2286
2287class WXDLLIMPEXP_CORE wxMouseCaptureLostEvent : public wxEvent
2288{
2289public:
2290 wxMouseCaptureLostEvent(wxWindowID winid = 0)
2291 : wxEvent(winid, wxEVT_MOUSE_CAPTURE_LOST)
2292 {}
2293
2294 wxMouseCaptureLostEvent(const wxMouseCaptureLostEvent& event)
2295 : wxEvent(event)
2296 {}
2297
2298 virtual wxEvent *Clone() const { return new wxMouseCaptureLostEvent(*this); }
2299
2300 DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxMouseCaptureLostEvent)
2301};
2302
2303/*
2304 wxEVT_DISPLAY_CHANGED
2305 */
2306class WXDLLIMPEXP_CORE wxDisplayChangedEvent : public wxEvent
2307{
2308private:
2309 DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxDisplayChangedEvent)
2310
2311public:
2312 wxDisplayChangedEvent()
2313 : wxEvent(0, wxEVT_DISPLAY_CHANGED)
2314 { }
2315
2316 virtual wxEvent *Clone() const { return new wxDisplayChangedEvent(*this); }
2317};
2318
2319/*
2320 wxEVT_PALETTE_CHANGED
2321 */
2322
2323class WXDLLIMPEXP_CORE wxPaletteChangedEvent : public wxEvent
2324{
2325public:
2326 wxPaletteChangedEvent(wxWindowID winid = 0)
2327 : wxEvent(winid, wxEVT_PALETTE_CHANGED),
2328 m_changedWindow(NULL)
2329 { }
2330
2331 wxPaletteChangedEvent(const wxPaletteChangedEvent& event)
2332 : wxEvent(event),
2333 m_changedWindow(event.m_changedWindow)
2334 { }
2335
2336 void SetChangedWindow(wxWindow* win) { m_changedWindow = win; }
2337 wxWindow* GetChangedWindow() const { return m_changedWindow; }
2338
2339 virtual wxEvent *Clone() const { return new wxPaletteChangedEvent(*this); }
2340
2341protected:
2342 wxWindow* m_changedWindow;
2343
2344private:
2345 DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxPaletteChangedEvent)
2346};
2347
2348/*
2349 wxEVT_QUERY_NEW_PALETTE
2350 Indicates the window is getting keyboard focus and should re-do its palette.
2351 */
2352
2353class WXDLLIMPEXP_CORE wxQueryNewPaletteEvent : public wxEvent
2354{
2355public:
2356 wxQueryNewPaletteEvent(wxWindowID winid = 0)
2357 : wxEvent(winid, wxEVT_QUERY_NEW_PALETTE),
2358 m_paletteRealized(false)
2359 { }
2360 wxQueryNewPaletteEvent(const wxQueryNewPaletteEvent& event)
2361 : wxEvent(event),
2362 m_paletteRealized(event.m_paletteRealized)
2363 { }
2364
2365 // App sets this if it changes the palette.
2366 void SetPaletteRealized(bool realized) { m_paletteRealized = realized; }
2367 bool GetPaletteRealized() const { return m_paletteRealized; }
2368
2369 virtual wxEvent *Clone() const { return new wxQueryNewPaletteEvent(*this); }
2370
2371protected:
2372 bool m_paletteRealized;
2373
2374private:
2375 DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxQueryNewPaletteEvent)
2376};
2377
2378/*
2379 Event generated by dialog navigation keys
2380 wxEVT_NAVIGATION_KEY
2381 */
2382// NB: don't derive from command event to avoid being propagated to the parent
2383class WXDLLIMPEXP_CORE wxNavigationKeyEvent : public wxEvent
2384{
2385public:
2386 wxNavigationKeyEvent()
2387 : wxEvent(0, wxEVT_NAVIGATION_KEY),
2388 m_flags(IsForward | FromTab), // defaults are for TAB
2389 m_focus(NULL)
2390 {
2391 m_propagationLevel = wxEVENT_PROPAGATE_NONE;
2392 }
2393
2394 wxNavigationKeyEvent(const wxNavigationKeyEvent& event)
2395 : wxEvent(event),
2396 m_flags(event.m_flags),
2397 m_focus(event.m_focus)
2398 { }
2399
2400 // direction: forward (true) or backward (false)
2401 bool GetDirection() const
2402 { return (m_flags & IsForward) != 0; }
2403 void SetDirection(bool bForward)
2404 { if ( bForward ) m_flags |= IsForward; else m_flags &= ~IsForward; }
2405
2406 // it may be a window change event (MDI, notebook pages...) or a control
2407 // change event
2408 bool IsWindowChange() const
2409 { return (m_flags & WinChange) != 0; }
2410 void SetWindowChange(bool bIs)
2411 { if ( bIs ) m_flags |= WinChange; else m_flags &= ~WinChange; }
2412
2413 // Set to true under MSW if the event was generated using the tab key.
2414 // This is required for proper navogation over radio buttons
2415 bool IsFromTab() const
2416 { return (m_flags & FromTab) != 0; }
2417 void SetFromTab(bool bIs)
2418 { if ( bIs ) m_flags |= FromTab; else m_flags &= ~FromTab; }
2419
2420 // the child which has the focus currently (may be NULL - use
2421 // wxWindow::FindFocus then)
2422 wxWindow* GetCurrentFocus() const { return m_focus; }
2423 void SetCurrentFocus(wxWindow *win) { m_focus = win; }
2424
2425 // Set flags
2426 void SetFlags(long flags) { m_flags = flags; }
2427
2428 virtual wxEvent *Clone() const { return new wxNavigationKeyEvent(*this); }
2429
2430 enum wxNavigationKeyEventFlags
2431 {
2432 IsBackward = 0x0000,
2433 IsForward = 0x0001,
2434 WinChange = 0x0002,
2435 FromTab = 0x0004
2436 };
2437
2438 long m_flags;
2439 wxWindow *m_focus;
2440
2441private:
2442 DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxNavigationKeyEvent)
2443};
2444
2445// Window creation/destruction events: the first is sent as soon as window is
2446// created (i.e. the underlying GUI object exists), but when the C++ object is
2447// fully initialized (so virtual functions may be called). The second,
2448// wxEVT_DESTROY, is sent right before the window is destroyed - again, it's
2449// still safe to call virtual functions at this moment
2450/*
2451 wxEVT_CREATE
2452 wxEVT_DESTROY
2453 */
2454
2455class WXDLLIMPEXP_CORE wxWindowCreateEvent : public wxCommandEvent
2456{
2457public:
2458 wxWindowCreateEvent(wxWindow *win = NULL);
2459
2460 wxWindow *GetWindow() const { return (wxWindow *)GetEventObject(); }
2461
2462 virtual wxEvent *Clone() const { return new wxWindowCreateEvent(*this); }
2463
2464private:
2465 DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxWindowCreateEvent)
2466};
2467
2468class WXDLLIMPEXP_CORE wxWindowDestroyEvent : public wxCommandEvent
2469{
2470public:
2471 wxWindowDestroyEvent(wxWindow *win = NULL);
2472
2473 wxWindow *GetWindow() const { return (wxWindow *)GetEventObject(); }
2474
2475 virtual wxEvent *Clone() const { return new wxWindowDestroyEvent(*this); }
2476
2477private:
2478 DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxWindowDestroyEvent)
2479};
2480
2481// A help event is sent when the user clicks on a window in context-help mode.
2482/*
2483 wxEVT_HELP
2484 wxEVT_DETAILED_HELP
2485*/
2486
2487class WXDLLIMPEXP_CORE wxHelpEvent : public wxCommandEvent
2488{
2489public:
2490 // how was this help event generated?
2491 enum Origin
2492 {
2493 Origin_Unknown, // unrecognized event source
2494 Origin_Keyboard, // event generated from F1 key press
2495 Origin_HelpButton // event from [?] button on the title bar (Windows)
2496 };
2497
2498 wxHelpEvent(wxEventType type = wxEVT_NULL,
2499 wxWindowID winid = 0,
2500 const wxPoint& pt = wxDefaultPosition,
2501 Origin origin = Origin_Unknown)
2502 : wxCommandEvent(type, winid),
2503 m_pos(pt),
2504 m_origin(GuessOrigin(origin))
2505 { }
2506 wxHelpEvent(const wxHelpEvent& event)
2507 : wxCommandEvent(event),
2508 m_pos(event.m_pos),
2509 m_target(event.m_target),
2510 m_link(event.m_link),
2511 m_origin(event.m_origin)
2512 { }
2513
2514 // Position of event (in screen coordinates)
2515 const wxPoint& GetPosition() const { return m_pos; }
2516 void SetPosition(const wxPoint& pos) { m_pos = pos; }
2517
2518 // Optional link to further help
2519 const wxString& GetLink() const { return m_link; }
2520 void SetLink(const wxString& link) { m_link = link; }
2521
2522 // Optional target to display help in. E.g. a window specification
2523 const wxString& GetTarget() const { return m_target; }
2524 void SetTarget(const wxString& target) { m_target = target; }
2525
2526 virtual wxEvent *Clone() const { return new wxHelpEvent(*this); }
2527
2528 // optional indication of the event source
2529 Origin GetOrigin() const { return m_origin; }
2530 void SetOrigin(Origin origin) { m_origin = origin; }
2531
2532protected:
2533 wxPoint m_pos;
2534 wxString m_target;
2535 wxString m_link;
2536 Origin m_origin;
2537
2538 // we can try to guess the event origin ourselves, even if none is
2539 // specified in the ctor
2540 static Origin GuessOrigin(Origin origin);
2541
2542private:
2543 DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxHelpEvent)
2544};
2545
2546// A Clipboard Text event is sent when a window intercepts text copy/cut/paste
2547// message, i.e. the user has cut/copied/pasted data from/into a text control
2548// via ctrl-C/X/V, ctrl/shift-del/insert, a popup menu command, etc.
2549// NOTE : under windows these events are *NOT* generated automatically
2550// for a Rich Edit text control.
2551/*
2552wxEVT_COMMAND_TEXT_COPY
2553wxEVT_COMMAND_TEXT_CUT
2554wxEVT_COMMAND_TEXT_PASTE
2555*/
2556
2557class WXDLLIMPEXP_CORE wxClipboardTextEvent : public wxCommandEvent
2558{
2559public:
2560 wxClipboardTextEvent(wxEventType type = wxEVT_NULL,
2561 wxWindowID winid = 0)
2562 : wxCommandEvent(type, winid)
2563 { }
2564 wxClipboardTextEvent(const wxClipboardTextEvent& event)
2565 : wxCommandEvent(event)
2566 { }
2567
2568 virtual wxEvent *Clone() const { return new wxClipboardTextEvent(*this); }
2569
2570private:
2571 DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxClipboardTextEvent)
2572};
2573
2574// A Context event is sent when the user right clicks on a window or
2575// presses Shift-F10
2576// NOTE : Under windows this is a repackaged WM_CONTETXMENU message
2577// Under other systems it may have to be generated from a right click event
2578/*
2579 wxEVT_CONTEXT_MENU
2580*/
2581
2582class WXDLLIMPEXP_CORE wxContextMenuEvent : public wxCommandEvent
2583{
2584public:
2585 wxContextMenuEvent(wxEventType type = wxEVT_NULL,
2586 wxWindowID winid = 0,
2587 const wxPoint& pt = wxDefaultPosition)
2588 : wxCommandEvent(type, winid),
2589 m_pos(pt)
2590 { }
2591 wxContextMenuEvent(const wxContextMenuEvent& event)
2592 : wxCommandEvent(event),
2593 m_pos(event.m_pos)
2594 { }
2595
2596 // Position of event (in screen coordinates)
2597 const wxPoint& GetPosition() const { return m_pos; }
2598 void SetPosition(const wxPoint& pos) { m_pos = pos; }
2599
2600 virtual wxEvent *Clone() const { return new wxContextMenuEvent(*this); }
2601
2602protected:
2603 wxPoint m_pos;
2604
2605private:
2606 DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxContextMenuEvent)
2607};
2608
2609#endif // wxUSE_GUI
2610
2611// Idle event
2612/*
2613 wxEVT_IDLE
2614 */
2615
2616// Whether to always send idle events to windows, or
2617// to only send update events to those with the
2618// wxWS_EX_PROCESS_IDLE style.
2619
2620enum wxIdleMode
2621{
2622 // Send idle events to all windows
2623 wxIDLE_PROCESS_ALL,
2624
2625 // Send idle events to windows that have
2626 // the wxWS_EX_PROCESS_IDLE flag specified
2627 wxIDLE_PROCESS_SPECIFIED
2628};
2629
2630class WXDLLIMPEXP_BASE wxIdleEvent : public wxEvent
2631{
2632public:
2633 wxIdleEvent()
2634 : wxEvent(0, wxEVT_IDLE),
2635 m_requestMore(false)
2636 { }
2637 wxIdleEvent(const wxIdleEvent& event)
2638 : wxEvent(event),
2639 m_requestMore(event.m_requestMore)
2640 { }
2641
2642 void RequestMore(bool needMore = true) { m_requestMore = needMore; }
2643 bool MoreRequested() const { return m_requestMore; }
2644
2645 virtual wxEvent *Clone() const { return new wxIdleEvent(*this); }
2646
2647 // Specify how wxWidgets will send idle events: to
2648 // all windows, or only to those which specify that they
2649 // will process the events.
2650 static void SetMode(wxIdleMode mode) { sm_idleMode = mode; }
2651
2652 // Returns the idle event mode
2653 static wxIdleMode GetMode() { return sm_idleMode; }
2654
2655protected:
2656 bool m_requestMore;
2657 static wxIdleMode sm_idleMode;
2658
2659private:
2660 DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxIdleEvent)
2661};
2662
2663/* TODO
2664 wxEVT_MOUSE_CAPTURE_CHANGED,
2665 wxEVT_SETTING_CHANGED, // WM_WININICHANGE (NT) / WM_SETTINGCHANGE (Win95)
2666// wxEVT_FONT_CHANGED, // WM_FONTCHANGE: roll into wxEVT_SETTING_CHANGED, but remember to propagate
2667 // wxEVT_FONT_CHANGED to all other windows (maybe).
2668 wxEVT_DRAW_ITEM, // Leave these three as virtual functions in wxControl?? Platform-specific.
2669 wxEVT_MEASURE_ITEM,
2670 wxEVT_COMPARE_ITEM
2671*/
2672
2673
2674
2675// ============================================================================
2676// event handler and related classes
2677// ============================================================================
2678
2679
2680// struct containing the members common to static and dynamic event tables
2681// entries
2682struct WXDLLIMPEXP_BASE wxEventTableEntryBase
2683{
2684 wxEventTableEntryBase(int winid, int idLast,
2685 wxEventFunctor* fn, wxObject *data)
2686 : m_id(winid),
2687 m_lastId(idLast),
2688 m_fn(fn),
2689 m_callbackUserData(data)
2690 { }
2691
2692 wxEventTableEntryBase( const wxEventTableEntryBase &entry )
2693 : m_id( entry.m_id ),
2694 m_lastId( entry.m_lastId ),
2695 m_fn( entry.m_fn ),
2696 m_callbackUserData( entry.m_callbackUserData )
2697 {
2698 // This is a 'hack' to ensure that only one instance tries to delete
2699 // the functor pointer. It is safe as long as the only place where the
2700 // copy constructor is being called is when the static event tables are
2701 // being initialized (a temporary instance is created and then this
2702 // constructor is called).
2703
2704 const_cast<wxEventTableEntryBase&>( entry ).m_fn = NULL;
2705 }
2706
2707 ~wxEventTableEntryBase()
2708 {
2709 delete m_fn;
2710 }
2711
2712 // the range of ids for this entry: if m_lastId == wxID_ANY, the range
2713 // consists only of m_id, otherwise it is m_id..m_lastId inclusive
2714 int m_id,
2715 m_lastId;
2716
2717 // function/method/functor to call
2718 wxEventFunctor* m_fn;
2719
2720 // arbitrary user data associated with the callback
2721 wxObject* m_callbackUserData;
2722
2723private:
2724 wxDECLARE_NO_ASSIGN_CLASS(wxEventTableEntryBase);
2725};
2726
2727// an entry from a static event table
2728struct WXDLLIMPEXP_BASE wxEventTableEntry : public wxEventTableEntryBase
2729{
2730 wxEventTableEntry(const int& evType, int winid, int idLast,
2731 wxEventFunctor* fn, wxObject *data)
2732 : wxEventTableEntryBase(winid, idLast, fn, data),
2733 m_eventType(evType)
2734 { }
2735
2736 // the reference to event type: this allows us to not care about the
2737 // (undefined) order in which the event table entries and the event types
2738 // are initialized: initially the value of this reference might be
2739 // invalid, but by the time it is used for the first time, all global
2740 // objects will have been initialized (including the event type constants)
2741 // and so it will have the correct value when it is needed
2742 const int& m_eventType;
2743
2744private:
2745 wxDECLARE_NO_ASSIGN_CLASS(wxEventTableEntry);
2746};
2747
2748// an entry used in dynamic event table managed by wxEvtHandler::Connect()
2749struct WXDLLIMPEXP_BASE wxDynamicEventTableEntry : public wxEventTableEntryBase
2750{
2751 wxDynamicEventTableEntry(int evType, int winid, int idLast,
2752 wxEventFunctor* fn, wxObject *data)
2753 : wxEventTableEntryBase(winid, idLast, fn, data),
2754 m_eventType(evType)
2755 { }
2756
2757 // not a reference here as we can't keep a reference to a temporary int
2758 // created to wrap the constant value typically passed to Connect() - nor
2759 // do we need it
2760 int m_eventType;
2761
2762private:
2763 wxDECLARE_NO_ASSIGN_CLASS(wxDynamicEventTableEntry);
2764};
2765
2766// ----------------------------------------------------------------------------
2767// wxEventTable: an array of event entries terminated with {0, 0, 0, 0, 0}
2768// ----------------------------------------------------------------------------
2769
2770struct WXDLLIMPEXP_BASE wxEventTable
2771{
2772 const wxEventTable *baseTable; // base event table (next in chain)
2773 const wxEventTableEntry *entries; // bottom of entry array
2774};
2775
2776// ----------------------------------------------------------------------------
2777// wxEventHashTable: a helper of wxEvtHandler to speed up wxEventTable lookups.
2778// ----------------------------------------------------------------------------
2779
2780WX_DEFINE_ARRAY_PTR(const wxEventTableEntry*, wxEventTableEntryPointerArray);
2781
2782class WXDLLIMPEXP_BASE wxEventHashTable
2783{
2784private:
2785 // Internal data structs
2786 struct EventTypeTable
2787 {
2788 wxEventType eventType;
2789 wxEventTableEntryPointerArray eventEntryTable;
2790 };
2791 typedef EventTypeTable* EventTypeTablePointer;
2792
2793public:
2794 // Constructor, needs the event table it needs to hash later on.
2795 // Note: hashing of the event table is not done in the constructor as it
2796 // can be that the event table is not yet full initialize, the hash
2797 // will gets initialized when handling the first event look-up request.
2798 wxEventHashTable(const wxEventTable &table);
2799 // Destructor.
2800 ~wxEventHashTable();
2801
2802 // Handle the given event, in other words search the event table hash
2803 // and call self->ProcessEvent() if a match was found.
2804 bool HandleEvent(wxEvent& event, wxEvtHandler *self);
2805
2806 // Clear table
2807 void Clear();
2808
2809#if wxUSE_MEMORY_TRACING
2810 // Clear all tables: only used to work around problems in memory tracing
2811 // code
2812 static void ClearAll();
2813#endif // wxUSE_MEMORY_TRACING
2814
2815protected:
2816 // Init the hash table with the entries of the static event table.
2817 void InitHashTable();
2818 // Helper funtion of InitHashTable() to insert 1 entry into the hash table.
2819 void AddEntry(const wxEventTableEntry &entry);
2820 // Allocate and init with null pointers the base hash table.
2821 void AllocEventTypeTable(size_t size);
2822 // Grow the hash table in size and transfer all items currently
2823 // in the table to the correct location in the new table.
2824 void GrowEventTypeTable();
2825
2826protected:
2827 const wxEventTable &m_table;
2828 bool m_rebuildHash;
2829
2830 size_t m_size;
2831 EventTypeTablePointer *m_eventTypeTable;
2832
2833 static wxEventHashTable* sm_first;
2834 wxEventHashTable* m_previous;
2835 wxEventHashTable* m_next;
2836
2837 wxDECLARE_NO_COPY_CLASS(wxEventHashTable);
2838};
2839
2840// ----------------------------------------------------------------------------
2841// wxEvtHandler: the base class for all objects handling wxWidgets events
2842// ----------------------------------------------------------------------------
2843
2844class WXDLLIMPEXP_BASE wxEvtHandler : public wxObject
2845 , public wxTrackable
2846{
2847public:
2848 wxEvtHandler();
2849 virtual ~wxEvtHandler();
2850
2851
2852 // Event handler chain
2853 // -------------------
2854
2855 wxEvtHandler *GetNextHandler() const { return m_nextHandler; }
2856 wxEvtHandler *GetPreviousHandler() const { return m_previousHandler; }
2857 virtual void SetNextHandler(wxEvtHandler *handler) { m_nextHandler = handler; }
2858 virtual void SetPreviousHandler(wxEvtHandler *handler) { m_previousHandler = handler; }
2859
2860 void SetEvtHandlerEnabled(bool enabled) { m_enabled = enabled; }
2861 bool GetEvtHandlerEnabled() const { return m_enabled; }
2862
2863 void Unlink();
2864 bool IsUnlinked() const;
2865
2866
2867
2868 // Event queuing and processing
2869 // ----------------------------
2870
2871 // Process an event right now: this can only be called from the main
2872 // thread, use QueueEvent() for scheduling the events for
2873 // processing from other threads.
2874 virtual bool ProcessEvent(wxEvent& event);
2875
2876 // Process an event by calling ProcessEvent and handling any exceptions
2877 // thrown by event handlers. It's mostly useful when processing wx events
2878 // when called from C code (e.g. in GTK+ callback) when the exception
2879 // wouldn't correctly propagate to wxEventLoop.
2880 bool SafelyProcessEvent(wxEvent& event);
2881 // NOTE: uses ProcessEvent()
2882
2883 // Schedule the given event to be processed later. It takes ownership of
2884 // the event pointer, i.e. it will be deleted later. This is safe to call
2885 // from multiple threads although you still need to ensure that wxString
2886 // fields of the event object are deep copies and not use the same string
2887 // buffer as other wxString objects in this thread.
2888 virtual void QueueEvent(wxEvent *event);
2889
2890 // Add an event to be processed later: notice that this function is not
2891 // safe to call from threads other than main, use QueueEvent()
2892 virtual void AddPendingEvent(const wxEvent& event)
2893 {
2894 // notice that the thread-safety problem comes from the fact that
2895 // Clone() doesn't make deep copies of wxString fields of wxEvent
2896 // object and so the same wxString could be used from both threads when
2897 // the event object is destroyed in this one -- QueueEvent() avoids
2898 // this problem as the event pointer is not used any more in this
2899 // thread at all after it is called.
2900 QueueEvent(event.Clone());
2901 }
2902
2903 void ProcessPendingEvents();
2904 // NOTE: uses ProcessEvent()
2905
2906 void DeletePendingEvents();
2907
2908#if wxUSE_THREADS
2909 bool ProcessThreadEvent(const wxEvent& event);
2910 // NOTE: uses AddPendingEvent(); call only from secondary threads
2911#endif
2912
2913
2914 // Connecting and disconnecting
2915 // ----------------------------
2916
2917 // These functions are used for old, untyped, event handlers and don't
2918 // check that the type of the function passed to them actually matches the
2919 // type of the event. They also only allow connecting events to methods of
2920 // wxEvtHandler-derived classes.
2921 //
2922 // The template Connect() methods below are safer and allow connecting
2923 // events to arbitrary functions or functors -- but require compiler
2924 // support for templates.
2925
2926 // Dynamic association of a member function handler with the event handler,
2927 // winid and event type
2928 void Connect(int winid,
2929 int lastId,
2930 wxEventType eventType,
2931 wxObjectEventFunction func,
2932 wxObject *userData = NULL,
2933 wxEvtHandler *eventSink = NULL)
2934 {
2935 DoConnect(winid, lastId, eventType,
2936 wxNewEventFunctor(eventType, func, eventSink),
2937 userData);
2938 }
2939
2940 // Convenience function: take just one id
2941 void Connect(int winid,
2942 wxEventType eventType,
2943 wxObjectEventFunction func,
2944 wxObject *userData = NULL,
2945 wxEvtHandler *eventSink = NULL)
2946 { Connect(winid, wxID_ANY, eventType, func, userData, eventSink); }
2947
2948 // Even more convenient: without id (same as using id of wxID_ANY)
2949 void Connect(wxEventType eventType,
2950 wxObjectEventFunction func,
2951 wxObject *userData = NULL,
2952 wxEvtHandler *eventSink = NULL)
2953 { Connect(wxID_ANY, wxID_ANY, eventType, func, userData, eventSink); }
2954
2955 bool Disconnect(int winid,
2956 int lastId,
2957 wxEventType eventType,
2958 wxObjectEventFunction func = NULL,
2959 wxObject *userData = NULL,
2960 wxEvtHandler *eventSink = NULL)
2961 {
2962 return DoDisconnect(winid, lastId, eventType,
2963 wxMakeEventFunctor(eventType, func, eventSink),
2964 userData );
2965 }
2966
2967 bool Disconnect(int winid = wxID_ANY,
2968 wxEventType eventType = wxEVT_NULL,
2969 wxObjectEventFunction func = NULL,
2970 wxObject *userData = NULL,
2971 wxEvtHandler *eventSink = NULL)
2972 { return Disconnect(winid, wxID_ANY, eventType, func, userData, eventSink); }
2973
2974 bool Disconnect(wxEventType eventType,
2975 wxObjectEventFunction func,
2976 wxObject *userData = NULL,
2977 wxEvtHandler *eventSink = NULL)
2978 { return Disconnect(wxID_ANY, eventType, func, userData, eventSink); }
2979
2980#if !wxEVENTS_COMPATIBILITY_2_8
2981 // Bind arbitrary functor (including just a function) to an event:
2982 template <typename EventTag, typename Functor>
2983 void Bind(const EventTag& eventType,
2984 Functor functor,
2985 int winid = wxID_ANY,
2986 int lastId = wxID_ANY,
2987 wxObject *userData = NULL)
2988 {
2989 DoConnect(winid, lastId, eventType,
2990 wxNewEventFunctor(eventType, functor),
2991 userData);
2992 }
2993
2994
2995 template <typename EventTag, typename Functor>
2996 bool Unbind(const EventTag& eventType,
2997 Functor functor,
2998 int winid = wxID_ANY,
2999 int lastId = wxID_ANY,
3000 wxObject *userData = NULL)
3001 {
3002 return DoDisconnect(winid, lastId, eventType,
3003 wxMakeEventFunctor(eventType, functor),
3004 userData);
3005 }
3006
3007
3008 // Bind a method of a class (called on the specified handler which must
3009 // be convertible to this class) object to an event:
3010
3011 template <typename EventTag, typename Class, typename EventArg, typename EventHandler>
3012 void Bind(const EventTag &eventType,
3013 void (Class::*method)(EventArg &),
3014 EventHandler *handler,
3015 int winid = wxID_ANY,
3016 int lastId = wxID_ANY,
3017 wxObject *userData = NULL)
3018 {
3019 DoConnect(winid, lastId, eventType,
3020 wxNewEventFunctor(eventType, method, handler),
3021 userData);
3022 }
3023
3024 template <typename EventTag, typename Class, typename EventArg, typename EventHandler>
3025 bool Unbind(const EventTag &eventType,
3026 void (Class::*method)(EventArg&),
3027 EventHandler *handler,
3028 int winid = wxID_ANY,
3029 int lastId = wxID_ANY,
3030 wxObject *userData = NULL )
3031 {
3032 return DoDisconnect(winid, lastId, eventType,
3033 wxMakeEventFunctor(eventType, method, handler),
3034 userData);
3035 }
3036#endif // !wxEVENTS_COMPATIBILITY_2_8
3037
3038 wxList* GetDynamicEventTable() const { return m_dynamicEvents ; }
3039
3040 // User data can be associated with each wxEvtHandler
3041 void SetClientObject( wxClientData *data ) { DoSetClientObject(data); }
3042 wxClientData *GetClientObject() const { return DoGetClientObject(); }
3043
3044 void SetClientData( void *data ) { DoSetClientData(data); }
3045 void *GetClientData() const { return DoGetClientData(); }
3046
3047
3048 // implementation from now on
3049 // --------------------------
3050
3051 // check if the given event table entry matches this event by id (the check
3052 // for the event type should be done by caller) and call the handler if it
3053 // does
3054 //
3055 // return true if the event was processed, false otherwise (no match or the
3056 // handler decided to skip the event)
3057 static bool ProcessEventIfMatchesId(const wxEventTableEntryBase& tableEntry,
3058 wxEvtHandler *handler,
3059 wxEvent& event);
3060
3061 virtual bool SearchEventTable(wxEventTable& table, wxEvent& event);
3062 bool SearchDynamicEventTable( wxEvent& event );
3063
3064 // Avoid problems at exit by cleaning up static hash table gracefully
3065 void ClearEventHashTable() { GetEventHashTable().Clear(); }
3066 void OnSinkDestroyed( wxEvtHandler *sink );
3067
3068
3069 // The method tries to process the event in this event handler.
3070 //
3071 // It is meant to be called from ProcessEvent() only and is not virtual,
3072 // additional event handlers can be hooked into the normal event processing
3073 // logic using TryBefore() and TryAfter() hooks.
3074 bool ProcessEventHere(wxEvent& event);
3075
3076
3077private:
3078 void DoConnect(int winid,
3079 int lastId,
3080 wxEventType eventType,
3081 wxEventFunctor *func,
3082 wxObject* userData = NULL);
3083
3084 bool DoDisconnect(int winid,
3085 int lastId,
3086 wxEventType eventType,
3087 const wxEventFunctor& func,
3088 wxObject *userData = NULL);
3089
3090 static const wxEventTableEntry sm_eventTableEntries[];
3091
3092protected:
3093 // hooks for wxWindow used by ProcessEvent()
3094 // -----------------------------------------
3095
3096 // this one is called before trying our own event table to allow plugging
3097 // in the event handlers overriding the default logic, this is used by e.g.
3098 // validators.
3099 virtual bool TryBefore(wxEvent& event);
3100
3101 // this one is called after failing to find the event handle in our own
3102 // table to give a chance to the other windows to process it
3103 //
3104 // base class implementation passes the event to wxTheApp
3105 virtual bool TryAfter(wxEvent& event);
3106
3107#ifdef WXWIN_COMPATIBILITY_2_8
3108 // deprecated method: override TryBefore() instead of this one
3109 wxDEPRECATED_BUT_USED_INTERNALLY_INLINE(
3110 virtual bool TryValidator(wxEvent& WXUNUSED(event)), return false; )
3111
3112 wxDEPRECATED_BUT_USED_INTERNALLY_INLINE(
3113 virtual bool TryParent(wxEvent& event), return DoTryApp(event); )
3114#endif // WXWIN_COMPATIBILITY_2_8
3115
3116
3117 static const wxEventTable sm_eventTable;
3118 virtual const wxEventTable *GetEventTable() const;
3119
3120 static wxEventHashTable sm_eventHashTable;
3121 virtual wxEventHashTable& GetEventHashTable() const;
3122
3123 wxEvtHandler* m_nextHandler;
3124 wxEvtHandler* m_previousHandler;
3125 wxList* m_dynamicEvents;
3126 wxList* m_pendingEvents;
3127
3128#if wxUSE_THREADS
3129 // critical section protecting m_pendingEvents
3130 wxCriticalSection m_pendingEventsLock;
3131#endif // wxUSE_THREADS
3132
3133 // Is event handler enabled?
3134 bool m_enabled;
3135
3136
3137 // The user data: either an object which will be deleted by the container
3138 // when it's deleted or some raw pointer which we do nothing with - only
3139 // one type of data can be used with the given window (i.e. you cannot set
3140 // the void data and then associate the container with wxClientData or vice
3141 // versa)
3142 union
3143 {
3144 wxClientData *m_clientObject;
3145 void *m_clientData;
3146 };
3147
3148 // what kind of data do we have?
3149 wxClientDataType m_clientDataType;
3150
3151 // client data accessors
3152 virtual void DoSetClientObject( wxClientData *data );
3153 virtual wxClientData *DoGetClientObject() const;
3154
3155 virtual void DoSetClientData( void *data );
3156 virtual void *DoGetClientData() const;
3157
3158 // Search tracker objects for event connection with this sink
3159 wxEventConnectionRef *FindRefInTrackerList(wxEvtHandler *handler);
3160
3161private:
3162 // pass the event to wxTheApp instance, called from TryAfter()
3163 bool DoTryApp(wxEvent& event);
3164
3165 DECLARE_DYNAMIC_CLASS_NO_COPY(wxEvtHandler)
3166};
3167
3168WX_DEFINE_ARRAY_WITH_DECL_PTR(wxEvtHandler *, wxEvtHandlerArray, class WXDLLIMPEXP_BASE);
3169
3170// ----------------------------------------------------------------------------
3171// wxEventConnectionRef represents all connections between two event handlers
3172// and enables automatic disconnect when an event handler sink goes out of
3173// scope. Each connection/disconnect increases/decreases ref count, and
3174// when it reaches zero the node goes out of scope.
3175// ----------------------------------------------------------------------------
3176
3177class wxEventConnectionRef : public wxTrackerNode
3178{
3179public:
3180 wxEventConnectionRef() : m_src(NULL), m_sink(NULL), m_refCount(0) { }
3181 wxEventConnectionRef(wxEvtHandler *src, wxEvtHandler *sink)
3182 : m_src(src), m_sink(sink), m_refCount(1)
3183 {
3184 m_sink->AddNode(this);
3185 }
3186
3187 // The sink is being destroyed
3188 virtual void OnObjectDestroy( )
3189 {
3190 if ( m_src )
3191 m_src->OnSinkDestroyed( m_sink );
3192 delete this;
3193 }
3194
3195 virtual wxEventConnectionRef *ToEventConnection() { return this; }
3196
3197 void IncRef() { m_refCount++; }
3198 void DecRef()
3199 {
3200 if ( !--m_refCount )
3201 {
3202 // The sink holds the only external pointer to this object
3203 if ( m_sink )
3204 m_sink->RemoveNode(this);
3205 delete this;
3206 }
3207 }
3208
3209private:
3210 wxEvtHandler *m_src,
3211 *m_sink;
3212 int m_refCount;
3213
3214 friend class wxEvtHandler;
3215
3216 wxDECLARE_NO_ASSIGN_CLASS(wxEventConnectionRef);
3217};
3218
3219inline void wxObjectEventFunctor::operator()(wxEvtHandler *handler, wxEvent& event)
3220{
3221 wxEvtHandler * const realHandler = m_handler ? m_handler : handler;
3222
3223 (realHandler->*m_method)(event);
3224}
3225
3226// Post a message to the given event handler which will be processed during the
3227// next event loop iteration.
3228//
3229// Notice that this one is not thread-safe, use wxQueueEvent()
3230inline void wxPostEvent(wxEvtHandler *dest, const wxEvent& event)
3231{
3232 wxCHECK_RET( dest, "need an object to post event to" );
3233
3234 dest->AddPendingEvent(event);
3235}
3236
3237// Wrapper around wxEvtHandler::QueueEvent(): adds an event for later
3238// processing, unlike wxPostEvent it is safe to use from different thread even
3239// for events with wxString members
3240inline void wxQueueEvent(wxEvtHandler *dest, wxEvent *event)
3241{
3242 wxCHECK_RET( dest, "need an object to queue event for" );
3243
3244 dest->QueueEvent(event);
3245}
3246
3247typedef void (wxEvtHandler::*wxEventFunction)(wxEvent&);
3248typedef void (wxEvtHandler::*wxIdleEventFunction)(wxIdleEvent&);
3249
3250#define wxEventHandler(func) \
3251 wxEVENT_HANDLER_CAST(wxEventFunction, func)
3252#define wxIdleEventHandler(func) \
3253 wxEVENT_HANDLER_CAST(wxIdleEventFunction, func)
3254
3255#if wxUSE_GUI
3256
3257// ----------------------------------------------------------------------------
3258// wxEventBlocker: helper class to temporarily disable event handling for a window
3259// ----------------------------------------------------------------------------
3260
3261class WXDLLIMPEXP_CORE wxEventBlocker : public wxEvtHandler
3262{
3263public:
3264 wxEventBlocker(wxWindow *win, wxEventType type = wxEVT_ANY);
3265 virtual ~wxEventBlocker();
3266
3267 void Block(wxEventType type)
3268 {
3269 m_eventsToBlock.push_back(type);
3270 }
3271
3272 virtual bool ProcessEvent(wxEvent& event);
3273
3274protected:
3275 wxArrayInt m_eventsToBlock;
3276 wxWindow *m_window;
3277
3278 wxDECLARE_NO_COPY_CLASS(wxEventBlocker);
3279};
3280
3281typedef void (wxEvtHandler::*wxCommandEventFunction)(wxCommandEvent&);
3282typedef void (wxEvtHandler::*wxThreadEventFunction)(wxThreadEvent&);
3283typedef void (wxEvtHandler::*wxScrollEventFunction)(wxScrollEvent&);
3284typedef void (wxEvtHandler::*wxScrollWinEventFunction)(wxScrollWinEvent&);
3285typedef void (wxEvtHandler::*wxSizeEventFunction)(wxSizeEvent&);
3286typedef void (wxEvtHandler::*wxMoveEventFunction)(wxMoveEvent&);
3287typedef void (wxEvtHandler::*wxPaintEventFunction)(wxPaintEvent&);
3288typedef void (wxEvtHandler::*wxNcPaintEventFunction)(wxNcPaintEvent&);
3289typedef void (wxEvtHandler::*wxEraseEventFunction)(wxEraseEvent&);
3290typedef void (wxEvtHandler::*wxMouseEventFunction)(wxMouseEvent&);
3291typedef void (wxEvtHandler::*wxCharEventFunction)(wxKeyEvent&);
3292typedef void (wxEvtHandler::*wxFocusEventFunction)(wxFocusEvent&);
3293typedef void (wxEvtHandler::*wxChildFocusEventFunction)(wxChildFocusEvent&);
3294typedef void (wxEvtHandler::*wxActivateEventFunction)(wxActivateEvent&);
3295typedef void (wxEvtHandler::*wxMenuEventFunction)(wxMenuEvent&);
3296typedef void (wxEvtHandler::*wxJoystickEventFunction)(wxJoystickEvent&);
3297typedef void (wxEvtHandler::*wxDropFilesEventFunction)(wxDropFilesEvent&);
3298typedef void (wxEvtHandler::*wxInitDialogEventFunction)(wxInitDialogEvent&);
3299typedef void (wxEvtHandler::*wxSysColourChangedEventFunction)(wxSysColourChangedEvent&);
3300typedef void (wxEvtHandler::*wxDisplayChangedEventFunction)(wxDisplayChangedEvent&);
3301typedef void (wxEvtHandler::*wxUpdateUIEventFunction)(wxUpdateUIEvent&);
3302typedef void (wxEvtHandler::*wxCloseEventFunction)(wxCloseEvent&);
3303typedef void (wxEvtHandler::*wxShowEventFunction)(wxShowEvent&);
3304typedef void (wxEvtHandler::*wxIconizeEventFunction)(wxIconizeEvent&);
3305typedef void (wxEvtHandler::*wxMaximizeEventFunction)(wxMaximizeEvent&);
3306typedef void (wxEvtHandler::*wxNavigationKeyEventFunction)(wxNavigationKeyEvent&);
3307typedef void (wxEvtHandler::*wxPaletteChangedEventFunction)(wxPaletteChangedEvent&);
3308typedef void (wxEvtHandler::*wxQueryNewPaletteEventFunction)(wxQueryNewPaletteEvent&);
3309typedef void (wxEvtHandler::*wxWindowCreateEventFunction)(wxWindowCreateEvent&);
3310typedef void (wxEvtHandler::*wxWindowDestroyEventFunction)(wxWindowDestroyEvent&);
3311typedef void (wxEvtHandler::*wxSetCursorEventFunction)(wxSetCursorEvent&);
3312typedef void (wxEvtHandler::*wxNotifyEventFunction)(wxNotifyEvent&);
3313typedef void (wxEvtHandler::*wxHelpEventFunction)(wxHelpEvent&);
3314typedef void (wxEvtHandler::*wxContextMenuEventFunction)(wxContextMenuEvent&);
3315typedef void (wxEvtHandler::*wxMouseCaptureChangedEventFunction)(wxMouseCaptureChangedEvent&);
3316typedef void (wxEvtHandler::*wxMouseCaptureLostEventFunction)(wxMouseCaptureLostEvent&);
3317typedef void (wxEvtHandler::*wxClipboardTextEventFunction)(wxClipboardTextEvent&);
3318
3319
3320#define wxCommandEventHandler(func) \
3321 wxEVENT_HANDLER_CAST(wxCommandEventFunction, func)
3322#define wxThreadEventHandler(func) \
3323 wxEVENT_HANDLER_CAST(wxThreadEventFunction, func)
3324#define wxScrollEventHandler(func) \
3325 wxEVENT_HANDLER_CAST(wxScrollEventFunction, func)
3326#define wxScrollWinEventHandler(func) \
3327 wxEVENT_HANDLER_CAST(wxScrollWinEventFunction, func)
3328#define wxSizeEventHandler(func) \
3329 wxEVENT_HANDLER_CAST(wxSizeEventFunction, func)
3330#define wxMoveEventHandler(func) \
3331 wxEVENT_HANDLER_CAST(wxMoveEventFunction, func)
3332#define wxPaintEventHandler(func) \
3333 wxEVENT_HANDLER_CAST(wxPaintEventFunction, func)
3334#define wxNcPaintEventHandler(func) \
3335 wxEVENT_HANDLER_CAST(wxNcPaintEventFunction, func)
3336#define wxEraseEventHandler(func) \
3337 wxEVENT_HANDLER_CAST(wxEraseEventFunction, func)
3338#define wxMouseEventHandler(func) \
3339 wxEVENT_HANDLER_CAST(wxMouseEventFunction, func)
3340#define wxCharEventHandler(func) \
3341 wxEVENT_HANDLER_CAST(wxCharEventFunction, func)
3342#define wxKeyEventHandler(func) wxCharEventHandler(func)
3343#define wxFocusEventHandler(func) \
3344 wxEVENT_HANDLER_CAST(wxFocusEventFunction, func)
3345#define wxChildFocusEventHandler(func) \
3346 wxEVENT_HANDLER_CAST(wxChildFocusEventFunction, func)
3347#define wxActivateEventHandler(func) \
3348 wxEVENT_HANDLER_CAST(wxActivateEventFunction, func)
3349#define wxMenuEventHandler(func) \
3350 wxEVENT_HANDLER_CAST(wxMenuEventFunction, func)
3351#define wxJoystickEventHandler(func) \
3352 wxEVENT_HANDLER_CAST(wxJoystickEventFunction, func)
3353#define wxDropFilesEventHandler(func) \
3354 wxEVENT_HANDLER_CAST(wxDropFilesEventFunction, func)
3355#define wxInitDialogEventHandler(func) \
3356 wxEVENT_HANDLER_CAST(wxInitDialogEventFunction, func)
3357#define wxSysColourChangedEventHandler(func) \
3358 wxEVENT_HANDLER_CAST(wxSysColourChangedEventFunction, func)
3359#define wxDisplayChangedEventHandler(func) \
3360 wxEVENT_HANDLER_CAST(wxDisplayChangedEventFunction, func)
3361#define wxUpdateUIEventHandler(func) \
3362 wxEVENT_HANDLER_CAST(wxUpdateUIEventFunction, func)
3363#define wxCloseEventHandler(func) \
3364 wxEVENT_HANDLER_CAST(wxCloseEventFunction, func)
3365#define wxShowEventHandler(func) \
3366 wxEVENT_HANDLER_CAST(wxShowEventFunction, func)
3367#define wxIconizeEventHandler(func) \
3368 wxEVENT_HANDLER_CAST(wxIconizeEventFunction, func)
3369#define wxMaximizeEventHandler(func) \
3370 wxEVENT_HANDLER_CAST(wxMaximizeEventFunction, func)
3371#define wxNavigationKeyEventHandler(func) \
3372 wxEVENT_HANDLER_CAST(wxNavigationKeyEventFunction, func)
3373#define wxPaletteChangedEventHandler(func) \
3374 wxEVENT_HANDLER_CAST(wxPaletteChangedEventFunction, func)
3375#define wxQueryNewPaletteEventHandler(func) \
3376 wxEVENT_HANDLER_CAST(wxQueryNewPaletteEventFunction, func)
3377#define wxWindowCreateEventHandler(func) \
3378 wxEVENT_HANDLER_CAST(wxWindowCreateEventFunction, func)
3379#define wxWindowDestroyEventHandler(func) \
3380 wxEVENT_HANDLER_CAST(wxWindowDestroyEventFunction, func)
3381#define wxSetCursorEventHandler(func) \
3382 wxEVENT_HANDLER_CAST(wxSetCursorEventFunction, func)
3383#define wxNotifyEventHandler(func) \
3384 wxEVENT_HANDLER_CAST(wxNotifyEventFunction, func)
3385#define wxHelpEventHandler(func) \
3386 wxEVENT_HANDLER_CAST(wxHelpEventFunction, func)
3387#define wxContextMenuEventHandler(func) \
3388 wxEVENT_HANDLER_CAST(wxContextMenuEventFunction, func)
3389#define wxMouseCaptureChangedEventHandler(func) \
3390 wxEVENT_HANDLER_CAST(wxMouseCaptureChangedEventFunction, func)
3391#define wxMouseCaptureLostEventHandler(func) \
3392 wxEVENT_HANDLER_CAST(wxMouseCaptureLostEventFunction, func)
3393#define wxClipboardTextEventHandler(func) \
3394 wxEVENT_HANDLER_CAST(wxClipboardTextEventFunction, func)
3395
3396#endif // wxUSE_GUI
3397
3398// N.B. In GNU-WIN32, you *have* to take the address of a member function
3399// (use &) or the compiler crashes...
3400
3401#define DECLARE_EVENT_TABLE() \
3402 private: \
3403 static const wxEventTableEntry sm_eventTableEntries[]; \
3404 protected: \
3405 static const wxEventTable sm_eventTable; \
3406 virtual const wxEventTable* GetEventTable() const; \
3407 static wxEventHashTable sm_eventHashTable; \
3408 virtual wxEventHashTable& GetEventHashTable() const;
3409
3410// N.B.: when building DLL with Borland C++ 5.5 compiler, you must initialize
3411// sm_eventTable before using it in GetEventTable() or the compiler gives
3412// E2233 (see http://groups.google.com/groups?selm=397dcc8a%241_2%40dnews)
3413
3414#define BEGIN_EVENT_TABLE(theClass, baseClass) \
3415 const wxEventTable theClass::sm_eventTable = \
3416 { &baseClass::sm_eventTable, &theClass::sm_eventTableEntries[0] }; \
3417 const wxEventTable *theClass::GetEventTable() const \
3418 { return &theClass::sm_eventTable; } \
3419 wxEventHashTable theClass::sm_eventHashTable(theClass::sm_eventTable); \
3420 wxEventHashTable &theClass::GetEventHashTable() const \
3421 { return theClass::sm_eventHashTable; } \
3422 const wxEventTableEntry theClass::sm_eventTableEntries[] = { \
3423
3424#define BEGIN_EVENT_TABLE_TEMPLATE1(theClass, baseClass, T1) \
3425 template<typename T1> \
3426 const wxEventTable theClass<T1>::sm_eventTable = \
3427 { &baseClass::sm_eventTable, &theClass<T1>::sm_eventTableEntries[0] }; \
3428 template<typename T1> \
3429 const wxEventTable *theClass<T1>::GetEventTable() const \
3430 { return &theClass<T1>::sm_eventTable; } \
3431 template<typename T1> \
3432 wxEventHashTable theClass<T1>::sm_eventHashTable(theClass<T1>::sm_eventTable); \
3433 template<typename T1> \
3434 wxEventHashTable &theClass<T1>::GetEventHashTable() const \
3435 { return theClass<T1>::sm_eventHashTable; } \
3436 template<typename T1> \
3437 const wxEventTableEntry theClass<T1>::sm_eventTableEntries[] = { \
3438
3439#define BEGIN_EVENT_TABLE_TEMPLATE2(theClass, baseClass, T1, T2) \
3440 template<typename T1, typename T2> \
3441 const wxEventTable theClass<T1, T2>::sm_eventTable = \
3442 { &baseClass::sm_eventTable, &theClass<T1, T2>::sm_eventTableEntries[0] }; \
3443 template<typename T1, typename T2> \
3444 const wxEventTable *theClass<T1, T2>::GetEventTable() const \
3445 { return &theClass<T1, T2>::sm_eventTable; } \
3446 template<typename T1, typename T2> \
3447 wxEventHashTable theClass<T1, T2>::sm_eventHashTable(theClass<T1, T2>::sm_eventTable); \
3448 template<typename T1, typename T2> \
3449 wxEventHashTable &theClass<T1, T2>::GetEventHashTable() const \
3450 { return theClass<T1, T2>::sm_eventHashTable; } \
3451 template<typename T1, typename T2> \
3452 const wxEventTableEntry theClass<T1, T2>::sm_eventTableEntries[] = { \
3453
3454#define BEGIN_EVENT_TABLE_TEMPLATE3(theClass, baseClass, T1, T2, T3) \
3455 template<typename T1, typename T2, typename T3> \
3456 const wxEventTable theClass<T1, T2, T3>::sm_eventTable = \
3457 { &baseClass::sm_eventTable, &theClass<T1, T2, T3>::sm_eventTableEntries[0] }; \
3458 template<typename T1, typename T2, typename T3> \
3459 const wxEventTable *theClass<T1, T2, T3>::GetEventTable() const \
3460 { return &theClass<T1, T2, T3>::sm_eventTable; } \
3461 template<typename T1, typename T2, typename T3> \
3462 wxEventHashTable theClass<T1, T2, T3>::sm_eventHashTable(theClass<T1, T2, T3>::sm_eventTable); \
3463 template<typename T1, typename T2, typename T3> \
3464 wxEventHashTable &theClass<T1, T2, T3>::GetEventHashTable() const \
3465 { return theClass<T1, T2, T3>::sm_eventHashTable; } \
3466 template<typename T1, typename T2, typename T3> \
3467 const wxEventTableEntry theClass<T1, T2, T3>::sm_eventTableEntries[] = { \
3468
3469#define BEGIN_EVENT_TABLE_TEMPLATE4(theClass, baseClass, T1, T2, T3, T4) \
3470 template<typename T1, typename T2, typename T3, typename T4> \
3471 const wxEventTable theClass<T1, T2, T3, T4>::sm_eventTable = \
3472 { &baseClass::sm_eventTable, &theClass<T1, T2, T3, T4>::sm_eventTableEntries[0] }; \
3473 template<typename T1, typename T2, typename T3, typename T4> \
3474 const wxEventTable *theClass<T1, T2, T3, T4>::GetEventTable() const \
3475 { return &theClass<T1, T2, T3, T4>::sm_eventTable; } \
3476 template<typename T1, typename T2, typename T3, typename T4> \
3477 wxEventHashTable theClass<T1, T2, T3, T4>::sm_eventHashTable(theClass<T1, T2, T3, T4>::sm_eventTable); \
3478 template<typename T1, typename T2, typename T3, typename T4> \
3479 wxEventHashTable &theClass<T1, T2, T3, T4>::GetEventHashTable() const \
3480 { return theClass<T1, T2, T3, T4>::sm_eventHashTable; } \
3481 template<typename T1, typename T2, typename T3, typename T4> \
3482 const wxEventTableEntry theClass<T1, T2, T3, T4>::sm_eventTableEntries[] = { \
3483
3484#define BEGIN_EVENT_TABLE_TEMPLATE5(theClass, baseClass, T1, T2, T3, T4, T5) \
3485 template<typename T1, typename T2, typename T3, typename T4, typename T5> \
3486 const wxEventTable theClass<T1, T2, T3, T4, T5>::sm_eventTable = \
3487 { &baseClass::sm_eventTable, &theClass<T1, T2, T3, T4, T5>::sm_eventTableEntries[0] }; \
3488 template<typename T1, typename T2, typename T3, typename T4, typename T5> \
3489 const wxEventTable *theClass<T1, T2, T3, T4, T5>::GetEventTable() const \
3490 { return &theClass<T1, T2, T3, T4, T5>::sm_eventTable; } \
3491 template<typename T1, typename T2, typename T3, typename T4, typename T5> \
3492 wxEventHashTable theClass<T1, T2, T3, T4, T5>::sm_eventHashTable(theClass<T1, T2, T3, T4, T5>::sm_eventTable); \
3493 template<typename T1, typename T2, typename T3, typename T4, typename T5> \
3494 wxEventHashTable &theClass<T1, T2, T3, T4, T5>::GetEventHashTable() const \
3495 { return theClass<T1, T2, T3, T4, T5>::sm_eventHashTable; } \
3496 template<typename T1, typename T2, typename T3, typename T4, typename T5> \
3497 const wxEventTableEntry theClass<T1, T2, T3, T4, T5>::sm_eventTableEntries[] = { \
3498
3499#define BEGIN_EVENT_TABLE_TEMPLATE7(theClass, baseClass, T1, T2, T3, T4, T5, T6, T7) \
3500 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7> \
3501 const wxEventTable theClass<T1, T2, T3, T4, T5, T6, T7>::sm_eventTable = \
3502 { &baseClass::sm_eventTable, &theClass<T1, T2, T3, T4, T5, T6, T7>::sm_eventTableEntries[0] }; \
3503 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7> \
3504 const wxEventTable *theClass<T1, T2, T3, T4, T5, T6, T7>::GetEventTable() const \
3505 { return &theClass<T1, T2, T3, T4, T5, T6, T7>::sm_eventTable; } \
3506 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7> \
3507 wxEventHashTable theClass<T1, T2, T3, T4, T5, T6, T7>::sm_eventHashTable(theClass<T1, T2, T3, T4, T5, T6, T7>::sm_eventTable); \
3508 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7> \
3509 wxEventHashTable &theClass<T1, T2, T3, T4, T5, T6, T7>::GetEventHashTable() const \
3510 { return theClass<T1, T2, T3, T4, T5, T6, T7>::sm_eventHashTable; } \
3511 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7> \
3512 const wxEventTableEntry theClass<T1, T2, T3, T4, T5, T6, T7>::sm_eventTableEntries[] = { \
3513
3514#define BEGIN_EVENT_TABLE_TEMPLATE8(theClass, baseClass, T1, T2, T3, T4, T5, T6, T7, T8) \
3515 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8> \
3516 const wxEventTable theClass<T1, T2, T3, T4, T5, T6, T7, T8>::sm_eventTable = \
3517 { &baseClass::sm_eventTable, &theClass<T1, T2, T3, T4, T5, T6, T7, T8>::sm_eventTableEntries[0] }; \
3518 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8> \
3519 const wxEventTable *theClass<T1, T2, T3, T4, T5, T6, T7, T8>::GetEventTable() const \
3520 { return &theClass<T1, T2, T3, T4, T5, T6, T7, T8>::sm_eventTable; } \
3521 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8> \
3522 wxEventHashTable theClass<T1, T2, T3, T4, T5, T6, T7, T8>::sm_eventHashTable(theClass<T1, T2, T3, T4, T5, T6, T7, T8>::sm_eventTable); \
3523 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8> \
3524 wxEventHashTable &theClass<T1, T2, T3, T4, T5, T6, T7, T8>::GetEventHashTable() const \
3525 { return theClass<T1, T2, T3, T4, T5, T6, T7, T8>::sm_eventHashTable; } \
3526 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8> \
3527 const wxEventTableEntry theClass<T1, T2, T3, T4, T5, T6, T7, T8>::sm_eventTableEntries[] = { \
3528
3529#define END_EVENT_TABLE() DECLARE_EVENT_TABLE_TERMINATOR() };
3530
3531/*
3532 * Event table macros
3533 */
3534
3535// helpers for writing shorter code below: declare an event macro taking 2, 1
3536// or none ids (the missing ids default to wxID_ANY)
3537//
3538// macro arguments:
3539// - evt one of wxEVT_XXX constants
3540// - id1, id2 ids of the first/last id
3541// - fn the function (should be cast to the right type)
3542#define wx__DECLARE_EVT2(evt, id1, id2, fn) \
3543 DECLARE_EVENT_TABLE_ENTRY(evt, id1, id2, fn, NULL),
3544#define wx__DECLARE_EVT1(evt, id, fn) \
3545 wx__DECLARE_EVT2(evt, id, wxID_ANY, fn)
3546#define wx__DECLARE_EVT0(evt, fn) \
3547 wx__DECLARE_EVT1(evt, wxID_ANY, fn)
3548
3549
3550// Generic events
3551#define EVT_CUSTOM(event, winid, func) \
3552 wx__DECLARE_EVT1(event, winid, wxEventHandler(func))
3553#define EVT_CUSTOM_RANGE(event, id1, id2, func) \
3554 wx__DECLARE_EVT2(event, id1, id2, wxEventHandler(func))
3555
3556// EVT_COMMAND
3557#define EVT_COMMAND(winid, event, func) \
3558 wx__DECLARE_EVT1(event, winid, wxCommandEventHandler(func))
3559
3560#define EVT_COMMAND_RANGE(id1, id2, event, func) \
3561 wx__DECLARE_EVT2(event, id1, id2, wxCommandEventHandler(func))
3562
3563#define EVT_NOTIFY(event, winid, func) \
3564 wx__DECLARE_EVT1(event, winid, wxNotifyEventHandler(func))
3565
3566#define EVT_NOTIFY_RANGE(event, id1, id2, func) \
3567 wx__DECLARE_EVT2(event, id1, id2, wxNotifyEventHandler(func))
3568
3569// Miscellaneous
3570#define EVT_SIZE(func) wx__DECLARE_EVT0(wxEVT_SIZE, wxSizeEventHandler(func))
3571#define EVT_SIZING(func) wx__DECLARE_EVT0(wxEVT_SIZING, wxSizeEventHandler(func))
3572#define EVT_MOVE(func) wx__DECLARE_EVT0(wxEVT_MOVE, wxMoveEventHandler(func))
3573#define EVT_MOVING(func) wx__DECLARE_EVT0(wxEVT_MOVING, wxMoveEventHandler(func))
3574#define EVT_MOVE_START(func) wx__DECLARE_EVT0(wxEVT_MOVE_START, wxMoveEventHandler(func))
3575#define EVT_MOVE_END(func) wx__DECLARE_EVT0(wxEVT_MOVE_END, wxMoveEventHandler(func))
3576#define EVT_CLOSE(func) wx__DECLARE_EVT0(wxEVT_CLOSE_WINDOW, wxCloseEventHandler(func))
3577#define EVT_END_SESSION(func) wx__DECLARE_EVT0(wxEVT_END_SESSION, wxCloseEventHandler(func))
3578#define EVT_QUERY_END_SESSION(func) wx__DECLARE_EVT0(wxEVT_QUERY_END_SESSION, wxCloseEventHandler(func))
3579#define EVT_PAINT(func) wx__DECLARE_EVT0(wxEVT_PAINT, wxPaintEventHandler(func))
3580#define EVT_NC_PAINT(func) wx__DECLARE_EVT0(wxEVT_NC_PAINT, wxNcPaintEventHandler(func))
3581#define EVT_ERASE_BACKGROUND(func) wx__DECLARE_EVT0(wxEVT_ERASE_BACKGROUND, wxEraseEventHandler(func))
3582#define EVT_CHAR(func) wx__DECLARE_EVT0(wxEVT_CHAR, wxCharEventHandler(func))
3583#define EVT_KEY_DOWN(func) wx__DECLARE_EVT0(wxEVT_KEY_DOWN, wxKeyEventHandler(func))
3584#define EVT_KEY_UP(func) wx__DECLARE_EVT0(wxEVT_KEY_UP, wxKeyEventHandler(func))
3585#if wxUSE_HOTKEY
3586#define EVT_HOTKEY(winid, func) wx__DECLARE_EVT1(wxEVT_HOTKEY, winid, wxCharEventHandler(func))
3587#endif
3588#define EVT_CHAR_HOOK(func) wx__DECLARE_EVT0(wxEVT_CHAR_HOOK, wxCharEventHandler(func))
3589#define EVT_MENU_OPEN(func) wx__DECLARE_EVT0(wxEVT_MENU_OPEN, wxMenuEventHandler(func))
3590#define EVT_MENU_CLOSE(func) wx__DECLARE_EVT0(wxEVT_MENU_CLOSE, wxMenuEventHandler(func))
3591#define EVT_MENU_HIGHLIGHT(winid, func) wx__DECLARE_EVT1(wxEVT_MENU_HIGHLIGHT, winid, wxMenuEventHandler(func))
3592#define EVT_MENU_HIGHLIGHT_ALL(func) wx__DECLARE_EVT0(wxEVT_MENU_HIGHLIGHT, wxMenuEventHandler(func))
3593#define EVT_SET_FOCUS(func) wx__DECLARE_EVT0(wxEVT_SET_FOCUS, wxFocusEventHandler(func))
3594#define EVT_KILL_FOCUS(func) wx__DECLARE_EVT0(wxEVT_KILL_FOCUS, wxFocusEventHandler(func))
3595#define EVT_CHILD_FOCUS(func) wx__DECLARE_EVT0(wxEVT_CHILD_FOCUS, wxChildFocusEventHandler(func))
3596#define EVT_ACTIVATE(func) wx__DECLARE_EVT0(wxEVT_ACTIVATE, wxActivateEventHandler(func))
3597#define EVT_ACTIVATE_APP(func) wx__DECLARE_EVT0(wxEVT_ACTIVATE_APP, wxActivateEventHandler(func))
3598#define EVT_HIBERNATE(func) wx__DECLARE_EVT0(wxEVT_HIBERNATE, wxActivateEventHandler(func))
3599#define EVT_END_SESSION(func) wx__DECLARE_EVT0(wxEVT_END_SESSION, wxCloseEventHandler(func))
3600#define EVT_QUERY_END_SESSION(func) wx__DECLARE_EVT0(wxEVT_QUERY_END_SESSION, wxCloseEventHandler(func))
3601#define EVT_DROP_FILES(func) wx__DECLARE_EVT0(wxEVT_DROP_FILES, wxDropFilesEventHandler(func))
3602#define EVT_INIT_DIALOG(func) wx__DECLARE_EVT0(wxEVT_INIT_DIALOG, wxInitDialogEventHandler(func))
3603#define EVT_SYS_COLOUR_CHANGED(func) wx__DECLARE_EVT0(wxEVT_SYS_COLOUR_CHANGED, wxSysColourChangedEventHandler(func))
3604#define EVT_DISPLAY_CHANGED(func) wx__DECLARE_EVT0(wxEVT_DISPLAY_CHANGED, wxDisplayChangedEventHandler(func))
3605#define EVT_SHOW(func) wx__DECLARE_EVT0(wxEVT_SHOW, wxShowEventHandler(func))
3606#define EVT_MAXIMIZE(func) wx__DECLARE_EVT0(wxEVT_MAXIMIZE, wxMaximizeEventHandler(func))
3607#define EVT_ICONIZE(func) wx__DECLARE_EVT0(wxEVT_ICONIZE, wxIconizeEventHandler(func))
3608#define EVT_NAVIGATION_KEY(func) wx__DECLARE_EVT0(wxEVT_NAVIGATION_KEY, wxNavigationKeyEventHandler(func))
3609#define EVT_PALETTE_CHANGED(func) wx__DECLARE_EVT0(wxEVT_PALETTE_CHANGED, wxPaletteChangedEventHandler(func))
3610#define EVT_QUERY_NEW_PALETTE(func) wx__DECLARE_EVT0(wxEVT_QUERY_NEW_PALETTE, wxQueryNewPaletteEventHandler(func))
3611#define EVT_WINDOW_CREATE(func) wx__DECLARE_EVT0(wxEVT_CREATE, wxWindowCreateEventHandler(func))
3612#define EVT_WINDOW_DESTROY(func) wx__DECLARE_EVT0(wxEVT_DESTROY, wxWindowDestroyEventHandler(func))
3613#define EVT_SET_CURSOR(func) wx__DECLARE_EVT0(wxEVT_SET_CURSOR, wxSetCursorEventHandler(func))
3614#define EVT_MOUSE_CAPTURE_CHANGED(func) wx__DECLARE_EVT0(wxEVT_MOUSE_CAPTURE_CHANGED, wxMouseCaptureChangedEventHandler(func))
3615#define EVT_MOUSE_CAPTURE_LOST(func) wx__DECLARE_EVT0(wxEVT_MOUSE_CAPTURE_LOST, wxMouseCaptureLostEventHandler(func))
3616
3617// Mouse events
3618#define EVT_LEFT_DOWN(func) wx__DECLARE_EVT0(wxEVT_LEFT_DOWN, wxMouseEventHandler(func))
3619#define EVT_LEFT_UP(func) wx__DECLARE_EVT0(wxEVT_LEFT_UP, wxMouseEventHandler(func))
3620#define EVT_MIDDLE_DOWN(func) wx__DECLARE_EVT0(wxEVT_MIDDLE_DOWN, wxMouseEventHandler(func))
3621#define EVT_MIDDLE_UP(func) wx__DECLARE_EVT0(wxEVT_MIDDLE_UP, wxMouseEventHandler(func))
3622#define EVT_RIGHT_DOWN(func) wx__DECLARE_EVT0(wxEVT_RIGHT_DOWN, wxMouseEventHandler(func))
3623#define EVT_RIGHT_UP(func) wx__DECLARE_EVT0(wxEVT_RIGHT_UP, wxMouseEventHandler(func))
3624#define EVT_MOTION(func) wx__DECLARE_EVT0(wxEVT_MOTION, wxMouseEventHandler(func))
3625#define EVT_LEFT_DCLICK(func) wx__DECLARE_EVT0(wxEVT_LEFT_DCLICK, wxMouseEventHandler(func))
3626#define EVT_MIDDLE_DCLICK(func) wx__DECLARE_EVT0(wxEVT_MIDDLE_DCLICK, wxMouseEventHandler(func))
3627#define EVT_RIGHT_DCLICK(func) wx__DECLARE_EVT0(wxEVT_RIGHT_DCLICK, wxMouseEventHandler(func))
3628#define EVT_LEAVE_WINDOW(func) wx__DECLARE_EVT0(wxEVT_LEAVE_WINDOW, wxMouseEventHandler(func))
3629#define EVT_ENTER_WINDOW(func) wx__DECLARE_EVT0(wxEVT_ENTER_WINDOW, wxMouseEventHandler(func))
3630#define EVT_MOUSEWHEEL(func) wx__DECLARE_EVT0(wxEVT_MOUSEWHEEL, wxMouseEventHandler(func))
3631#define EVT_MOUSE_AUX1_DOWN(func) wx__DECLARE_EVT0(wxEVT_AUX1_DOWN, wxMouseEventHandler(func))
3632#define EVT_MOUSE_AUX1_UP(func) wx__DECLARE_EVT0(wxEVT_AUX1_UP, wxMouseEventHandler(func))
3633#define EVT_MOUSE_AUX1_DCLICK(func) wx__DECLARE_EVT0(wxEVT_AUX1_DCLICK, wxMouseEventHandler(func))
3634#define EVT_MOUSE_AUX2_DOWN(func) wx__DECLARE_EVT0(wxEVT_AUX2_DOWN, wxMouseEventHandler(func))
3635#define EVT_MOUSE_AUX2_UP(func) wx__DECLARE_EVT0(wxEVT_AUX2_UP, wxMouseEventHandler(func))
3636#define EVT_MOUSE_AUX2_DCLICK(func) wx__DECLARE_EVT0(wxEVT_AUX2_DCLICK, wxMouseEventHandler(func))
3637
3638// All mouse events
3639#define EVT_MOUSE_EVENTS(func) \
3640 EVT_LEFT_DOWN(func) \
3641 EVT_LEFT_UP(func) \
3642 EVT_LEFT_DCLICK(func) \
3643 EVT_MIDDLE_DOWN(func) \
3644 EVT_MIDDLE_UP(func) \
3645 EVT_MIDDLE_DCLICK(func) \
3646 EVT_RIGHT_DOWN(func) \
3647 EVT_RIGHT_UP(func) \
3648 EVT_RIGHT_DCLICK(func) \
3649 EVT_MOUSE_AUX1_DOWN(func) \
3650 EVT_MOUSE_AUX1_UP(func) \
3651 EVT_MOUSE_AUX1_DCLICK(func) \
3652 EVT_MOUSE_AUX2_DOWN(func) \
3653 EVT_MOUSE_AUX2_UP(func) \
3654 EVT_MOUSE_AUX2_DCLICK(func) \
3655 EVT_MOTION(func) \
3656 EVT_LEAVE_WINDOW(func) \
3657 EVT_ENTER_WINDOW(func) \
3658 EVT_MOUSEWHEEL(func)
3659
3660// Scrolling from wxWindow (sent to wxScrolledWindow)
3661#define EVT_SCROLLWIN_TOP(func) wx__DECLARE_EVT0(wxEVT_SCROLLWIN_TOP, wxScrollWinEventHandler(func))
3662#define EVT_SCROLLWIN_BOTTOM(func) wx__DECLARE_EVT0(wxEVT_SCROLLWIN_BOTTOM, wxScrollWinEventHandler(func))
3663#define EVT_SCROLLWIN_LINEUP(func) wx__DECLARE_EVT0(wxEVT_SCROLLWIN_LINEUP, wxScrollWinEventHandler(func))
3664#define EVT_SCROLLWIN_LINEDOWN(func) wx__DECLARE_EVT0(wxEVT_SCROLLWIN_LINEDOWN, wxScrollWinEventHandler(func))
3665#define EVT_SCROLLWIN_PAGEUP(func) wx__DECLARE_EVT0(wxEVT_SCROLLWIN_PAGEUP, wxScrollWinEventHandler(func))
3666#define EVT_SCROLLWIN_PAGEDOWN(func) wx__DECLARE_EVT0(wxEVT_SCROLLWIN_PAGEDOWN, wxScrollWinEventHandler(func))
3667#define EVT_SCROLLWIN_THUMBTRACK(func) wx__DECLARE_EVT0(wxEVT_SCROLLWIN_THUMBTRACK, wxScrollWinEventHandler(func))
3668#define EVT_SCROLLWIN_THUMBRELEASE(func) wx__DECLARE_EVT0(wxEVT_SCROLLWIN_THUMBRELEASE, wxScrollWinEventHandler(func))
3669
3670#define EVT_SCROLLWIN(func) \
3671 EVT_SCROLLWIN_TOP(func) \
3672 EVT_SCROLLWIN_BOTTOM(func) \
3673 EVT_SCROLLWIN_LINEUP(func) \
3674 EVT_SCROLLWIN_LINEDOWN(func) \
3675 EVT_SCROLLWIN_PAGEUP(func) \
3676 EVT_SCROLLWIN_PAGEDOWN(func) \
3677 EVT_SCROLLWIN_THUMBTRACK(func) \
3678 EVT_SCROLLWIN_THUMBRELEASE(func)
3679
3680// Scrolling from wxSlider and wxScrollBar
3681#define EVT_SCROLL_TOP(func) wx__DECLARE_EVT0(wxEVT_SCROLL_TOP, wxScrollEventHandler(func))
3682#define EVT_SCROLL_BOTTOM(func) wx__DECLARE_EVT0(wxEVT_SCROLL_BOTTOM, wxScrollEventHandler(func))
3683#define EVT_SCROLL_LINEUP(func) wx__DECLARE_EVT0(wxEVT_SCROLL_LINEUP, wxScrollEventHandler(func))
3684#define EVT_SCROLL_LINEDOWN(func) wx__DECLARE_EVT0(wxEVT_SCROLL_LINEDOWN, wxScrollEventHandler(func))
3685#define EVT_SCROLL_PAGEUP(func) wx__DECLARE_EVT0(wxEVT_SCROLL_PAGEUP, wxScrollEventHandler(func))
3686#define EVT_SCROLL_PAGEDOWN(func) wx__DECLARE_EVT0(wxEVT_SCROLL_PAGEDOWN, wxScrollEventHandler(func))
3687#define EVT_SCROLL_THUMBTRACK(func) wx__DECLARE_EVT0(wxEVT_SCROLL_THUMBTRACK, wxScrollEventHandler(func))
3688#define EVT_SCROLL_THUMBRELEASE(func) wx__DECLARE_EVT0(wxEVT_SCROLL_THUMBRELEASE, wxScrollEventHandler(func))
3689#define EVT_SCROLL_CHANGED(func) wx__DECLARE_EVT0(wxEVT_SCROLL_CHANGED, wxScrollEventHandler(func))
3690
3691#define EVT_SCROLL(func) \
3692 EVT_SCROLL_TOP(func) \
3693 EVT_SCROLL_BOTTOM(func) \
3694 EVT_SCROLL_LINEUP(func) \
3695 EVT_SCROLL_LINEDOWN(func) \
3696 EVT_SCROLL_PAGEUP(func) \
3697 EVT_SCROLL_PAGEDOWN(func) \
3698 EVT_SCROLL_THUMBTRACK(func) \
3699 EVT_SCROLL_THUMBRELEASE(func) \
3700 EVT_SCROLL_CHANGED(func)
3701
3702// Scrolling from wxSlider and wxScrollBar, with an id
3703#define EVT_COMMAND_SCROLL_TOP(winid, func) wx__DECLARE_EVT1(wxEVT_SCROLL_TOP, winid, wxScrollEventHandler(func))
3704#define EVT_COMMAND_SCROLL_BOTTOM(winid, func) wx__DECLARE_EVT1(wxEVT_SCROLL_BOTTOM, winid, wxScrollEventHandler(func))
3705#define EVT_COMMAND_SCROLL_LINEUP(winid, func) wx__DECLARE_EVT1(wxEVT_SCROLL_LINEUP, winid, wxScrollEventHandler(func))
3706#define EVT_COMMAND_SCROLL_LINEDOWN(winid, func) wx__DECLARE_EVT1(wxEVT_SCROLL_LINEDOWN, winid, wxScrollEventHandler(func))
3707#define EVT_COMMAND_SCROLL_PAGEUP(winid, func) wx__DECLARE_EVT1(wxEVT_SCROLL_PAGEUP, winid, wxScrollEventHandler(func))
3708#define EVT_COMMAND_SCROLL_PAGEDOWN(winid, func) wx__DECLARE_EVT1(wxEVT_SCROLL_PAGEDOWN, winid, wxScrollEventHandler(func))
3709#define EVT_COMMAND_SCROLL_THUMBTRACK(winid, func) wx__DECLARE_EVT1(wxEVT_SCROLL_THUMBTRACK, winid, wxScrollEventHandler(func))
3710#define EVT_COMMAND_SCROLL_THUMBRELEASE(winid, func) wx__DECLARE_EVT1(wxEVT_SCROLL_THUMBRELEASE, winid, wxScrollEventHandler(func))
3711#define EVT_COMMAND_SCROLL_CHANGED(winid, func) wx__DECLARE_EVT1(wxEVT_SCROLL_CHANGED, winid, wxScrollEventHandler(func))
3712
3713#define EVT_COMMAND_SCROLL(winid, func) \
3714 EVT_COMMAND_SCROLL_TOP(winid, func) \
3715 EVT_COMMAND_SCROLL_BOTTOM(winid, func) \
3716 EVT_COMMAND_SCROLL_LINEUP(winid, func) \
3717 EVT_COMMAND_SCROLL_LINEDOWN(winid, func) \
3718 EVT_COMMAND_SCROLL_PAGEUP(winid, func) \
3719 EVT_COMMAND_SCROLL_PAGEDOWN(winid, func) \
3720 EVT_COMMAND_SCROLL_THUMBTRACK(winid, func) \
3721 EVT_COMMAND_SCROLL_THUMBRELEASE(winid, func) \
3722 EVT_COMMAND_SCROLL_CHANGED(winid, func)
3723
3724#if WXWIN_COMPATIBILITY_2_6
3725 // compatibility macros for the old name, deprecated in 2.8
3726 #define wxEVT_SCROLL_ENDSCROLL wxEVT_SCROLL_CHANGED
3727 #define EVT_COMMAND_SCROLL_ENDSCROLL EVT_COMMAND_SCROLL_CHANGED
3728 #define EVT_SCROLL_ENDSCROLL EVT_SCROLL_CHANGED
3729#endif // WXWIN_COMPATIBILITY_2_6
3730
3731// Convenience macros for commonly-used commands
3732#define EVT_CHECKBOX(winid, func) wx__DECLARE_EVT1(wxEVT_COMMAND_CHECKBOX_CLICKED, winid, wxCommandEventHandler(func))
3733#define EVT_CHOICE(winid, func) wx__DECLARE_EVT1(wxEVT_COMMAND_CHOICE_SELECTED, winid, wxCommandEventHandler(func))
3734#define EVT_LISTBOX(winid, func) wx__DECLARE_EVT1(wxEVT_COMMAND_LISTBOX_SELECTED, winid, wxCommandEventHandler(func))
3735#define EVT_LISTBOX_DCLICK(winid, func) wx__DECLARE_EVT1(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED, winid, wxCommandEventHandler(func))
3736#define EVT_MENU(winid, func) wx__DECLARE_EVT1(wxEVT_COMMAND_MENU_SELECTED, winid, wxCommandEventHandler(func))
3737#define EVT_MENU_RANGE(id1, id2, func) wx__DECLARE_EVT2(wxEVT_COMMAND_MENU_SELECTED, id1, id2, wxCommandEventHandler(func))
3738#if defined(__SMARTPHONE__)
3739# define EVT_BUTTON(winid, func) EVT_MENU(winid, func)
3740#else
3741# define EVT_BUTTON(winid, func) wx__DECLARE_EVT1(wxEVT_COMMAND_BUTTON_CLICKED, winid, wxCommandEventHandler(func))
3742#endif
3743#define EVT_SLIDER(winid, func) wx__DECLARE_EVT1(wxEVT_COMMAND_SLIDER_UPDATED, winid, wxCommandEventHandler(func))
3744#define EVT_RADIOBOX(winid, func) wx__DECLARE_EVT1(wxEVT_COMMAND_RADIOBOX_SELECTED, winid, wxCommandEventHandler(func))
3745#define EVT_RADIOBUTTON(winid, func) wx__DECLARE_EVT1(wxEVT_COMMAND_RADIOBUTTON_SELECTED, winid, wxCommandEventHandler(func))
3746// EVT_SCROLLBAR is now obsolete since we use EVT_COMMAND_SCROLL... events
3747#define EVT_SCROLLBAR(winid, func) wx__DECLARE_EVT1(wxEVT_COMMAND_SCROLLBAR_UPDATED, winid, wxCommandEventHandler(func))
3748#define EVT_VLBOX(winid, func) wx__DECLARE_EVT1(wxEVT_COMMAND_VLBOX_SELECTED, winid, wxCommandEventHandler(func))
3749#define EVT_COMBOBOX(winid, func) wx__DECLARE_EVT1(wxEVT_COMMAND_COMBOBOX_SELECTED, winid, wxCommandEventHandler(func))
3750#define EVT_TOOL(winid, func) wx__DECLARE_EVT1(wxEVT_COMMAND_TOOL_CLICKED, winid, wxCommandEventHandler(func))
3751#define EVT_TOOL_DROPDOWN(winid, func) wx__DECLARE_EVT1(wxEVT_COMMAND_TOOL_DROPDOWN_CLICKED, winid, wxCommandEventHandler(func))
3752#define EVT_TOOL_RANGE(id1, id2, func) wx__DECLARE_EVT2(wxEVT_COMMAND_TOOL_CLICKED, id1, id2, wxCommandEventHandler(func))
3753#define EVT_TOOL_RCLICKED(winid, func) wx__DECLARE_EVT1(wxEVT_COMMAND_TOOL_RCLICKED, winid, wxCommandEventHandler(func))
3754#define EVT_TOOL_RCLICKED_RANGE(id1, id2, func) wx__DECLARE_EVT2(wxEVT_COMMAND_TOOL_RCLICKED, id1, id2, wxCommandEventHandler(func))
3755#define EVT_TOOL_ENTER(winid, func) wx__DECLARE_EVT1(wxEVT_COMMAND_TOOL_ENTER, winid, wxCommandEventHandler(func))
3756#define EVT_CHECKLISTBOX(winid, func) wx__DECLARE_EVT1(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED, winid, wxCommandEventHandler(func))
3757#define EVT_COMBOBOX_DROPDOWN(winid, func) wx__DECLARE_EVT1(wxEVT_COMMAND_COMBOBOX_DROPDOWN, winid, wxCommandEventHandler(func))
3758#define EVT_COMBOBOX_CLOSEUP(winid, func) wx__DECLARE_EVT1(wxEVT_COMMAND_COMBOBOX_CLOSEUP, winid, wxCommandEventHandler(func))
3759
3760// Generic command events
3761#define EVT_COMMAND_LEFT_CLICK(winid, func) wx__DECLARE_EVT1(wxEVT_COMMAND_LEFT_CLICK, winid, wxCommandEventHandler(func))
3762#define EVT_COMMAND_LEFT_DCLICK(winid, func) wx__DECLARE_EVT1(wxEVT_COMMAND_LEFT_DCLICK, winid, wxCommandEventHandler(func))
3763#define EVT_COMMAND_RIGHT_CLICK(winid, func) wx__DECLARE_EVT1(wxEVT_COMMAND_RIGHT_CLICK, winid, wxCommandEventHandler(func))
3764#define EVT_COMMAND_RIGHT_DCLICK(winid, func) wx__DECLARE_EVT1(wxEVT_COMMAND_RIGHT_DCLICK, winid, wxCommandEventHandler(func))
3765#define EVT_COMMAND_SET_FOCUS(winid, func) wx__DECLARE_EVT1(wxEVT_COMMAND_SET_FOCUS, winid, wxCommandEventHandler(func))
3766#define EVT_COMMAND_KILL_FOCUS(winid, func) wx__DECLARE_EVT1(wxEVT_COMMAND_KILL_FOCUS, winid, wxCommandEventHandler(func))
3767#define EVT_COMMAND_ENTER(winid, func) wx__DECLARE_EVT1(wxEVT_COMMAND_ENTER, winid, wxCommandEventHandler(func))
3768
3769// Joystick events
3770
3771#define EVT_JOY_BUTTON_DOWN(func) wx__DECLARE_EVT0(wxEVT_JOY_BUTTON_DOWN, wxJoystickEventHandler(func))
3772#define EVT_JOY_BUTTON_UP(func) wx__DECLARE_EVT0(wxEVT_JOY_BUTTON_UP, wxJoystickEventHandler(func))
3773#define EVT_JOY_MOVE(func) wx__DECLARE_EVT0(wxEVT_JOY_MOVE, wxJoystickEventHandler(func))
3774#define EVT_JOY_ZMOVE(func) wx__DECLARE_EVT0(wxEVT_JOY_ZMOVE, wxJoystickEventHandler(func))
3775
3776// All joystick events
3777#define EVT_JOYSTICK_EVENTS(func) \
3778 EVT_JOY_BUTTON_DOWN(func) \
3779 EVT_JOY_BUTTON_UP(func) \
3780 EVT_JOY_MOVE(func) \
3781 EVT_JOY_ZMOVE(func)
3782
3783// Idle event
3784#define EVT_IDLE(func) wx__DECLARE_EVT0(wxEVT_IDLE, wxIdleEventHandler(func))
3785
3786// Update UI event
3787#define EVT_UPDATE_UI(winid, func) wx__DECLARE_EVT1(wxEVT_UPDATE_UI, winid, wxUpdateUIEventHandler(func))
3788#define EVT_UPDATE_UI_RANGE(id1, id2, func) wx__DECLARE_EVT2(wxEVT_UPDATE_UI, id1, id2, wxUpdateUIEventHandler(func))
3789
3790// Help events
3791#define EVT_HELP(winid, func) wx__DECLARE_EVT1(wxEVT_HELP, winid, wxHelpEventHandler(func))
3792#define EVT_HELP_RANGE(id1, id2, func) wx__DECLARE_EVT2(wxEVT_HELP, id1, id2, wxHelpEventHandler(func))
3793#define EVT_DETAILED_HELP(winid, func) wx__DECLARE_EVT1(wxEVT_DETAILED_HELP, winid, wxHelpEventHandler(func))
3794#define EVT_DETAILED_HELP_RANGE(id1, id2, func) wx__DECLARE_EVT2(wxEVT_DETAILED_HELP, id1, id2, wxHelpEventHandler(func))
3795
3796// Context Menu Events
3797#define EVT_CONTEXT_MENU(func) wx__DECLARE_EVT0(wxEVT_CONTEXT_MENU, wxContextMenuEventHandler(func))
3798#define EVT_COMMAND_CONTEXT_MENU(winid, func) wx__DECLARE_EVT1(wxEVT_CONTEXT_MENU, winid, wxContextMenuEventHandler(func))
3799
3800// Clipboard text Events
3801#define EVT_TEXT_CUT(winid, func) wx__DECLARE_EVT1(wxEVT_COMMAND_TEXT_CUT, winid, wxClipboardTextEventHandler(func))
3802#define EVT_TEXT_COPY(winid, func) wx__DECLARE_EVT1(wxEVT_COMMAND_TEXT_COPY, winid, wxClipboardTextEventHandler(func))
3803#define EVT_TEXT_PASTE(winid, func) wx__DECLARE_EVT1(wxEVT_COMMAND_TEXT_PASTE, winid, wxClipboardTextEventHandler(func))
3804
3805// Thread events
3806#define EVT_THREAD(id, func) wx__DECLARE_EVT1(wxEVT_COMMAND_THREAD, id, wxThreadEventHandler(func))
3807
3808// ----------------------------------------------------------------------------
3809// Helper functions
3810// ----------------------------------------------------------------------------
3811
3812// This is an ugly hack to allow the use of Bind() instead of Connect() inside
3813// the library code if the library was built with support for it, here is how
3814// it is used:
3815//
3816// class SomeEventHandlingClass : wxBIND_OR_CONNECT_HACK_BASE_CLASS
3817// public SomeBaseClass
3818// {
3819// public:
3820// SomeEventHandlingClass(wxWindow *win)
3821// {
3822// // connect to the event for the given window
3823// wxBIND_OR_CONNECT_HACK(win, wxEVT_SOMETHING, wxSomeEventHandler,
3824// SomeEventHandlingClass::OnSomeEvent, this);
3825// }
3826//
3827// private:
3828// void OnSomeEvent(wxSomeEvent&) { ... }
3829// };
3830//
3831// This is *not* meant to be used by library users, it is only defined here
3832// (and not in a private header) because the base class must be visible from
3833// other public headers, please do NOT use this in your code, it will be
3834// removed from future wx versions without warning.
3835#if wxEVENTS_COMPATIBILITY_2_8
3836 #define wxBIND_OR_CONNECT_HACK_BASE_CLASS public wxEvtHandler,
3837 #define wxBIND_OR_CONNECT_HACK_ONLY_BASE_CLASS : public wxEvtHandler
3838 #define wxBIND_OR_CONNECT_HACK(w, evt, handler, func, obj) \
3839 win->Connect(evt, handler(func), NULL, obj)
3840#else // wxEVENTS_COMPATIBILITY_2_8
3841 #define wxBIND_OR_CONNECT_HACK_BASE_CLASS
3842 #define wxBIND_OR_CONNECT_HACK_ONLY_BASE_CLASS
3843 #define wxBIND_OR_CONNECT_HACK(w, evt, handler, func, obj) \
3844 win->Bind(evt, &func, obj)
3845#endif // wxEVENTS_COMPATIBILITY_2_8/!wxEVENTS_COMPATIBILITY_2_8
3846
3847#if wxUSE_GUI
3848
3849// Find a window with the focus, that is also a descendant of the given window.
3850// This is used to determine the window to initially send commands to.
3851WXDLLIMPEXP_CORE wxWindow* wxFindFocusDescendant(wxWindow* ancestor);
3852
3853#endif // wxUSE_GUI
3854
3855#endif // _WX_EVENT_H_