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