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