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