#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 );
-
-#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 )
-#endif
+ #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
// Try to cast the given event handler to the correct handler type:
#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;
+
+ // 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;
- // these functions are used for functors comparison in Matches()
- virtual void *GetHandler() const { return GetEvtHandler(); }
- virtual wxEventFunction GetMethod() 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 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; }
+ // 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 )
+ { }
+
+ virtual void operator()(wxEvtHandler *handler, wxEvent& event)
{
- m_handler = handler;
- m_method = method;
- }
+ wxEvtHandler * const realHandler = m_handler ? m_handler : handler;
- 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; }
};
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:
- EventHandler *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::Bind<>() to store them
// in dynamic event table) or just by returning them as 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 EventHandler>
inline 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 EventHandler 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 EventHandler>
-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
wxPropagateOnce(wxEvent& event) : m_event(event)
{
wxASSERT_MSG( m_event.m_propagationLevel > 0,
- _T("shouldn't be used unless ShouldPropagate()!") );
+ wxT("shouldn't be used unless ShouldPropagate()!") );
m_event.m_propagationLevel--;
}
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;
wxEVT_HOTKEY
*/
+// key categories: the bit flags for IsKeyInCategory() function
+//
+// the enum values used may change in future version of wx
+// use the named constants only, or bitwise combinations thereof
+enum wxKeyCategoryFlags
+{
+ // arrow keys, on and off numeric keypads
+ WXK_CATEGORY_ARROW = 1,
+
+ // page up and page down keys, on and off numeric keypads
+ WXK_CATEGORY_PAGING = 2,
+
+ // home and end keys, on and off numeric keypads
+ WXK_CATEGORY_JUMP = 4,
+
+ // tab key, on and off numeric keypads
+ WXK_CATEGORY_TAB = 8,
+
+ // backspace and delete keys, on and off numeric keypads
+ WXK_CATEGORY_CUT = 16,
+
+ // all keys usually used for navigation
+ WXK_CATEGORY_NAVIGATION = WXK_CATEGORY_ARROW |
+ WXK_CATEGORY_PAGING |
+ WXK_CATEGORY_JUMP
+};
+
class WXDLLIMPEXP_CORE wxKeyEvent : public wxEvent,
public wxKeyboardState
{
// get the key code: an ASCII7 char or an element of wxKeyCode enum
int GetKeyCode() const { return (int)m_keyCode; }
+ // returns true iff this event's key code is of a certain type
+ bool IsKeyInCategory(int category) const;
+
#if wxUSE_UNICODE
// get the Unicode character corresponding to this key
wxChar GetUnicodeKey() const { return m_uniChar; }
// m_loggingOff flag is only used by wxEVT_[QUERY_]END_SESSION, it
// doesn't make sense for wxEVT_CLOSE_WINDOW
wxASSERT_MSG( m_eventType != wxEVT_CLOSE_WINDOW,
- _T("this flag is for end session events only") );
+ wxT("this flag is for end session events only") );
return m_loggingOff;
}
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
- // Bind arbitrary functor (including just a function) to an event:
+#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)
+ {
+ DoBind(winid, lastId, eventType,
+ wxNewEventFunctor(eventType, function),
+ userData);
+ }
+
+
+ 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 DoUnbind(winid, lastId, eventType,
+ wxMakeEventFunctor(eventType, function),
+ userData);
+ }
+
+ // Bind functors to an event:
template <typename EventTag, typename Functor>
void Bind(const EventTag& eventType,
- Functor functor,
+ const Functor &functor,
int winid = wxID_ANY,
int lastId = wxID_ANY,
wxObject *userData = NULL)
{
- DoConnect(winid, lastId, eventType,
+ DoBind(winid, lastId, eventType,
wxNewEventFunctor(eventType, functor),
userData);
}
template <typename EventTag, typename Functor>
bool Unbind(const EventTag& eventType,
- Functor functor,
+ const Functor &functor,
int winid = wxID_ANY,
int lastId = wxID_ANY,
wxObject *userData = NULL)
{
- return DoDisconnect(winid, lastId, eventType,
+ return DoUnbind(winid, lastId, eventType,
wxMakeEventFunctor(eventType, functor),
userData);
}
int lastId = wxID_ANY,
wxObject *userData = NULL)
{
- DoConnect(winid, lastId, eventType,
+ DoBind(winid, lastId, eventType,
wxNewEventFunctor(eventType, method, handler),
userData);
}
int lastId = wxID_ANY,
wxObject *userData = NULL )
{
- return DoDisconnect(winid, lastId, eventType,
+ return DoUnbind(winid, lastId, eventType,
wxMakeEventFunctor(eventType, method, handler),
userData);
}
-#endif // !wxEVENTS_COMPATIBILITY_2_8
+#endif // wxHAS_EVENT_BIND
wxList* GetDynamicEventTable() const { return m_dynamicEvents ; }
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,
wxDECLARE_NO_ASSIGN_CLASS(wxEventConnectionRef);
};
-inline void wxObjectEventFunctor::operator()(wxEvtHandler *handler, wxEvent& event)
-{
- wxEvtHandler * const realHandler = m_handler ? m_handler : handler;
-
- (realHandler->*m_method)(event);
-}
-
// Post a message to the given event handler which will be processed during the
// next event loop iteration.
//
// (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.
-#if wxEVENTS_COMPATIBILITY_2_8
- #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)
-#else // wxEVENTS_COMPATIBILITY_2_8
+#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)
-#endif // wxEVENTS_COMPATIBILITY_2_8/!wxEVENTS_COMPATIBILITY_2_8
+#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