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