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