#include "wx/thread.h"
#include "wx/tracker.h"
-#if !wxEVENTS_COMPATIBILITY_2_8
+#ifdef wxHAS_EVENT_BIND
#include "wx/meta/convertible.h"
#endif
#define wxStaticCastEvent(type, val) static_cast<type>(val)
#define DECLARE_EVENT_TABLE_ENTRY(type, winid, idLast, fn, obj) \
- wxEventTableEntry(type, winid, idLast, wxNewEventFunctor(type, fn), obj)
+ wxEventTableEntry(type, winid, idLast, wxNewEventTableFunctor(type, fn), obj)
#define DECLARE_EVENT_TABLE_TERMINATOR() \
wxEventTableEntry(wxEVT_NULL, 0, 0, 0, 0)
// generate a new unique event type
extern WXDLLIMPEXP_BASE wxEventType wxNewEventType();
-// New macros to create templatized event types:
-
-#if wxEVENTS_COMPATIBILITY_2_8
-
- // Define/Declare a wxEventType-based event type:
-
- #define wxDEFINE_EVENT( name, type ) \
- const wxEventType name( wxNewEventType() )
-
- #define wxDECLARE_EXPORTED_EVENT( expdecl, name, type ) \
- extern const expdecl wxEventType name
-
- // Define/Declare a wxEventType-based event type and initialize it with a
- // predefined event type. (Only used for wxEVT_SPIN_XXX for backward
- // compatibility)
-
- #define wxDEFINE_EVENT_ALIAS( name, type, value ) \
- const wxEventType name = value
-
- #define wxDECLARE_EXPORTED_EVENT_ALIAS( expdecl, name, type ) \
- extern const expdecl wxEventType name
-
- // Declare a local (not exported) wxEventType-based event type:
-
- #define wxDECLARE_EVENT( name, type ) \
- wxDECLARE_EXPORTED_EVENT( wxEMPTY_PARAMETER_VALUE, name, type );
-
- // Try to cast the given event handler to the correct handler type:
-
- #define wxEVENT_HANDLER_CAST( functype, func ) \
- ( wxObjectEventFunction )( wxEventFunction )wxStaticCastEvent( functype, &func )
-#else
- // Define/Declare a templatized event type with the corresponding event as
- // a nested typedef:
+// define macros to create new event types:
+#ifdef wxHAS_EVENT_BIND
+ // events are represented by an instance of wxEventTypeTag and the
+ // corresponding type must be specified for type-safety checks
+ // define a new custom event type, can be used alone or after event
+ // declaration in the header using one of the macros below
#define wxDEFINE_EVENT( name, type ) \
const wxEventTypeTag< type > name( wxNewEventType() )
+ // the general version allowing exporting the event type from DLL, used by
+ // wxWidgets itself
#define wxDECLARE_EXPORTED_EVENT( expdecl, name, type ) \
extern const expdecl wxEventTypeTag< type > name
- // Define/Declare a templatized event type and initialize it with a
- // predefined event type. (Only used for wxEVT_SPIN_XXX for backward
- // compatibility)
+ // this is the version which will normally be used in the user code
+ #define wxDECLARE_EVENT( name, type ) \
+ wxDECLARE_EXPORTED_EVENT( wxEMPTY_PARAMETER_VALUE, name, type )
+
+ // these macros are only used internally for backwards compatibility and
+ // allow to define an alias for an existing event type (this is used by
+ // wxEVT_SPIN_XXX)
#define wxDEFINE_EVENT_ALIAS( name, type, value ) \
const wxEventTypeTag< type > name( value )
#define wxDECLARE_EXPORTED_EVENT_ALIAS( expdecl, name, type ) \
extern const expdecl wxEventTypeTag< type > name
+#else // !wxHAS_EVENT_BIND
+ // the macros are the same ones as above but defined differently as we only
+ // use the integer event type values to identify events in this case
- // Declare a local (not exported) templatized event type:
+ #define wxDEFINE_EVENT( name, type ) \
+ const wxEventType name( wxNewEventType() )
+ #define wxDECLARE_EXPORTED_EVENT( expdecl, name, type ) \
+ extern const expdecl wxEventType name
#define wxDECLARE_EVENT( name, type ) \
- wxDECLARE_EXPORTED_EVENT( wxEMPTY_PARAMETER_VALUE, name, type );
+ wxDECLARE_EXPORTED_EVENT( wxEMPTY_PARAMETER_VALUE, name, type )
+
+ #define wxDEFINE_EVENT_ALIAS( name, type, value ) \
+ const wxEventType name = value
+ #define wxDECLARE_EXPORTED_EVENT_ALIAS( expdecl, name, type ) \
+ extern const expdecl wxEventType name
+#endif // wxHAS_EVENT_BIND/!wxHAS_EVENT_BIND
- // Don't cast the given event handler so that wxEvtHandler::Connect() sees
- // the actual type:
+// Try to cast the given event handler to the correct handler type:
- #define wxEVENT_HANDLER_CAST( functype, func ) \
- ( &func )
-#endif
+#define wxEVENT_HANDLER_CAST( functype, func ) \
+ ( wxObjectEventFunction )( wxEventFunction )wxStaticCastEvent( functype, &func )
-// Template which associates the correct event object with the event type
-#if !wxEVENTS_COMPATIBILITY_2_8
+#ifdef wxHAS_EVENT_BIND
// The tag is a type associated to the event type (which is an integer itself,
// in spite of its name) value. It exists in order to be used as a template
wxEventType m_type;
};
-#endif // !wxEVENTS_COMPATIBILITY_2_8
+#endif // wxHAS_EVENT_BIND
// These are needed for the functor definitions
typedef void (wxEvtHandler::*wxEventFunction)(wxEvent&);
typedef wxEventFunction wxObjectEventFunction;
+// wxEventFunctorClassInfo is used as a unique identifier for wxEventFunctor-
+// derived classes; it is more light weight than wxClassInfo and can be used in
+// template classes
+typedef void (*wxEventFunctorClassInfo)();
+
+// this macro must be used in wxEventFunctor-derived classes
+#define wxDEFINE_EVENT_FUNCTOR_CLASS_INFO( classInfoName ) \
+ static void classInfoName() {}
+
// The event functor which is stored in the static and dynamic event tables:
class WXDLLIMPEXP_BASE wxEventFunctor
{
virtual void operator()(wxEvtHandler *, wxEvent&) = 0;
// this function tests whether this functor is matched, for the purpose of
- // finding it in an event table in Disconnect(), by the given func
- virtual bool Matches(const wxEventFunctor& func) const = 0;
+ // finding it in an event table in Unbind(), by the given functor:
+ virtual bool IsMatching(const wxEventFunctor& functor) const = 0;
- // these functions are used for functors comparison in Matches()
- virtual void *GetHandler() const { return GetEvtHandler(); }
- virtual wxEventFunction GetMethod() const { return NULL; }
+ // Test whether the given class info is the same as from this functor. This
+ // allows us in IsMatching to safely downcast the given wxEventFunctor without
+ // the usage of dynamic_cast<>().
+ virtual bool IsSameClass(wxEventFunctorClassInfo classInfo) const = 0;
- // this one is also used elsewhere in the code and should be overridden to
- // return non-NULL if we are indeed associated with an wxEvtHandler
- virtual wxEvtHandler *GetEvtHandler() const { return NULL; }
+ // If the functor holds an wxEvtHandler, then get access to it and track
+ // its lifetime with wxEventConnectionRef:
+ virtual wxEvtHandler *GetEvtHandler() const
+ { return NULL; }
+
+ // This is only used to maintain backward compatibility in
+ // wxAppConsoleBase::CallEventHandler and ensures that an overwritten
+ // wxAppConsoleBase::HandleEvent is still called for functors which hold an
+ // wxEventFunction:
+ virtual wxEventFunction GetEvtMethod() const
+ { return NULL; }
};
-// A plain method functor: notice that it is used even with the new events as
-// it is reused as a specialization of wxEventFunctorMethod for legacy untyped
-// event types
+// A plain method functor for the untyped legacy event types:
class WXDLLIMPEXP_BASE wxObjectEventFunctor : public wxEventFunctor
{
public:
wxObjectEventFunctor(wxObjectEventFunction method, wxEvtHandler *handler)
- {
- m_handler = handler;
- m_method = method;
- }
+ : m_handler( handler ), m_method( method )
+ { }
virtual void operator()(wxEvtHandler *handler, wxEvent& event)
{
(realHandler->*m_method)(event);
}
- virtual bool Matches(const wxEventFunctor& func) const
+ virtual bool IsMatching(const wxEventFunctor& functor) const
{
- void * const handler = func.GetHandler();
- if ( handler && GetHandler() != handler )
- return false;
+ if ( functor.IsSameClass( sm_classInfo ))
+ {
+ const wxObjectEventFunctor &other =
+ static_cast< const wxObjectEventFunctor & >( functor );
- const wxEventFunction method = GetMethod();
+ // FIXME-VC6: amazing but true: replacing "method == NULL" here
+ // with "!method" makes VC6 crash with an ICE in DLL build (only!)
- // FIXME-VC6: amazing but true: replacing "method == NULL" here with
- // "!method" makes VC6 crash with an ICE in DLL build (only!)
- return method == NULL || GetMethod() == method;
+ return ( m_method == other.m_method || other.m_method == NULL ) &&
+ ( m_handler == other.m_handler || other.m_handler == NULL );
+ }
+ else
+ return false;
}
- virtual wxEvtHandler *GetEvtHandler() const { return m_handler; }
- virtual wxEventFunction GetMethod() const { return m_method; }
+ virtual bool IsSameClass( wxEventFunctorClassInfo otherClassInfo ) const
+ { return sm_classInfo == otherClassInfo; }
+
+ virtual wxEvtHandler *GetEvtHandler() const
+ { return m_handler; }
+
+ virtual wxEventFunction GetEvtMethod() const
+ { return m_method; }
private:
wxEvtHandler *m_handler;
wxEventFunction m_method;
-};
-
-#if wxEVENTS_COMPATIBILITY_2_8
-// Create a functor for the legacy events: handler can be NULL and its default
-// value is used by the event table macros
+ wxDEFINE_EVENT_FUNCTOR_CLASS_INFO( sm_classInfo );
+};
+// Create a functor for the legacy events: used by Connect()
inline wxObjectEventFunctor *
wxNewEventFunctor(const wxEventType& WXUNUSED(evtType),
wxObjectEventFunction method,
- wxEvtHandler *handler = NULL)
+ wxEvtHandler *handler)
{
return new wxObjectEventFunctor(method, handler);
}
+// This version is used by DECLARE_EVENT_TABLE_ENTRY()
+inline wxObjectEventFunctor *
+wxNewEventTableFunctor(const wxEventType& WXUNUSED(evtType),
+ wxObjectEventFunction method)
+{
+ return new wxObjectEventFunctor(method, NULL);
+}
+
inline wxObjectEventFunctor
wxMakeEventFunctor(const wxEventType& WXUNUSED(evtType),
wxObjectEventFunction method,
return wxObjectEventFunctor(method, handler);
}
-#else // !wxEVENTS_COMPATIBILITY_2_8
-
-// functor forwarding the event to anything callable (function, static method,
-// generalized functor...)
-template <typename EventTag, typename Functor>
-class wxEventFunctorFunction : public wxEventFunctor
-{
-public:
- typedef typename EventTag::EventClass EventArg;
-
- wxEventFunctorFunction(Functor handler)
- {
- m_handler = handler;
- }
-
- virtual void operator()(wxEvtHandler *WXUNUSED(handler), wxEvent& event)
- {
- m_handler(static_cast<EventArg&>(event));
- }
-
- virtual bool Matches(const wxEventFunctor& WXUNUSED(func)) const
- {
- // we have no way to compare arbitrary functors so just consider them
- // to be equal: this means that disconnecting a functor will always
- // find the last functor connected which in turn implies that it's
- // probably a bad idea to connect more than one functor if you plan to
- // disconnect them but this limitation doesn't seem very important in
- // practice
- return true;
- }
-
-private:
- Functor m_handler;
-};
+#ifdef wxHAS_EVENT_BIND
namespace wxPrivate
{
{ return static_cast<T *>(p); }
static wxEvtHandler *ConvertToEvtHandler(T *p)
{ return p; }
- static wxEventFunction ConvertToEvtFunction(void (T::*f)(A&))
+ static wxEventFunction ConvertToEvtMethod(void (T::*f)(A&))
{ return static_cast<wxEventFunction>(
reinterpret_cast<void (T::*)(wxEvent&)>(f)); }
};
{ return NULL; }
static wxEvtHandler *ConvertToEvtHandler(T *)
{ return NULL; }
- static wxEventFunction ConvertToEvtFunction(void (T::*)(A&))
+ static wxEventFunction ConvertToEvtMethod(void (T::*)(A&))
{ return NULL; }
};
// allowed to handle different events in the same handler taking wxEvent&, for
// example
template
- <typename EventTag, typename Class, typename EventArg, typename ObjClass>
+ <typename EventTag, typename Class, typename EventArg, typename EventHandler>
class wxEventFunctorMethod
: public wxEventFunctor,
private wxPrivate::HandlerImpl
<
Class,
EventArg,
- wxConvertibleTo<Class, wxEvtHandler>::value
+ wxConvertibleTo<Class, wxEvtHandler>::value != 0
>
{
private:
typedef typename wxPrivate::EventClassOf<EventTag>::type EventClass;
- wxEventFunctorMethod(void (Class::*method)(EventArg&), ObjClass *handler)
+ wxEventFunctorMethod(void (Class::*method)(EventArg&), EventHandler *handler)
+ : m_handler( handler ), m_method( method )
{
wxASSERT_MSG( handler || this->IsEvtHandler(),
"handlers defined in non-wxEvtHandler-derived classes "
// you're trying to use is not compatible with (i.e. is not the same as
// or a base class of) the real event class used for this event type
CheckHandlerArgument(static_cast<EventClass *>(NULL));
-
- m_handler = handler;
- m_method = method;
}
virtual void operator()(wxEvtHandler *handler, wxEvent& event)
(realHandler->*m_method)(static_cast<EventArg&>(event));
}
- virtual bool Matches(const wxEventFunctor& func) const
+ virtual bool IsMatching(const wxEventFunctor& functor) const
{
- void * const handler = func.GetHandler();
- if ( handler && GetHandler() != handler )
+ if ( !functor.IsSameClass(sm_classInfo) )
return false;
- const wxEventFunction method = GetMethod();
- return !method || GetMethod() == method;
+ typedef wxEventFunctorMethod<EventTag, Class, EventArg, EventHandler>
+ ThisFunctor;
+
+ // the cast is valid because IsSameClass() returned true above
+ const ThisFunctor& other = static_cast<const ThisFunctor &>(functor);
+
+ return (m_method == other.m_method || other.m_method == NULL) &&
+ (m_handler == other.m_handler || other.m_handler == NULL);
}
- virtual void *GetHandler() const
+ virtual bool IsSameClass( wxEventFunctorClassInfo otherClassInfo ) const
+ { return sm_classInfo == otherClassInfo; }
+
+ virtual wxEvtHandler *GetEvtHandler() const
+ { return this->ConvertToEvtHandler(m_handler); }
+
+ virtual wxEventFunction GetEvtMethod() const
+ { return this->ConvertToEvtMethod(m_method); }
+
+private:
+ EventHandler *m_handler;
+ void (Class::*m_method)(EventArg&);
+
+ wxDEFINE_EVENT_FUNCTOR_CLASS_INFO( sm_classInfo );
+};
+
+
+// functor forwarding the event to function (function, static method)
+template <typename EventTag, typename EventArg>
+class wxEventFunctorFunction : public wxEventFunctor
+{
+private:
+ static void CheckHandlerArgument(EventArg *) { }
+
+public:
+ // the event class associated with the given event tag
+ typedef typename wxPrivate::EventClassOf<EventTag>::type EventClass;
+
+ wxEventFunctorFunction( void ( *handler )( EventArg & ))
+ : m_handler( handler )
{
- return m_handler;
+ // if you get an error here it means that the signature of the handler
+ // you're trying to use is not compatible with (i.e. is not the same as
+ // or a base class of) the real event class used for this event type
+ CheckHandlerArgument(static_cast<EventClass *>(NULL));
}
- virtual wxEventFunction GetMethod() const
+ virtual void operator()(wxEvtHandler *WXUNUSED(handler), wxEvent& event)
{
- return this->ConvertToEvtFunction(m_method);
+ // If you get an error here like "must use .* or ->* to call
+ // pointer-to-member function" then you probably tried to call
+ // Bind/Unbind with a method pointer but without a handler pointer or
+ // NULL as a handler e.g.:
+ // Unbind( wxEVT_XXX, &EventHandler::method );
+ // or
+ // Unbind( wxEVT_XXX, &EventHandler::method, NULL )
+ m_handler(static_cast<EventArg&>(event));
}
- virtual wxEvtHandler *GetEvtHandler() const
+ virtual bool IsMatching(const wxEventFunctor &functor) const
{
- return this->ConvertToEvtHandler(m_handler);
+ if ( !functor.IsSameClass(sm_classInfo) )
+ return false;
+
+ typedef wxEventFunctorFunction<EventTag, EventArg> ThisFunctor;
+
+ const ThisFunctor& other = static_cast<const ThisFunctor&>( functor );
+
+ return m_handler == other.m_handler;
}
+ virtual bool IsSameClass( wxEventFunctorClassInfo otherClassInfo ) const
+ { return sm_classInfo == otherClassInfo; }
+
private:
- ObjClass *m_handler;
- void (Class::*m_method)(EventArg&);
+ void (*m_handler)(EventArg&);
+
+ wxDEFINE_EVENT_FUNCTOR_CLASS_INFO( sm_classInfo );
};
-//
+template <typename EventTag, typename Functor>
+class wxEventFunctorFunctor : public wxEventFunctor
+{
+public:
+ typedef typename EventTag::EventClass EventArg;
+
+ wxEventFunctorFunctor(const Functor& handler)
+ : m_handler(handler), m_handlerAddr(&handler)
+ { }
+
+ virtual void operator()(wxEvtHandler *WXUNUSED(handler), wxEvent& event)
+ {
+ // If you get an error here like "must use '.*' or '->*' to call
+ // pointer-to-member function" then you probably tried to call
+ // Bind/Unbind with a method pointer but without a handler pointer or
+ // NULL as a handler e.g.:
+ // Unbind( wxEVT_XXX, &EventHandler::method );
+ // or
+ // Unbind( wxEVT_XXX, &EventHandler::method, NULL )
+ m_handler(static_cast<EventArg&>(event));
+ }
+
+ virtual bool IsMatching(const wxEventFunctor &functor) const
+ {
+ if ( !functor.IsSameClass(sm_classInfo) )
+ return false;
+
+ typedef wxEventFunctorFunctor<EventTag, Functor> FunctorThis;
+
+ const FunctorThis& other = static_cast<const FunctorThis&>(functor);
+
+ // The only reliable/portable way to compare two functors is by
+ // identity:
+ return m_handlerAddr == other.m_handlerAddr;
+ }
+
+ virtual bool IsSameClass( wxEventFunctorClassInfo otherClassInfo ) const
+ { return sm_classInfo == otherClassInfo; }
+
+private:
+ // Store a copy of the functor to prevent using/calling an already
+ // destroyed instance:
+ Functor m_handler;
+
+ // Use the address of the original functor for comparison in IsMatching:
+ const void *m_handlerAddr;
+
+ wxDEFINE_EVENT_FUNCTOR_CLASS_INFO( sm_classInfo );
+};
+
// Create functors for the templatized events, either allocated on the heap for
-// wxNewXXX() variants (this is needed in wxEvtHandler::Connect() to store them
-// in dynamic event table) or just by returning them as temporary objects (this
-// is enough for Disconnect() and we allocate unnecessary heap allocation like
-// this)
+// wxNewXXX() variants (this is needed in wxEvtHandler::Bind<>() to store them
+// in dynamic event table) or just by returning them as a temporary objects (this
+// is enough for Unbind<>() and we avoid unnecessary heap allocation like this).
-// Create functors wrapping other functors (including functions):
-template <typename EventTag, typename Functor>
-inline wxEventFunctorFunction<EventTag, Functor> *
-wxNewEventFunctor(const EventTag&, Functor func)
+// Create functors wrapping functions:
+template <typename EventTag, typename EventArg>
+inline wxEventFunctorFunction<EventTag, EventArg> *
+wxNewEventFunctor(const EventTag&, void (*func)(EventArg &))
+{
+ return new wxEventFunctorFunction<EventTag, EventArg>(func);
+}
+
+template <typename EventTag, typename EventArg>
+inline wxEventFunctorFunction<EventTag, EventArg>
+wxMakeEventFunctor(const EventTag&, void (*func)(EventArg &))
{
- return new wxEventFunctorFunction<EventTag, Functor>(func);
+ return wxEventFunctorFunction<EventTag, EventArg>(func);
}
+// Create functors wrapping other functors:
template <typename EventTag, typename Functor>
-inline wxEventFunctorFunction<EventTag, Functor>
-wxMakeEventFunctor(const EventTag&, Functor func)
+inline wxEventFunctorFunctor<EventTag, Functor> *
+wxNewEventFunctor(const EventTag&, const Functor &func)
{
- return wxEventFunctorFunction<EventTag, Functor>(func);
+ return new wxEventFunctorFunctor<EventTag, Functor>(func);
}
+template <typename EventTag, typename Functor>
+inline wxEventFunctorFunctor<EventTag, Functor>
+wxMakeEventFunctor(const EventTag&, const Functor &func)
+{
+ return wxEventFunctorFunctor<EventTag, Functor>(func);
+}
-// Create functors for methods:
+// Create functors wrapping methods:
template
- <typename EventTag, typename Class, typename EventArg, typename ObjClass>
-inline wxEventFunctorMethod<EventTag, Class, EventArg, ObjClass> *
+ <typename EventTag, typename Class, typename EventArg, typename EventHandler>
+inline wxEventFunctorMethod<EventTag, Class, EventArg, EventHandler> *
wxNewEventFunctor(const EventTag&,
void (Class::*method)(EventArg&),
- ObjClass *handler)
+ EventHandler *handler)
{
- return new wxEventFunctorMethod<EventTag, Class, EventArg, ObjClass>(
+ return new wxEventFunctorMethod<EventTag, Class, EventArg, EventHandler>(
method, handler);
}
template
- <typename EventTag, typename Class, typename EventArg, typename ObjClass>
-inline wxEventFunctorMethod<EventTag, Class, EventArg, ObjClass>
+ <typename EventTag, typename Class, typename EventArg, typename EventHandler>
+inline wxEventFunctorMethod<EventTag, Class, EventArg, EventHandler>
wxMakeEventFunctor(const EventTag&,
void (Class::*method)(EventArg&),
- ObjClass *handler)
+ EventHandler *handler)
{
- return wxEventFunctorMethod<EventTag, Class, EventArg, ObjClass>(
+ return wxEventFunctorMethod<EventTag, Class, EventArg, EventHandler>(
method, handler);
}
-// Special case for the wxNewEventFunctor() calls used inside the event table
-// macros: they don't specify the handler so ObjClass can't be deduced
+// Create an event functor for the event table via DECLARE_EVENT_TABLE_ENTRY:
+// in this case we don't have the handler (as it's always the same as the
+// object which generated the event) so we must use Class as its type
template <typename EventTag, typename Class, typename EventArg>
inline wxEventFunctorMethod<EventTag, Class, EventArg, Class> *
-wxNewEventFunctor(const EventTag&, void (Class::*method)(EventArg&))
+wxNewEventTableFunctor(const EventTag&, void (Class::*method)(EventArg&))
{
return new wxEventFunctorMethod<EventTag, Class, EventArg, Class>(
method, NULL);
}
-template
- <typename EventTag, typename Class, typename EventArg, typename ObjClass>
-inline wxEventFunctorMethod<EventTag, Class, EventArg, Class>
-wxMakeEventFunctor(const EventTag&, void (Class::*method)(EventArg&))
-{
- return wxEventFunctorMethod<EventTag, Class, EventArg, Class>(
- method, NULL);
-}
-
-#endif // !wxEVENTS_COMPATIBILITY_2_8
+#endif // wxHAS_EVENT_BIND
// many, but not all, standard event types
wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_COMMAND_TOOL_RCLICKED, wxCommandEvent);
wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_COMMAND_TOOL_DROPDOWN_CLICKED, wxCommandEvent);
wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_COMMAND_TOOL_ENTER, wxCommandEvent);
+wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_COMMAND_COMBOBOX_DROPDOWN, wxCommandEvent);
+wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_COMMAND_COMBOBOX_CLOSEUP, wxCommandEvent);
// Thread events
wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_COMMAND_THREAD, wxThreadEvent);
};
// The different categories for a wxEvent; see wxEvent::GetEventCategory.
-// NOTE: they are used as OR-combinable flags by wxApp::Yield
+// NOTE: they are used as OR-combinable flags by wxEventLoopBase::YieldFor
enum wxEventCategory
{
// this is the category for those events which are generated to update
// implementation only
- // used in the implementations of DoYield()
+ // used in the implementations of wxEventLoopBase::YieldFor
wxEVT_CATEGORY_UNKNOWN = 32,
- // a special category used as an argument to wxApp::Yield() to indicate that
+ // a special category used as an argument to wxEventLoopBase::YieldFor to indicate that
// Yield() should leave all wxEvents on the queue while emptying the native event queue
// (native events will be processed but the wxEvents they generate will be queued)
wxEVT_CATEGORY_CLIPBOARD = 64,
// events of the native toolkit and which typically are not-"delayable".
wxEVT_CATEGORY_NATIVE_EVENTS = wxEVT_CATEGORY_UI|wxEVT_CATEGORY_USER_INPUT,
- // used in wxApp::Yield to specify all event categories should be processed:
+ // used in wxEventLoopBase::YieldFor to specify all event categories should be processed:
wxEVT_CATEGORY_ALL =
wxEVT_CATEGORY_UI|wxEVT_CATEGORY_USER_INPUT|wxEVT_CATEGORY_SOCKET| \
- wxEVT_CATEGORY_TIMER|wxEVT_CATEGORY_THREAD
+ wxEVT_CATEGORY_TIMER|wxEVT_CATEGORY_THREAD|wxEVT_CATEGORY_UNKNOWN| \
+ wxEVT_CATEGORY_CLIPBOARD
};
/*
// for them wouldn't work (it needs to do a copy of the event)
virtual wxEvent *Clone() const = 0;
- // this function is used to selectively process events in wxApp::YieldFor
+ // this function is used to selectively process events in wxEventLoopBase::YieldFor
// NOTE: by default it returns wxEVT_CATEGORY_UI just because the major
// part of wxWidgets events belong to that category.
virtual wxEventCategory GetEventCategory() const
wxEvent& m_event;
int m_propagationLevelOld;
- DECLARE_NO_COPY_CLASS(wxPropagationDisabler)
+ wxDECLARE_NO_COPY_CLASS(wxPropagationDisabler);
};
/*
private:
wxEvent& m_event;
- DECLARE_NO_COPY_CLASS(wxPropagateOnce)
+ wxDECLARE_NO_COPY_CLASS(wxPropagateOnce);
};
: wxCommandEvent(eventType, id)
{ }
+ wxThreadEvent(const wxThreadEvent& event)
+ : wxCommandEvent(event)
+ {
+ // make sure our string member (which uses COW, aka refcounting) is not
+ // shared by other wxString instances:
+ SetString(GetString().c_str());
+ }
+
virtual wxEvent *Clone() const
{
wxThreadEvent* ev = new wxThreadEvent(*this);
return ev;
}
- // this is important to avoid that calling wxApp::Yield() thread events
+ // this is important to avoid that calling wxEventLoopBase::YieldFor thread events
// gets processed when this is unwanted:
virtual wxEventCategory GetEventCategory() const
{ return wxEVT_CATEGORY_THREAD; }
wxEVT_NC_RIGHT_DCLICK,
*/
-// the symbolic names for the mouse buttons
-enum
-{
- wxMOUSE_BTN_ANY = -1,
- wxMOUSE_BTN_NONE = 0,
- wxMOUSE_BTN_LEFT = 1,
- wxMOUSE_BTN_MIDDLE = 2,
- wxMOUSE_BTN_RIGHT = 3,
- wxMOUSE_BTN_AUX1 = 4,
- wxMOUSE_BTN_AUX2 = 5,
- wxMOUSE_BTN_MAX
-};
-
class WXDLLIMPEXP_CORE wxMouseEvent : public wxEvent,
public wxMouseState
{
// Was it a up event from this (or any) button?
bool ButtonUp(int but = wxMOUSE_BTN_ANY) const;
- // Was the given button?
+ // Was this event generated by the given button?
bool Button(int but) const;
- // Was the given button in Down state?
- bool ButtonIsDown(int but) const;
-
// Get the button which is changing state (wxMOUSE_BTN_NONE if none)
int GetButton() const;
bool Aux1DClick() const { return (m_eventType == wxEVT_AUX1_UP); }
bool Aux2DClick() const { return (m_eventType == wxEVT_AUX2_UP); }
- // Find the current state of the mouse buttons (regardless
- // of current event type)
- bool LeftIsDown() const { return m_leftDown; }
- bool MiddleIsDown() const { return m_middleDown; }
- bool RightIsDown() const { return m_rightDown; }
- bool Aux1IsDown() const { return m_aux1Down; }
- bool Aux2IsDown() const { return m_aux2Down; }
-
// True if a button is down and the mouse is moving
bool Dragging() const
{
// Returns the number of mouse clicks associated with this event.
int GetClickCount() const { return m_clickCount; }
-
- // Find the position of the event
- void GetPosition(wxCoord *xpos, wxCoord *ypos) const
- {
- if (xpos)
- *xpos = m_x;
- if (ypos)
- *ypos = m_y;
- }
-
- void GetPosition(long *xpos, long *ypos) const
- {
- if (xpos)
- *xpos = (long)m_x;
- if (ypos)
- *ypos = (long)m_y;
- }
-
- // Find the position of the event
- wxPoint GetPosition() const { return wxPoint(m_x, m_y); }
-
// Find the logical position of the event given the DC
wxPoint GetLogicalPosition(const wxDC& dc) const;
- // Get X position
- wxCoord GetX() const { return m_x; }
-
- // Get Y position
- wxCoord GetY() const { return m_y; }
-
// Get wheel rotation, positive or negative indicates direction of
// rotation. Current devices all send an event when rotation is equal to
// +/-WheelDelta, but this allows for finer resolution devices to be
}
public:
- wxCoord m_x, m_y;
-
- bool m_leftDown;
- bool m_middleDown;
- bool m_rightDown;
- bool m_aux1Down;
- bool m_aux2Down;
-
int m_clickCount;
int m_wheelAxis;
m_keyCode = evt.m_keyCode;
- m_scanCode = evt.m_scanCode;
m_rawCode = evt.m_rawCode;
m_rawFlags = evt.m_rawFlags;
#if wxUSE_UNICODE
long m_keyCode;
- // FIXME: what is this for? relation to m_rawXXX?
- bool m_scanCode;
-
#if wxUSE_UNICODE
// This contains the full Unicode character
// in a character events in Unicode mode
wxEVT_PAINT_ICON
*/
-#if defined(__WXDEBUG__) && (defined(__WXMSW__) || defined(__WXPM__))
+#if wxDEBUG_LEVEL && (defined(__WXMSW__) || defined(__WXPM__))
+ #define wxHAS_PAINT_DEBUG
+
// see comments in src/msw|os2/dcclient.cpp where g_isPainting is defined
extern WXDLLIMPEXP_CORE int g_isPainting;
#endif // debug
wxPaintEvent(int Id = 0)
: wxEvent(Id, wxEVT_PAINT)
{
-#if defined(__WXDEBUG__) && (defined(__WXMSW__) || defined(__WXPM__))
- // set the internal flag for the duration of processing of WM_PAINT
+#ifdef wxHAS_PAINT_DEBUG
+ // set the internal flag for the duration of redrawing
g_isPainting++;
#endif // debug
}
// default copy ctor and dtor are normally fine, we only need them to keep
// g_isPainting updated in debug build
-#if defined(__WXDEBUG__) && (defined(__WXMSW__) || defined(__WXPM__))
+#ifdef wxHAS_PAINT_DEBUG
wxPaintEvent(const wxPaintEvent& event)
: wxEvent(event)
{
virtual wxEvent *Clone() const { return new wxNavigationKeyEvent(*this); }
- enum
+ enum wxNavigationKeyEventFlags
{
IsBackward = 0x0000,
IsForward = 0x0001,
wxObject* m_callbackUserData;
private:
- DECLARE_NO_ASSIGN_CLASS(wxEventTableEntryBase)
+ wxDECLARE_NO_ASSIGN_CLASS(wxEventTableEntryBase);
};
// an entry from a static event table
const int& m_eventType;
private:
- DECLARE_NO_ASSIGN_CLASS(wxEventTableEntry)
+ wxDECLARE_NO_ASSIGN_CLASS(wxEventTableEntry);
};
// an entry used in dynamic event table managed by wxEvtHandler::Connect()
int m_eventType;
private:
- DECLARE_NO_ASSIGN_CLASS(wxDynamicEventTableEntry)
+ wxDECLARE_NO_ASSIGN_CLASS(wxDynamicEventTableEntry);
};
// ----------------------------------------------------------------------------
// Clear table
void Clear();
-#if defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING
- // Clear all tables
+#if wxUSE_MEMORY_TRACING
+ // Clear all tables: only used to work around problems in memory tracing
+ // code
static void ClearAll();
-#endif // __WXDEBUG__ && wxUSE_MEMORY_TRACING
+#endif // wxUSE_MEMORY_TRACING
protected:
// Init the hash table with the entries of the static event table.
wxEventHashTable* m_previous;
wxEventHashTable* m_next;
- DECLARE_NO_COPY_CLASS(wxEventHashTable)
+ wxDECLARE_NO_COPY_CLASS(wxEventHashTable);
};
// ----------------------------------------------------------------------------
// Event queuing and processing
// ----------------------------
-
// Process an event right now: this can only be called from the main
// thread, use QueueEvent() for scheduling the events for
// processing from other threads.
void ProcessPendingEvents();
// NOTE: uses ProcessEvent()
+ void DeletePendingEvents();
+
#if wxUSE_THREADS
bool ProcessThreadEvent(const wxEvent& event);
- // NOTE: uses AddPendingEvent()
+ // NOTE: uses AddPendingEvent(); call only from secondary threads
#endif
wxObject *userData = NULL,
wxEvtHandler *eventSink = NULL)
{
- DoConnect(winid, lastId, eventType,
+ DoBind(winid, lastId, eventType,
wxNewEventFunctor(eventType, func, eventSink),
userData);
}
wxObject *userData = NULL,
wxEvtHandler *eventSink = NULL)
{
- return DoDisconnect(winid, lastId, eventType,
+ return DoUnbind(winid, lastId, eventType,
wxMakeEventFunctor(eventType, func, eventSink),
userData );
}
wxEvtHandler *eventSink = NULL)
{ return Disconnect(wxID_ANY, eventType, func, userData, eventSink); }
-#if !wxEVENTS_COMPATIBILITY_2_8
- // Event handling in functions (including generalized functors):
-
- template <typename EventTag, typename Functor>
- void Connect(int winid,
- int lastId,
- const EventTag& eventType,
- Functor func)
+#ifdef wxHAS_EVENT_BIND
+ // Bind functions to an event:
+ template <typename EventTag, typename EventArg>
+ void Bind(const EventTag& eventType,
+ void (*function)(EventArg &),
+ int winid = wxID_ANY,
+ int lastId = wxID_ANY,
+ wxObject *userData = NULL)
{
- DoConnect(winid, lastId, eventType,
- wxNewEventFunctor(eventType, func));
+ DoBind(winid, lastId, eventType,
+ wxNewEventFunctor(eventType, function),
+ userData);
}
- template <typename EventTag, typename Functor>
- void Connect(int winid, const EventTag& eventType, Functor func)
- { Connect(winid, wxID_ANY, eventType, func); }
-
- template <typename EventTag, typename Functor>
- void Connect(const EventTag& eventType, Functor func)
- { Connect(wxID_ANY, eventType, func); }
-
- template <typename EventTag, typename Functor>
- bool Disconnect(int winid,
- int lastId,
- const EventTag& eventType,
- Functor func)
+ template <typename EventTag, typename EventArg>
+ bool Unbind(const EventTag& eventType,
+ void (*function)(EventArg &),
+ int winid = wxID_ANY,
+ int lastId = wxID_ANY,
+ wxObject *userData = NULL)
{
- return DoDisconnect(winid, lastId, eventType,
- wxMakeEventFunctor(eventType, func));
+ return DoUnbind(winid, lastId, eventType,
+ wxMakeEventFunctor(eventType, function),
+ userData);
}
+ // Bind functors to an event:
template <typename EventTag, typename Functor>
- bool Disconnect(int winid, const EventTag& eventType, Functor func)
- { return Disconnect(winid, wxID_ANY, eventType, func); }
-
- template <typename EventTag, typename Functor>
- bool Disconnect(const EventTag& eventType, Functor func)
- { return Disconnect(wxID_ANY, eventType, func); }
-
-
-
- // Event handling in class methods: the object handling the event (i.e.
- // this object itself by default or eventSink if specified) must be
- // convertible to this class.
- //
- // Notice that we need to have separate overloads for the versions with and
- // without eventSink because in the latter case we must check that this
- // object itself derives from Class while in the former this is not
- // necessarily true
-
- // Methods connecting/disconnecting event to this object itself
-
- template <typename EventTag, typename Class, typename EventArg>
- void Connect(int winid,
- int lastId,
- const EventTag& eventType,
- void (Class::*func)(EventArg&),
- wxObject *userData = NULL)
+ void Bind(const EventTag& eventType,
+ const Functor &functor,
+ int winid = wxID_ANY,
+ int lastId = wxID_ANY,
+ wxObject *userData = NULL)
{
- DoConnect(winid, lastId, eventType,
- wxNewEventFunctor(eventType, func, static_cast<Class *>(this)),
+ DoBind(winid, lastId, eventType,
+ wxNewEventFunctor(eventType, functor),
userData);
}
- template <typename EventTag, typename Class, typename EventArg>
- void Connect(int winid,
- const EventTag& eventType,
- void (Class::*func)(EventArg&),
- wxObject *userData = NULL)
- { Connect(winid, wxID_ANY, eventType, func, userData); }
- template <typename EventTag, typename Class, typename EventArg>
- void Connect(const EventTag& eventType,
- void (Class::*func)(EventArg&),
- wxObject *userData = NULL)
- { Connect(wxID_ANY, eventType, func, userData); }
-
-
- template <typename EventTag, typename Class, typename EventArg>
- bool Disconnect(int winid,
- int lastId,
- const EventTag& eventType,
- void (Class::*func)(EventArg&),
- wxObject *userData = NULL)
+ template <typename EventTag, typename Functor>
+ bool Unbind(const EventTag& eventType,
+ const Functor &functor,
+ int winid = wxID_ANY,
+ int lastId = wxID_ANY,
+ wxObject *userData = NULL)
{
- return DoDisconnect(winid, lastId, eventType,
- wxMakeEventFunctor(eventType, func,
- static_cast<Class *>(this)),
+ return DoUnbind(winid, lastId, eventType,
+ wxMakeEventFunctor(eventType, functor),
userData);
}
- template <typename EventTag, typename Class, typename EventArg>
- bool Disconnect(int winid,
- const EventTag& eventType,
- void (Class::*func)(EventArg&),
- wxObject *userData = NULL)
- { return Disconnect(winid, wxID_ANY, eventType, func, userData); }
-
- template <typename EventTag, typename Class, typename EventArg>
- bool Disconnect(const EventTag& eventType,
- void (Class::*func)(EventArg&),
- wxObject *userData = NULL)
- { return Disconnect(wxID_ANY, eventType, func, userData); }
-
- // Methods connecting/disconnecting event to another object
+ // Bind a method of a class (called on the specified handler which must
+ // be convertible to this class) object to an event:
- template
- <typename EventTag, typename Class, typename EventArg, typename ObjClass>
- void Connect(int winid,
- int lastId,
- const EventTag& eventType,
- void (Class::*func)(EventArg&),
- wxObject *userData,
- ObjClass *eventSink)
+ template <typename EventTag, typename Class, typename EventArg, typename EventHandler>
+ void Bind(const EventTag &eventType,
+ void (Class::*method)(EventArg &),
+ EventHandler *handler,
+ int winid = wxID_ANY,
+ int lastId = wxID_ANY,
+ wxObject *userData = NULL)
{
- DoConnect(winid, lastId, eventType,
- wxNewEventFunctor(eventType, func, eventSink),
+ DoBind(winid, lastId, eventType,
+ wxNewEventFunctor(eventType, method, handler),
userData);
}
- template
- <typename EventTag, typename Class, typename EventArg, typename ObjClass>
- void Connect(int winid,
- const EventTag& eventType,
- void (Class::*func)(EventArg&),
- wxObject *userData,
- ObjClass *eventSink)
- { Connect(winid, wxID_ANY, eventType, func, userData, eventSink); }
-
- template
- <typename EventTag, typename Class, typename EventArg, typename ObjClass>
- void Connect(const EventTag& eventType,
- void (Class::*func)(EventArg&),
- wxObject *userData,
- ObjClass *eventSink)
- { Connect(wxID_ANY, eventType, func, userData, eventSink); }
-
-
- template
- <typename EventTag, typename Class, typename EventArg, typename ObjClass>
- bool Disconnect(int winid,
- int lastId,
- const EventTag& eventType,
- void (Class::*func)(EventArg&),
- wxObject *userData,
- ObjClass *eventSink)
+ template <typename EventTag, typename Class, typename EventArg, typename EventHandler>
+ bool Unbind(const EventTag &eventType,
+ void (Class::*method)(EventArg&),
+ EventHandler *handler,
+ int winid = wxID_ANY,
+ int lastId = wxID_ANY,
+ wxObject *userData = NULL )
{
- return DoDisconnect(winid, lastId, eventType,
- wxMakeEventFunctor(eventType, func, eventSink),
+ return DoUnbind(winid, lastId, eventType,
+ wxMakeEventFunctor(eventType, method, handler),
userData);
}
-
- template
- <typename EventTag, typename Class, typename EventArg, typename ObjClass>
- bool Disconnect(int winid,
- const EventTag& eventType,
- void (Class::*func)(EventArg&),
- wxObject *userData,
- ObjClass *eventSink)
- { return Disconnect(winid, wxID_ANY, eventType, func,
- userData, eventSink); }
-
- template
- <typename EventTag, typename Class, typename EventArg, typename ObjClass>
- bool Disconnect(const EventTag& eventType,
- void (Class::*func)(EventArg&),
- wxObject *userData,
- ObjClass *eventSink)
- { return Disconnect(wxID_ANY, eventType, func, userData, eventSink); }
-
-
-
- // Static version of Connect() which allows to specify the event source and
- // event handler in a more symmetric way
- template <typename ObjSource, typename EventTag,
- typename Class, typename EventArg, typename ObjClass>
- static void Connect(ObjSource *eventSrc,
- int winid,
- int lastId,
- const EventTag& eventType,
- void (Class::*func)(EventArg&),
- wxObject *userData = NULL,
- ObjClass *eventSink = NULL)
- {
- eventSrc->Connect(winid, lastId, eventType, func, userData, eventSink);
- }
-
- template <typename ObjSource, typename EventTag,
- typename Class, typename EventArg, typename ObjClass>
- static void Connect(ObjSource *eventSrc,
- int winid,
- const EventTag& eventType,
- void (Class::*func)(EventArg&),
- wxObject *userData = NULL,
- ObjClass *eventSink = NULL)
- {
- Connect(eventSrc, winid, wxID_ANY, eventType, func, userData, eventSink);
- }
-
- template <typename ObjSource, typename EventTag,
- typename Class, typename EventArg, typename ObjClass>
- static void Connect(ObjSource *eventSrc,
- const EventTag& eventType,
- void (Class::*func)(EventArg&),
- wxObject *userData = NULL,
- ObjClass *eventSink = NULL)
- {
- Connect(eventSrc, wxID_ANY, eventType, func, userData, eventSink);
- }
-
-
- template <typename ObjSource, typename EventTag,
- typename Class, typename EventArg, typename ObjClass>
- static bool Disconnect(ObjSource *eventSrc,
- int winid,
- int lastId,
- const EventTag& eventType,
- void (Class::*func)(EventArg&),
- wxObject *userData = NULL,
- ObjClass *eventSink = NULL)
- {
- return eventSrc->Disconnect(winid, lastId, eventType, func,
- userData, eventSink);
- }
-
- template <typename ObjSource, typename EventTag,
- typename Class, typename EventArg, typename ObjClass>
- static bool Disconnect(ObjSource *eventSrc,
- int winid,
- const EventTag& eventType,
- void (Class::*func)(EventArg&),
- wxObject *userData = NULL,
- ObjClass *eventSink = NULL)
- {
- return Disconnect(eventSrc, winid, wxID_ANY, eventType, func,
- userData, eventSink);
- }
-
- template <typename ObjSource, typename EventTag,
- typename Class, typename EventArg, typename ObjClass>
- static bool Disconnect(ObjSource *eventSrc,
- const EventTag& eventType,
- void (Class::*func)(EventArg&),
- wxObject *userData = NULL,
- ObjClass *eventSink = NULL)
- {
- return Disconnect(eventSrc, wxID_ANY, eventType, func,
- userData, eventSink);
- }
-#endif // !wxEVENTS_COMPATIBILITY_2_8
-
+#endif // wxHAS_EVENT_BIND
wxList* GetDynamicEventTable() const { return m_dynamicEvents ; }
//
// It is meant to be called from ProcessEvent() only and is not virtual,
// additional event handlers can be hooked into the normal event processing
- // logic using TryValidator() hook.
+ // logic using TryBefore() and TryAfter() hooks.
bool ProcessEventHere(wxEvent& event);
private:
- void DoConnect(int winid,
+ void DoBind(int winid,
int lastId,
wxEventType eventType,
wxEventFunctor *func,
wxObject* userData = NULL);
- bool DoDisconnect(int winid,
+ bool DoUnbind(int winid,
int lastId,
wxEventType eventType,
const wxEventFunctor& func,
// hooks for wxWindow used by ProcessEvent()
// -----------------------------------------
- // This one is called before trying our own event table to allow plugging
- // in the validators.
- //
- // NB: This method is intentionally *not* inside wxUSE_VALIDATORS!
- // It is part of wxBase which doesn't use validators and the code
- // is compiled out when building wxBase w/o GUI classes, which affects
- // binary compatibility and wxBase library can't be used by GUI
- // ports.
- virtual bool TryValidator(wxEvent& WXUNUSED(event)) { return false; }
+ // this one is called before trying our own event table to allow plugging
+ // in the event handlers overriding the default logic, this is used by e.g.
+ // validators.
+ virtual bool TryBefore(wxEvent& event);
// this one is called after failing to find the event handle in our own
// table to give a chance to the other windows to process it
//
// base class implementation passes the event to wxTheApp
- virtual bool TryParent(wxEvent& event);
+ virtual bool TryAfter(wxEvent& event);
+
+#ifdef WXWIN_COMPATIBILITY_2_8
+ // deprecated method: override TryBefore() instead of this one
+ wxDEPRECATED_BUT_USED_INTERNALLY_INLINE(
+ virtual bool TryValidator(wxEvent& WXUNUSED(event)), return false; )
+
+ wxDEPRECATED_BUT_USED_INTERNALLY_INLINE(
+ virtual bool TryParent(wxEvent& event), return DoTryApp(event); )
+#endif // WXWIN_COMPATIBILITY_2_8
static const wxEventTable sm_eventTable;
virtual void *DoGetClientData() const;
// Search tracker objects for event connection with this sink
- wxEventConnectionRef *FindRefInTrackerList(wxEvtHandler *eventSink);
+ wxEventConnectionRef *FindRefInTrackerList(wxEvtHandler *handler);
private:
+ // pass the event to wxTheApp instance, called from TryAfter()
+ bool DoTryApp(wxEvent& event);
+
DECLARE_DYNAMIC_CLASS_NO_COPY(wxEvtHandler)
};
-WX_DEFINE_EXPORTED_ARRAY_PTR(wxEvtHandler*, wxEvtHandlerArray);
+WX_DEFINE_ARRAY_WITH_DECL_PTR(wxEvtHandler *, wxEvtHandlerArray, class WXDLLIMPEXP_BASE);
// ----------------------------------------------------------------------------
// wxEventConnectionRef represents all connections between two event handlers
friend class wxEvtHandler;
- DECLARE_NO_ASSIGN_CLASS(wxEventConnectionRef)
+ wxDECLARE_NO_ASSIGN_CLASS(wxEventConnectionRef);
};
// Post a message to the given event handler which will be processed during the
wxArrayInt m_eventsToBlock;
wxWindow *m_window;
- DECLARE_NO_COPY_CLASS(wxEventBlocker)
+ wxDECLARE_NO_COPY_CLASS(wxEventBlocker);
};
typedef void (wxEvtHandler::*wxCommandEventFunction)(wxCommandEvent&);
#define EVT_TOOL_RCLICKED_RANGE(id1, id2, func) wx__DECLARE_EVT2(wxEVT_COMMAND_TOOL_RCLICKED, id1, id2, wxCommandEventHandler(func))
#define EVT_TOOL_ENTER(winid, func) wx__DECLARE_EVT1(wxEVT_COMMAND_TOOL_ENTER, winid, wxCommandEventHandler(func))
#define EVT_CHECKLISTBOX(winid, func) wx__DECLARE_EVT1(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED, winid, wxCommandEventHandler(func))
+#define EVT_COMBOBOX_DROPDOWN(winid, func) wx__DECLARE_EVT1(wxEVT_COMMAND_COMBOBOX_DROPDOWN, winid, wxCommandEventHandler(func))
+#define EVT_COMBOBOX_CLOSEUP(winid, func) wx__DECLARE_EVT1(wxEVT_COMMAND_COMBOBOX_CLOSEUP, winid, wxCommandEventHandler(func))
// Generic command events
#define EVT_COMMAND_LEFT_CLICK(winid, func) wx__DECLARE_EVT1(wxEVT_COMMAND_LEFT_CLICK, winid, wxCommandEventHandler(func))
#define EVT_THREAD(id, func) wx__DECLARE_EVT1(wxEVT_COMMAND_THREAD, id, wxThreadEventHandler(func))
// ----------------------------------------------------------------------------
-// Global data
+// Helper functions
// ----------------------------------------------------------------------------
-// list containing event handlers with pending events for them
+// This is an ugly hack to allow the use of Bind() instead of Connect() inside
+// the library code if the library was built with support for it, here is how
+// it is used:
//
-// notice that each event handler should occur at most once in this list
-extern WXDLLIMPEXP_BASE wxList *wxHandlersWithPendingEvents;
-extern WXDLLIMPEXP_BASE wxList *wxHandlersWithPendingDelayedEvents;
-#if wxUSE_THREADS
- // this critical section protectes both the lists above
- extern WXDLLIMPEXP_BASE wxCriticalSection *wxHandlersWithPendingEventsLocker;
-#endif
-
-// old list names:
-#define wxPendingEvents wxHandlersWithPendingEvents
-#define wxPendingEventsLocker wxHandlersWithPendingEventsLocker
-
-// ----------------------------------------------------------------------------
-// Helper functions
-// ----------------------------------------------------------------------------
+// class SomeEventHandlingClass : wxBIND_OR_CONNECT_HACK_BASE_CLASS
+// public SomeBaseClass
+// {
+// public:
+// SomeEventHandlingClass(wxWindow *win)
+// {
+// // connect to the event for the given window
+// wxBIND_OR_CONNECT_HACK(win, wxEVT_SOMETHING, wxSomeEventHandler,
+// SomeEventHandlingClass::OnSomeEvent, this);
+// }
+//
+// private:
+// void OnSomeEvent(wxSomeEvent&) { ... }
+// };
+//
+// This is *not* meant to be used by library users, it is only defined here
+// (and not in a private header) because the base class must be visible from
+// other public headers, please do NOT use this in your code, it will be
+// removed from future wx versions without warning.
+#ifdef wxHAS_EVENT_BIND
+ #define wxBIND_OR_CONNECT_HACK_BASE_CLASS
+ #define wxBIND_OR_CONNECT_HACK_ONLY_BASE_CLASS
+ #define wxBIND_OR_CONNECT_HACK(w, evt, handler, func, obj) \
+ win->Bind(evt, &func, obj)
+#else // wxHAS_EVENT_BIND
+ #define wxBIND_OR_CONNECT_HACK_BASE_CLASS public wxEvtHandler,
+ #define wxBIND_OR_CONNECT_HACK_ONLY_BASE_CLASS : public wxEvtHandler
+ #define wxBIND_OR_CONNECT_HACK(w, evt, handler, func, obj) \
+ win->Connect(evt, handler(func), NULL, obj)
+#endif // wxHAS_EVENT_BIND
#if wxUSE_GUI
projects / wxWidgets.git / blobdiff