// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-#ifndef _WX_EVENTH__
-#define _WX_EVENTH__
+#ifndef _WX_EVENT_H__
+#define _WX_EVENT_H__
#if defined(__GNUG__) && !defined(__APPLE__)
#pragma interface "event.h"
#include "wx/thread.h"
+#include "wx/dynarray.h"
+
// ----------------------------------------------------------------------------
// forward declarations
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxDC;
class WXDLLIMPEXP_CORE wxMenu;
class WXDLLIMPEXP_CORE wxWindow;
+ class WXDLLIMPEXP_CORE wxWindowBase;
#endif // wxUSE_GUI
// ----------------------------------------------------------------------------
#define DECLARE_EVENT_TABLE_ENTRY(type, winid, idLast, fn, obj) \
wxEventTableEntry(type, winid, idLast, fn, obj)
+#define EMPTY_PARAMETER_VALUE /* Fake macro parameter value */
+
#define BEGIN_DECLARE_EVENT_TYPES()
#define END_DECLARE_EVENT_TYPES()
#define DECLARE_EXPORTED_EVENT_TYPE(expdecl, name, value) \
#define DECLARE_EVENT_TYPE(name, value) \
DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_CORE, name, value)
#define DECLARE_LOCAL_EVENT_TYPE(name, value) \
- DECLARE_EXPORTED_EVENT_TYPE(/* */, name, value)
+ DECLARE_EXPORTED_EVENT_TYPE(EMPTY_PARAMETER_VALUE, name, value)
#define DEFINE_EVENT_TYPE(name) const wxEventType name = wxNewEventType();
#define DEFINE_LOCAL_EVENT_TYPE(name) DEFINE_EVENT_TYPE(name)
#endif // WXWIN_COMPATIBILITY
+// the predefined constants for the number of times we propagate event
+// upwards window child-parent chain
+enum Propagation_state
+{
+ // don't propagate it at all
+ wxEVENT_PROPAGATE_NONE = 0,
+
+ // propagate it until it is processed
+ wxEVENT_PROPAGATE_MAX = INT_MAX
+};
+
/*
* wxWindows events, covering all interesting things that might happen
* (button clicking, resizing, setting text in widgets, etc.).
void Skip(bool skip = TRUE) { m_skipped = skip; }
bool GetSkipped() const { return m_skipped; };
- // Implementation only: this test is explicitlty anti OO and this functions
- // exists only for optimization purposes.
- bool IsCommandEvent() const { return m_isCommandEvent; }
-
// this function is used to create a copy of the event polymorphically and
// all derived classes must implement it because otherwise wxPostEvent()
// for them wouldn't work (it needs to do a copy of the event)
virtual wxEvent *Clone() const = 0;
+ // Implementation only: this test is explicitlty anti OO and this functions
+ // exists only for optimization purposes.
+ bool IsCommandEvent() const { return m_isCommandEvent; }
+
+ // Determine if this event should be propagating to the parent window.
+ bool ShouldPropagate() const
+ { return m_propagationLevel != wxEVENT_PROPAGATE_NONE; }
+
+ // Stop an event from propagating to its parent window, returns the old
+ // propagation level value
+ int StopPropagation()
+ {
+ int propagationLevel = m_propagationLevel;
+ m_propagationLevel = wxEVENT_PROPAGATE_NONE;
+ return propagationLevel;
+ }
+
+ // Resume the event propagation by restoring the propagation level
+ // (returned by StopPropagation())
+ void ResumePropagation(int propagationLevel)
+ {
+ m_propagationLevel = propagationLevel;
+ }
+
public:
wxObject* m_eventObject;
wxEventType m_eventType;
long m_timeStamp;
int m_id;
wxObject* m_callbackUserData;
+
+protected:
+ // the propagation level: while it is positive, we propagate the event to
+ // the parent window (if any)
+ //
+ // this one doesn't have to be public, we don't have to worry about
+ // backwards compatibility as it is new
+ int m_propagationLevel;
+
+public:
bool m_skipped;
bool m_isCommandEvent;
-
+
private:
+ // it needs to access our m_propagationLevel
+ friend class WXDLLIMPEXP_BASE wxPropagateOnce;
+
DECLARE_ABSTRACT_CLASS(wxEvent)
};
+/*
+ * Helper class to temporarily change an event not to propagate.
+ */
+class WXDLLIMPEXP_BASE wxPropagationDisabler
+{
+public:
+ wxPropagationDisabler(wxEvent& event) : m_event(event)
+ {
+ m_propagationLevelOld = m_event.StopPropagation();
+ }
+
+ ~wxPropagationDisabler()
+ {
+ m_event.ResumePropagation(m_propagationLevelOld);
+ }
+
+private:
+ wxEvent& m_event;
+ int m_propagationLevelOld;
+
+ DECLARE_NO_COPY_CLASS(wxPropagationDisabler)
+};
+
+/*
+ * Another one to temporarily lower propagation level.
+ */
+class WXDLLIMPEXP_BASE wxPropagateOnce
+{
+public:
+ wxPropagateOnce(wxEvent& event) : m_event(event)
+ {
+ wxASSERT_MSG( m_event.m_propagationLevel > 0,
+ _T("shouldn't be used unless ShouldPropagate()!") );
+
+ m_event.m_propagationLevel--;
+ }
+
+ ~wxPropagateOnce()
+ {
+ m_event.m_propagationLevel++;
+ }
+
+private:
+ wxEvent& m_event;
+
+ DECLARE_NO_COPY_CLASS(wxPropagateOnce)
+};
+
#if wxUSE_GUI
+
// Item or menu event class
/*
wxEVT_COMMAND_BUTTON_CLICKED
class WXDLLIMPEXP_CORE wxCommandEvent : public wxEvent
{
-private:
- wxCommandEvent& operator=(const wxCommandEvent& event);
-
public:
wxCommandEvent(wxEventType commandType = wxEVT_NULL, int winid = 0);
bool IsSelection() const { return (m_extraLong != 0); }
void SetExtraLong(long extraLong) { m_extraLong = extraLong; }
- long GetExtraLong() const { return m_extraLong ; }
+ long GetExtraLong() const { return m_extraLong; }
void SetInt(int i) { m_commandInt = i; }
- long GetInt() const { return m_commandInt ; }
+ long GetInt() const { return m_commandInt; }
virtual wxEvent *Clone() const { return new wxCommandEvent(*this); }
wxClientData* m_clientObject; // Arbitrary client object
private:
- DECLARE_DYNAMIC_CLASS(wxCommandEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxCommandEvent)
};
// this class adds a possibility to react (from the user) code to a control
bool m_bAllow;
private:
- DECLARE_DYNAMIC_CLASS(wxNotifyEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxNotifyEvent)
};
// Scroll event class, derived form wxCommandEvent. wxScrollEvents are
wxScrollEvent(wxEventType commandType = wxEVT_NULL,
int winid = 0, int pos = 0, int orient = 0);
- int GetOrientation() const { return (int) m_extraLong ; }
- int GetPosition() const { return m_commandInt ; }
+ int GetOrientation() const { return (int) m_extraLong; }
+ int GetPosition() const { return m_commandInt; }
void SetOrientation(int orient) { m_extraLong = (long) orient; }
void SetPosition(int pos) { m_commandInt = pos; }
virtual wxEvent *Clone() const { return new wxScrollEvent(*this); }
private:
- DECLARE_DYNAMIC_CLASS(wxScrollEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxScrollEvent)
};
// ScrollWin event class, derived fom wxEvent. wxScrollWinEvents
{ m_commandInt = event.m_commandInt;
m_extraLong = event.m_extraLong; }
- int GetOrientation() const { return (int) m_extraLong ; }
- int GetPosition() const { return m_commandInt ; }
+ int GetOrientation() const { return (int) m_extraLong; }
+ int GetPosition() const { return m_commandInt; }
void SetOrientation(int orient) { m_extraLong = (long) orient; }
void SetPosition(int pos) { m_commandInt = pos; }
long m_extraLong;
private:
- DECLARE_DYNAMIC_CLASS(wxScrollWinEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxScrollWinEvent)
};
// Mouse event class
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 ;
+ wxPoint GetLogicalPosition(const wxDC& dc) const;
// Compatibility
#if WXWIN_COMPATIBILITY
wxCursor m_cursor;
private:
- DECLARE_DYNAMIC_CLASS(wxSetCursorEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxSetCursorEvent)
};
// Keyboard input event class
wxRect m_rect; // Used for wxEVT_SIZING
private:
- DECLARE_DYNAMIC_CLASS(wxSizeEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxSizeEvent)
};
// Move event class
wxRect m_rect;
private:
- DECLARE_DYNAMIC_CLASS(wxMoveEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxMoveEvent)
};
// Paint event class
virtual wxEvent *Clone() const { return new wxPaintEvent(*this); }
private:
- DECLARE_DYNAMIC_CLASS(wxPaintEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxPaintEvent)
};
class WXDLLIMPEXP_CORE wxNcPaintEvent : public wxEvent
virtual wxEvent *Clone() const { return new wxNcPaintEvent(*this); }
private:
- DECLARE_DYNAMIC_CLASS(wxNcPaintEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxNcPaintEvent)
};
// Erase background event class
class WXDLLIMPEXP_CORE wxEraseEvent : public wxEvent
{
-private:
- wxEraseEvent& operator=(const wxEraseEvent& event);
-
public:
wxEraseEvent(int Id = 0, wxDC *dc = (wxDC *) NULL)
: wxEvent(Id, wxEVT_ERASE_BACKGROUND),
wxDC *m_dc;
private:
- DECLARE_DYNAMIC_CLASS(wxEraseEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxEraseEvent)
};
// Focus event class
class WXDLLIMPEXP_CORE wxFocusEvent : public wxEvent
{
-private:
- wxFocusEvent& operator=(const wxFocusEvent& event);
-
public:
wxFocusEvent(wxEventType type = wxEVT_NULL, int winid = 0)
: wxEvent(winid, type)
wxWindow *m_win;
private:
- DECLARE_DYNAMIC_CLASS(wxFocusEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxFocusEvent)
};
// wxChildFocusEvent notifies the parent that a child has got the focus: unlike
-// wxFocusEvent it is propgated upwards the window chain
+// wxFocusEvent it is propagated upwards the window chain
class WXDLLIMPEXP_CORE wxChildFocusEvent : public wxCommandEvent
{
public:
virtual wxEvent *Clone() const { return new wxChildFocusEvent(*this); }
private:
- DECLARE_DYNAMIC_CLASS(wxChildFocusEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxChildFocusEvent)
};
// Activate event class
bool m_active;
private:
- DECLARE_DYNAMIC_CLASS(wxActivateEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxActivateEvent)
};
// InitDialog event class
virtual wxEvent *Clone() const { return new wxInitDialogEvent(*this); }
private:
- DECLARE_DYNAMIC_CLASS(wxInitDialogEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxInitDialogEvent)
};
// Miscellaneous menu event class
class WXDLLIMPEXP_CORE wxMenuEvent : public wxEvent
{
public:
- wxMenuEvent(wxEventType type = wxEVT_NULL, int winid = 0)
+ wxMenuEvent(wxEventType type = wxEVT_NULL, int winid = 0, wxMenu* menu = NULL)
: wxEvent(winid, type)
- { m_menuId = winid; }
+ { m_menuId = winid; m_menu = menu; }
wxMenuEvent(const wxMenuEvent & event)
: wxEvent(event)
- { m_menuId = event.m_menuId; }
+ { m_menuId = event.m_menuId; m_menu = event.m_menu; }
// only for wxEVT_MENU_HIGHLIGHT
int GetMenuId() const { return m_menuId; }
// only for wxEVT_MENU_OPEN/CLOSE
bool IsPopup() const { return m_menuId == -1; }
+ // only for wxEVT_MENU_OPEN/CLOSE
+ wxMenu* GetMenu() const { return m_menu; }
+
virtual wxEvent *Clone() const { return new wxMenuEvent(*this); }
private:
- int m_menuId;
+ int m_menuId;
+ wxMenu* m_menu;
- DECLARE_DYNAMIC_CLASS(wxMenuEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxMenuEvent)
};
// Window close or session close event class
#endif
private:
- DECLARE_DYNAMIC_CLASS(wxCloseEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxCloseEvent)
};
bool m_show;
private:
- DECLARE_DYNAMIC_CLASS(wxShowEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxShowEvent)
};
/*
bool m_iconized;
private:
- DECLARE_DYNAMIC_CLASS(wxIconizeEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxIconizeEvent)
};
/*
wxEVT_MAXIMIZE
virtual wxEvent *Clone() const { return new wxMaximizeEvent(*this); }
private:
- DECLARE_DYNAMIC_CLASS(wxMaximizeEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxMaximizeEvent)
};
// Joystick event class
(GetEventType() == wxEVT_JOY_BUTTON_UP)); }
// Was it a move event?
- bool IsMove() const { return (GetEventType() == wxEVT_JOY_MOVE) ; }
+ bool IsMove() const { return (GetEventType() == wxEVT_JOY_MOVE); }
// Was it a zmove event?
- bool IsZMove() const { return (GetEventType() == wxEVT_JOY_ZMOVE) ; }
+ bool IsZMove() const { return (GetEventType() == wxEVT_JOY_ZMOVE); }
// Was it a down event from button 1, 2, 3, 4 or any?
bool ButtonDown(int but = wxJOY_BUTTON_ANY) const
virtual wxEvent *Clone() const { return new wxJoystickEvent(*this); }
private:
- DECLARE_DYNAMIC_CLASS(wxJoystickEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxJoystickEvent)
};
// Drop files event class
class WXDLLIMPEXP_CORE wxDropFilesEvent : public wxEvent
{
-private:
- wxDropFilesEvent& operator=(const wxDropFilesEvent& event);
-
public:
int m_noFiles;
wxPoint m_pos;
virtual wxEvent *Clone() const { return new wxDropFilesEvent(*this); }
private:
- DECLARE_DYNAMIC_CLASS(wxDropFilesEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxDropFilesEvent)
};
// Update UI event
static void SetUpdateInterval(long updateInterval) { sm_updateInterval = updateInterval; }
// Returns the current interval between updates in milliseconds
- static long GetUpdateInterval() { return sm_updateInterval ; }
+ static long GetUpdateInterval() { return sm_updateInterval; }
// Can we update this window?
- static bool CanUpdate(wxWindow* win) ;
+ static bool CanUpdate(wxWindowBase *win);
// Reset the update time to provide a delay until the next
// time we should update
- static void ResetUpdateTime() ;
+ static void ResetUpdateTime();
// Specify how wxWindows will send update events: to
// all windows, or only to those which specify that they
static void SetMode(wxUpdateUIMode mode) { sm_updateMode = mode; }
// Returns the UI update mode
- static wxUpdateUIMode GetMode() { return sm_updateMode ; }
+ static wxUpdateUIMode GetMode() { return sm_updateMode; }
virtual wxEvent *Clone() const { return new wxUpdateUIEvent(*this); }
static wxUpdateUIMode sm_updateMode;
private:
- DECLARE_DYNAMIC_CLASS(wxUpdateUIEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxUpdateUIEvent)
};
/*
virtual wxEvent *Clone() const { return new wxSysColourChangedEvent(*this); }
private:
- DECLARE_DYNAMIC_CLASS(wxSysColourChangedEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxSysColourChangedEvent)
};
/*
class WXDLLIMPEXP_CORE wxMouseCaptureChangedEvent : public wxEvent
{
-private:
- wxMouseCaptureChangedEvent operator=(const wxMouseCaptureChangedEvent& event);
-
public:
wxMouseCaptureChangedEvent(wxWindowID winid = 0, wxWindow* gainedCapture = NULL)
: wxEvent(winid, wxEVT_MOUSE_CAPTURE_CHANGED),
private:
wxWindow* m_gainedCapture;
- DECLARE_DYNAMIC_CLASS(wxMouseCaptureChangedEvent)
+
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxMouseCaptureChangedEvent)
};
/*
class WXDLLIMPEXP_CORE wxDisplayChangedEvent : public wxEvent
{
private:
- DECLARE_DYNAMIC_CLASS(wxDisplayChangedEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxDisplayChangedEvent)
public:
wxDisplayChangedEvent()
class WXDLLIMPEXP_CORE wxPaletteChangedEvent : public wxEvent
{
-private:
- wxPaletteChangedEvent& operator=(const wxPaletteChangedEvent& event);
-
public:
wxPaletteChangedEvent(wxWindowID winid = 0)
: wxEvent(winid, wxEVT_PALETTE_CHANGED),
wxWindow* m_changedWindow;
private:
- DECLARE_DYNAMIC_CLASS(wxPaletteChangedEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxPaletteChangedEvent)
};
/*
bool m_paletteRealized;
private:
- DECLARE_DYNAMIC_CLASS(wxQueryNewPaletteEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxQueryNewPaletteEvent)
};
/*
// NB: don't derive from command event to avoid being propagated to the parent
class WXDLLIMPEXP_CORE wxNavigationKeyEvent : public wxEvent
{
-private:
- wxNavigationKeyEvent& operator=(const wxNavigationKeyEvent& event);
-
public:
wxNavigationKeyEvent()
: wxEvent(0, wxEVT_NAVIGATION_KEY),
wxWindow *m_focus;
private:
- DECLARE_DYNAMIC_CLASS(wxNavigationKeyEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxNavigationKeyEvent)
};
// Window creation/destruction events: the first is sent as soon as window is
virtual wxEvent *Clone() const { return new wxWindowCreateEvent(*this); }
private:
- DECLARE_DYNAMIC_CLASS(wxWindowCreateEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxWindowCreateEvent)
};
class WXDLLIMPEXP_CORE wxWindowDestroyEvent : public wxCommandEvent
virtual wxEvent *Clone() const { return new wxWindowDestroyEvent(*this); }
private:
- DECLARE_DYNAMIC_CLASS(wxWindowDestroyEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxWindowDestroyEvent)
};
// A help event is sent when the user clicks on a window in context-help mode.
wxString m_link;
private:
- DECLARE_DYNAMIC_CLASS(wxHelpEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxHelpEvent)
};
// A Context event is sent when the user right clicks on a window or
wxPoint m_pos;
private:
- DECLARE_DYNAMIC_CLASS(wxContextMenuEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxContextMenuEvent)
};
// Idle event
static void SetMode(wxIdleMode mode) { sm_idleMode = mode; }
// Returns the idle event mode
- static wxIdleMode GetMode() { return sm_idleMode ; }
+ static wxIdleMode GetMode() { return sm_idleMode; }
// Can we send an idle event?
- static bool CanSend(wxWindow* win) ;
+ static bool CanSend(wxWindow* win);
protected:
bool m_requestMore;
static wxIdleMode sm_idleMode;
private:
- DECLARE_DYNAMIC_CLASS(wxIdleEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxIdleEvent)
};
#endif // wxUSE_GUI
// objects will have been initialized (including the event type constants)
// and so it will have the correct value when it is needed
const int& m_eventType;
+
+private:
+ wxEventTableEntry& operator=(const wxEventTableEntry&);
};
class WXDLLIMPEXP_BASE wxEvtHandler;
// EventFunction is always a member of the EventHandler receiving the
// message
wxEvtHandler* m_eventSink;
+
+ DECLARE_NO_COPY_CLASS(wxDynamicEventTableEntry)
};
#endif // !WXWIN_COMPATIBILITY_EVENT_TYPES
const wxEventTableEntry *entries; // bottom of entry array
};
+// ----------------------------------------------------------------------------
+// wxEventHashTable: a helper of wxEvtHandler to speed up wxEventTable lookups.
+// ----------------------------------------------------------------------------
+
+WX_DEFINE_ARRAY_NO_PTR(const wxEventTableEntry*, wxEventTableEntryPointerArray);
+class WXDLLIMPEXP_BASE wxEvtHandler;
+
+class WXDLLIMPEXP_BASE wxEventHashTable
+{
+private:
+ // Internal data structs
+ struct EventTypeTable
+ {
+ wxEventType eventType;
+ wxEventTableEntryPointerArray eventEntryTable;
+ };
+ typedef EventTypeTable* EventTypeTablePointer;
+
+public:
+ // Constructor, needs the event table it needs to hash later on.
+ // Note: hashing of the event table is not done in the constructor as it
+ // can be that the event table is not yet full initialize, the hash
+ // will gets initialized when handling the first event look-up request.
+ wxEventHashTable(const wxEventTable &table);
+ // Destructor.
+ ~wxEventHashTable();
+
+ // Handle the given event, in other words search the event table hash
+ // and call self->ProcessEvent() if a match was found.
+ bool HandleEvent(wxEvent &event, wxEvtHandler *self);
+
+protected:
+ // Init the hash table with the entries of the static event table.
+ void InitHashTable();
+ // Helper funtion of InitHashTable() to insert 1 entry into the hash table.
+ void AddEntry(const wxEventTableEntry &entry);
+ // Allocate and init with null pointers the base hash table.
+ void AllocEventTypeTable(size_t size);
+ // Grow the hash table in size and transfer all items currently
+ // in the table to the correct location in the new table.
+ void GrowEventTypeTable();
+
+protected:
+ const wxEventTable &m_table;
+ bool m_rebuildHash;
+
+ size_t m_size;
+ EventTypeTablePointer *m_eventTypeTable;
+
+ DECLARE_NO_COPY_CLASS(wxEventHashTable)
+};
+
// ----------------------------------------------------------------------------
// wxEvtHandler: the base class for all objects handling wxWindows events
// ----------------------------------------------------------------------------
virtual bool TryParent(wxEvent& event);
- static const wxEventTable sm_eventTable;
-
+ static const wxEventTable sm_eventTable;
virtual const wxEventTable *GetEventTable() const;
+ static wxEventHashTable sm_eventHashTable;
+ virtual wxEventHashTable& GetEventHashTable() const;
+
wxEvtHandler* m_nextHandler;
wxEvtHandler* m_previousHandler;
wxList* m_dynamicEvents;
virtual void *DoGetClientData() const;
private:
- DECLARE_NO_COPY_CLASS(wxEvtHandler)
- DECLARE_DYNAMIC_CLASS(wxEvtHandler)
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxEvtHandler)
};
// Post a message to the given eventhandler which will be processed during the
static const wxEventTableEntry sm_eventTableEntries[]; \
protected: \
static const wxEventTable sm_eventTable; \
- virtual const wxEventTable* GetEventTable() const;
+ virtual const wxEventTable* GetEventTable() const; \
+ static wxEventHashTable sm_eventHashTable; \
+ virtual wxEventHashTable& GetEventHashTable() const;
// N.B.: when building DLL with Borland C++ 5.5 compiler, you must initialize
// sm_eventTable before using it in GetEventTable() or the compiler gives
// E2233 (see http://groups.google.com/groups?selm=397dcc8a%241_2%40dnews)
+
#define BEGIN_EVENT_TABLE(theClass, baseClass) \
const wxEventTable theClass::sm_eventTable = \
{ &baseClass::sm_eventTable, &theClass::sm_eventTableEntries[0] }; \
const wxEventTable *theClass::GetEventTable() const \
{ return &theClass::sm_eventTable; } \
+ wxEventHashTable theClass::sm_eventHashTable(theClass::sm_eventTable); \
+ wxEventHashTable &theClass::GetEventHashTable() const \
+ { return theClass::sm_eventHashTable; } \
const wxEventTableEntry theClass::sm_eventTableEntries[] = { \
#define END_EVENT_TABLE() DECLARE_EVENT_TABLE_ENTRY( wxEVT_NULL, 0, 0, 0, 0 ) };
#endif // wxUSE_GUI
-#endif
- // _WX_EVENTH__
+#endif // _WX_EVENT_H__
+
projects / wxWidgets.git / blobdiff