]> git.saurik.com Git - wxWidgets.git/blob - include/wx/event.h
add missing tests (closes #10692)
[wxWidgets.git] / include / wx / event.h
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_