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