// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-#ifndef _WX_EVENTH__
-#define _WX_EVENTH__
+#ifndef _WX_EVENT_H__
+#define _WX_EVENT_H__
-#if defined(__GNUG__) && !defined(__APPLE__)
+#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
#pragma interface "event.h"
#endif
#include "wx/thread.h"
+#include "wx/dynarray.h"
+
// ----------------------------------------------------------------------------
// forward declarations
// ----------------------------------------------------------------------------
-class WXDLLEXPORT wxList;
+class WXDLLIMPEXP_BASE wxList;
#if wxUSE_GUI
- class WXDLLEXPORT wxDC;
- class WXDLLEXPORT wxMenu;
- class WXDLLEXPORT wxWindow;
+ class WXDLLIMPEXP_CORE wxDC;
+ class WXDLLIMPEXP_CORE wxMenu;
+ class WXDLLIMPEXP_CORE wxWindow;
+ class WXDLLIMPEXP_CORE wxWindowBase;
#endif // wxUSE_GUI
// ----------------------------------------------------------------------------
#define END_DECLARE_EVENT_TYPES() };
#define DECLARE_EVENT_TYPE(name, value) name = wxEVT_FIRST + value,
#define DECLARE_LOCAL_EVENT_TYPE(name, value) name = wxEVT_USER_FIRST + value,
+#define DECLARE_EXPORTED_EVENT_TYPE(expdecl, name, value) \
+ DECLARE_LOCAL_EVENT_TYPE(name, value)
#define DEFINE_EVENT_TYPE(name)
#define DEFINE_LOCAL_EVENT_TYPE(name)
#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) \
+ extern expdecl const wxEventType name;
#define DECLARE_EVENT_TYPE(name, value) \
- extern const wxEventType WXDLLEXPORT name;
-#define DECLARE_LOCAL_EVENT_TYPE(name, value) extern const wxEventType name;
-#define DECLARE_EXPORTED_LOCAL_EVENT_TYPE(usergoo, name, value) extern const wxEventType usergoo name;
+ DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_CORE, name, value)
+#define DECLARE_LOCAL_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) const wxEventType name = wxNewEventType();
+#define DEFINE_LOCAL_EVENT_TYPE(name) DEFINE_EVENT_TYPE(name)
// generate a new unique event type
-extern WXDLLEXPORT wxEventType wxNewEventType();
+extern WXDLLIMPEXP_BASE wxEventType wxNewEventType();
#endif // WXWIN_COMPATIBILITY_EVENT_TYPES/!WXWIN_COMPATIBILITY_EVENT_TYPES
#else // !WXWIN_COMPATIBILITY_EVENT_TYPES
// it is important to still have these as constants to avoid
// initialization order related problems
- DECLARE_EVENT_TYPE(wxEVT_NULL, 0)
- const wxEventType wxEVT_FIRST = 10000;
- const wxEventType wxEVT_USER_FIRST = wxEVT_FIRST + 2000;
+ DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_BASE, wxEVT_NULL, 0)
+ DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_BASE, wxEVT_FIRST, 10000)
+ DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_BASE, wxEVT_USER_FIRST, wxEVT_FIRST + 2000)
#endif // WXWIN_COMPATIBILITY_EVENT_TYPES/!WXWIN_COMPATIBILITY_EVENT_TYPES
DECLARE_EVENT_TYPE(wxEVT_COMMAND_BUTTON_CLICKED, 1)
DECLARE_EVENT_TYPE(wxEVT_COMMAND_SPINCTRL_UPDATED, 18)
// Sockets and timers send events, too
- DECLARE_EVENT_TYPE(wxEVT_SOCKET, 50)
+ DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_BASE, wxEVT_SOCKET, 50)
DECLARE_EVENT_TYPE(wxEVT_TIMER , 80)
// Mouse event types
DECLARE_EVENT_TYPE(wxEVT_NAVIGATION_KEY, 214)
DECLARE_EVENT_TYPE(wxEVT_KEY_DOWN, 215)
DECLARE_EVENT_TYPE(wxEVT_KEY_UP, 216)
-
+#if wxUSE_HOTKEY
+ DECLARE_EVENT_TYPE(wxEVT_HOTKEY, 217)
+#endif
// Set cursor event
DECLARE_EVENT_TYPE(wxEVT_SET_CURSOR, 230)
DECLARE_EVENT_TYPE(wxEVT_MEASURE_ITEM, 436)
DECLARE_EVENT_TYPE(wxEVT_COMPARE_ITEM, 437)
DECLARE_EVENT_TYPE(wxEVT_INIT_DIALOG, 438)
- DECLARE_EVENT_TYPE(wxEVT_IDLE, 439)
+ DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_BASE, wxEVT_IDLE, 439)
DECLARE_EVENT_TYPE(wxEVT_UPDATE_UI, 440)
DECLARE_EVENT_TYPE(wxEVT_SIZING, 441)
DECLARE_EVENT_TYPE(wxEVT_MOVING, 4442)
//
// still, any new code using it should include wx/textctrl.h explicitly
#if !WXWIN_COMPATIBILITY_EVENT_TYPES
- extern const wxEventType WXDLLEXPORT wxEVT_COMMAND_TEXT_UPDATED;
+ extern const wxEventType WXDLLIMPEXP_CORE wxEVT_COMMAND_TEXT_UPDATED;
#endif
#if WXWIN_COMPATIBILITY
#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.).
*
*/
-class WXDLLEXPORT wxEvent : public wxObject
+class WXDLLIMPEXP_BASE wxEvent : public wxObject
{
private:
wxEvent& operator=(const wxEvent&);
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
wxEVT_COMMAND_TOGGLEBUTTON_CLICKED
*/
-class WXDLLEXPORT wxCommandEvent : public wxEvent
+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
// notification: allow or veto the operation being reported.
-class WXDLLEXPORT wxNotifyEvent : public wxCommandEvent
+class WXDLLIMPEXP_CORE wxNotifyEvent : public wxCommandEvent
{
public:
wxNotifyEvent(wxEventType commandType = wxEVT_NULL, int winid = 0)
bool m_bAllow;
private:
- DECLARE_DYNAMIC_CLASS(wxNotifyEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxNotifyEvent)
};
// Scroll event class, derived form wxCommandEvent. wxScrollEvents are
wxEVT_SCROLL_ENDSCROLL
*/
-class WXDLLEXPORT wxScrollEvent : public wxCommandEvent
+class WXDLLIMPEXP_CORE wxScrollEvent : public wxCommandEvent
{
public:
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
wxEVT_SCROLLWIN_THUMBRELEASE
*/
-class WXDLLEXPORT wxScrollWinEvent : public wxEvent
+class WXDLLIMPEXP_CORE wxScrollWinEvent : public wxEvent
{
public:
wxScrollWinEvent(wxEventType commandType = wxEVT_NULL,
{ 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
wxMOUSE_BTN_RIGHT = 2
};
-class WXDLLEXPORT wxMouseEvent : public wxEvent
+class WXDLLIMPEXP_CORE wxMouseEvent : public wxEvent
{
public:
wxMouseEvent(wxEventType mouseType = wxEVT_NULL);
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
wxEVT_SET_CURSOR
*/
-class WXDLLEXPORT wxSetCursorEvent : public wxEvent
+class WXDLLIMPEXP_CORE wxSetCursorEvent : public wxEvent
{
public:
wxSetCursorEvent(wxCoord x = 0, wxCoord y = 0)
wxCursor m_cursor;
private:
- DECLARE_DYNAMIC_CLASS(wxSetCursorEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxSetCursorEvent)
};
// Keyboard input event class
wxEVT_CHAR_HOOK
wxEVT_KEY_DOWN
wxEVT_KEY_UP
+ wxEVT_HOTKEY
*/
-class WXDLLEXPORT wxKeyEvent : public wxEvent
+class WXDLLIMPEXP_CORE wxKeyEvent : public wxEvent
{
public:
wxKeyEvent(wxEventType keyType = wxEVT_NULL);
wxEVT_SIZE
*/
-class WXDLLEXPORT wxSizeEvent : public wxEvent
+class WXDLLIMPEXP_CORE wxSizeEvent : public wxEvent
{
public:
wxSizeEvent() : wxEvent(0, wxEVT_SIZE)
m_size(event.m_size), m_rect(event.m_rect)
{ }
wxSizeEvent(const wxRect& rect, int id = 0)
- : m_rect(rect), m_size(rect.GetSize())
+ : m_size(rect.GetSize()), m_rect(rect)
{ m_eventType = wxEVT_SIZING; m_id = id; }
wxSize GetSize() const { return m_size; }
wxRect m_rect; // Used for wxEVT_SIZING
private:
- DECLARE_DYNAMIC_CLASS(wxSizeEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxSizeEvent)
};
// Move event class
wxEVT_MOVE
*/
-class WXDLLEXPORT wxMoveEvent : public wxEvent
+class WXDLLIMPEXP_CORE wxMoveEvent : public wxEvent
{
public:
wxMoveEvent()
wxRect m_rect;
private:
- DECLARE_DYNAMIC_CLASS(wxMoveEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxMoveEvent)
};
// Paint event class
#if defined(__WXDEBUG__) && (defined(__WXMSW__) || defined(__WXPM__))
// see comments in src/msw|os2/dcclient.cpp where g_isPainting is defined
- extern WXDLLEXPORT int g_isPainting;
+ extern WXDLLIMPEXP_CORE int g_isPainting;
#endif // debug
-class WXDLLEXPORT wxPaintEvent : public wxEvent
+class WXDLLIMPEXP_CORE wxPaintEvent : public wxEvent
{
public:
wxPaintEvent(int Id = 0)
virtual wxEvent *Clone() const { return new wxPaintEvent(*this); }
private:
- DECLARE_DYNAMIC_CLASS(wxPaintEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxPaintEvent)
};
-class WXDLLEXPORT wxNcPaintEvent : public wxEvent
+class WXDLLIMPEXP_CORE wxNcPaintEvent : public wxEvent
{
public:
wxNcPaintEvent(int winid = 0)
virtual wxEvent *Clone() const { return new wxNcPaintEvent(*this); }
private:
- DECLARE_DYNAMIC_CLASS(wxNcPaintEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxNcPaintEvent)
};
// Erase background event class
wxEVT_ERASE_BACKGROUND
*/
-class WXDLLEXPORT wxEraseEvent : public wxEvent
+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
wxEVT_KILL_FOCUS
*/
-class WXDLLEXPORT wxFocusEvent : public wxEvent
+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
-class WXDLLEXPORT wxChildFocusEvent : public wxCommandEvent
+// wxFocusEvent it is propagated upwards the window chain
+class WXDLLIMPEXP_CORE wxChildFocusEvent : public wxCommandEvent
{
public:
wxChildFocusEvent(wxWindow *win = NULL);
virtual wxEvent *Clone() const { return new wxChildFocusEvent(*this); }
private:
- DECLARE_DYNAMIC_CLASS(wxChildFocusEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxChildFocusEvent)
};
// Activate event class
wxEVT_ACTIVATE_APP
*/
-class WXDLLEXPORT wxActivateEvent : public wxEvent
+class WXDLLIMPEXP_CORE wxActivateEvent : public wxEvent
{
public:
wxActivateEvent(wxEventType type = wxEVT_NULL, bool active = TRUE, int Id = 0)
bool m_active;
private:
- DECLARE_DYNAMIC_CLASS(wxActivateEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxActivateEvent)
};
// InitDialog event class
wxEVT_INIT_DIALOG
*/
-class WXDLLEXPORT wxInitDialogEvent : public wxEvent
+class WXDLLIMPEXP_CORE wxInitDialogEvent : public wxEvent
{
public:
wxInitDialogEvent(int Id = 0)
virtual wxEvent *Clone() const { return new wxInitDialogEvent(*this); }
private:
- DECLARE_DYNAMIC_CLASS(wxInitDialogEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxInitDialogEvent)
};
// Miscellaneous menu event class
wxEVT_MENU_HIGHLIGHT,
*/
-class WXDLLEXPORT wxMenuEvent : public wxEvent
+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
wxEVT_QUERY_END_SESSION
*/
-class WXDLLEXPORT wxCloseEvent : public wxEvent
+class WXDLLIMPEXP_CORE wxCloseEvent : public wxEvent
{
public:
wxCloseEvent(wxEventType type = wxEVT_NULL, int winid = 0)
#endif
private:
- DECLARE_DYNAMIC_CLASS(wxCloseEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxCloseEvent)
};
wxEVT_SHOW
*/
-class WXDLLEXPORT wxShowEvent : public wxEvent
+class WXDLLIMPEXP_CORE wxShowEvent : public wxEvent
{
public:
wxShowEvent(int winid = 0, bool show = FALSE)
bool m_show;
private:
- DECLARE_DYNAMIC_CLASS(wxShowEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxShowEvent)
};
/*
wxEVT_ICONIZE
*/
-class WXDLLEXPORT wxIconizeEvent : public wxEvent
+class WXDLLIMPEXP_CORE wxIconizeEvent : public wxEvent
{
public:
wxIconizeEvent(int winid = 0, bool iconized = TRUE)
bool m_iconized;
private:
- DECLARE_DYNAMIC_CLASS(wxIconizeEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxIconizeEvent)
};
/*
wxEVT_MAXIMIZE
*/
-class WXDLLEXPORT wxMaximizeEvent : public wxEvent
+class WXDLLIMPEXP_CORE wxMaximizeEvent : public wxEvent
{
public:
wxMaximizeEvent(int winid = 0)
virtual wxEvent *Clone() const { return new wxMaximizeEvent(*this); }
private:
- DECLARE_DYNAMIC_CLASS(wxMaximizeEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxMaximizeEvent)
};
// Joystick event class
wxJOY_BUTTON4 = 8
};
-class WXDLLEXPORT wxJoystickEvent : public wxEvent
+class WXDLLIMPEXP_CORE wxJoystickEvent : public wxEvent
{
public:
wxPoint m_pos;
(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
wxEVT_DROP_FILES
*/
-class WXDLLEXPORT wxDropFilesEvent : public wxEvent
+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
wxEVT_UPDATE_UI
*/
-class WXDLLEXPORT wxUpdateUIEvent : public wxCommandEvent
+// Whether to always send update events to windows, or
+// to only send update events to those with the
+// wxWS_EX_PROCESS_UI_UPDATES style.
+
+enum wxUpdateUIMode
+{
+ // Send UI update events to all windows
+ wxUPDATE_UI_PROCESS_ALL,
+
+ // Send UI update events to windows that have
+ // the wxWS_EX_PROCESS_UI_UPDATES flag specified
+ wxUPDATE_UI_PROCESS_SPECIFIED
+};
+
+class WXDLLIMPEXP_CORE wxUpdateUIEvent : public wxCommandEvent
{
public:
wxUpdateUIEvent(wxWindowID commandId = 0)
void Enable(bool enable) { m_enabled = enable; m_setEnabled = TRUE; }
void SetText(const wxString& text) { m_text = text; m_setText = TRUE; }
+ // Sets the interval between updates in milliseconds.
+ // Set to -1 to disable updates, or to 0 to update as frequently as possible.
+ static void SetUpdateInterval(long updateInterval) { sm_updateInterval = updateInterval; }
+
+ // Returns the current interval between updates in milliseconds
+ static long GetUpdateInterval() { return sm_updateInterval; }
+
+ // Can we update this window?
+ static bool CanUpdate(wxWindowBase *win);
+
+ // Reset the update time to provide a delay until the next
+ // time we should update
+ static void ResetUpdateTime();
+
+ // Specify how wxWindows will send update events: to
+ // all windows, or only to those which specify that they
+ // will process the events.
+ static void SetMode(wxUpdateUIMode mode) { sm_updateMode = mode; }
+
+ // Returns the UI update mode
+ static wxUpdateUIMode GetMode() { return sm_updateMode; }
+
virtual wxEvent *Clone() const { return new wxUpdateUIEvent(*this); }
protected:
bool m_setText;
bool m_setChecked;
wxString m_text;
+#if wxUSE_LONGLONG
+ static wxLongLong sm_lastUpdate;
+#endif
+ static long sm_updateInterval;
+ static wxUpdateUIMode sm_updateMode;
private:
- DECLARE_DYNAMIC_CLASS(wxUpdateUIEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxUpdateUIEvent)
};
/*
*/
// TODO: shouldn't all events record the window ID?
-class WXDLLEXPORT wxSysColourChangedEvent : public wxEvent
+class WXDLLIMPEXP_CORE wxSysColourChangedEvent : public wxEvent
{
public:
wxSysColourChangedEvent()
virtual wxEvent *Clone() const { return new wxSysColourChangedEvent(*this); }
private:
- DECLARE_DYNAMIC_CLASS(wxSysColourChangedEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxSysColourChangedEvent)
};
/*
(even if it released the capture itself).
*/
-class WXDLLEXPORT wxMouseCaptureChangedEvent : public wxEvent
+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)
};
/*
wxEVT_DISPLAY_CHANGED
*/
-class WXDLLEXPORT wxDisplayChangedEvent : public wxEvent
+class WXDLLIMPEXP_CORE wxDisplayChangedEvent : public wxEvent
{
private:
- DECLARE_DYNAMIC_CLASS(wxDisplayChangedEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxDisplayChangedEvent)
public:
wxDisplayChangedEvent()
wxEVT_PALETTE_CHANGED
*/
-class WXDLLEXPORT wxPaletteChangedEvent : public wxEvent
+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)
};
/*
Indicates the window is getting keyboard focus and should re-do its palette.
*/
-class WXDLLEXPORT wxQueryNewPaletteEvent : public wxEvent
+class WXDLLIMPEXP_CORE wxQueryNewPaletteEvent : public wxEvent
{
public:
wxQueryNewPaletteEvent(wxWindowID winid = 0)
bool m_paletteRealized;
private:
- DECLARE_DYNAMIC_CLASS(wxQueryNewPaletteEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxQueryNewPaletteEvent)
};
/*
wxEVT_NAVIGATION_KEY
*/
// NB: don't derive from command event to avoid being propagated to the parent
-class WXDLLEXPORT wxNavigationKeyEvent : public wxEvent
+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
wxEVT_DESTROY
*/
-class WXDLLEXPORT wxWindowCreateEvent : public wxCommandEvent
+class WXDLLIMPEXP_CORE wxWindowCreateEvent : public wxCommandEvent
{
public:
wxWindowCreateEvent(wxWindow *win = NULL);
virtual wxEvent *Clone() const { return new wxWindowCreateEvent(*this); }
private:
- DECLARE_DYNAMIC_CLASS(wxWindowCreateEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxWindowCreateEvent)
};
-class WXDLLEXPORT wxWindowDestroyEvent : public wxCommandEvent
+class WXDLLIMPEXP_CORE wxWindowDestroyEvent : public wxCommandEvent
{
public:
wxWindowDestroyEvent(wxWindow *win = NULL);
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.
wxEVT_DETAILED_HELP
*/
-class WXDLLEXPORT wxHelpEvent : public wxCommandEvent
+class WXDLLIMPEXP_CORE wxHelpEvent : public wxCommandEvent
{
public:
wxHelpEvent(wxEventType type = wxEVT_NULL,
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
wxEVT_CONTEXT_MENU
*/
-class WXDLLEXPORT wxContextMenuEvent : public wxCommandEvent
+class WXDLLIMPEXP_CORE wxContextMenuEvent : public wxCommandEvent
{
public:
wxContextMenuEvent(wxEventType type = wxEVT_NULL,
wxPoint m_pos;
private:
- DECLARE_DYNAMIC_CLASS(wxContextMenuEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxContextMenuEvent)
};
// Idle event
wxEVT_IDLE
*/
-class WXDLLEXPORT wxIdleEvent : public wxEvent
+// Whether to always send idle events to windows, or
+// to only send update events to those with the
+// wxWS_EX_PROCESS_IDLE style.
+
+enum wxIdleMode
+{
+ // Send idle events to all windows
+ wxIDLE_PROCESS_ALL,
+
+ // Send idle events to windows that have
+ // the wxWS_EX_PROCESS_IDLE flag specified
+ wxIDLE_PROCESS_SPECIFIED
+};
+
+class WXDLLIMPEXP_CORE wxIdleEvent : public wxEvent
{
public:
wxIdleEvent()
virtual wxEvent *Clone() const { return new wxIdleEvent(*this); }
+ // Specify how wxWindows will send idle events: to
+ // all windows, or only to those which specify that they
+ // will process the events.
+ static void SetMode(wxIdleMode mode) { sm_idleMode = mode; }
+
+ // Returns the idle event mode
+ static wxIdleMode GetMode() { return sm_idleMode; }
+
+ // Can we send an idle event?
+ 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
// we have to keep both versions
#if WXWIN_COMPATIBILITY_EVENT_TYPES
-struct WXDLLEXPORT wxEventTableEntry
+struct WXDLLIMPEXP_BASE wxEventTableEntry
{
// For some reason, this can't be wxEventType, or VC++ complains.
int m_eventType; // main event type
// struct containing the members common to static and dynamic event tables
// entries
-struct WXDLLEXPORT wxEventTableEntryBase
+struct WXDLLIMPEXP_BASE wxEventTableEntryBase
{
private:
wxEventTableEntryBase& operator=(const wxEventTableEntryBase& event);
};
// an entry from a static event table
-struct WXDLLEXPORT wxEventTableEntry : public wxEventTableEntryBase
+struct WXDLLIMPEXP_BASE wxEventTableEntry : public wxEventTableEntryBase
{
wxEventTableEntry(const int& evType, int winid, int idLast,
wxObjectEventFunction fn, wxObject *data)
// 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;
+
// an entry used in dynamic event table managed by wxEvtHandler::Connect()
-struct WXDLLEXPORT wxDynamicEventTableEntry : public wxEventTableEntryBase
+struct WXDLLIMPEXP_BASE wxDynamicEventTableEntry : public wxEventTableEntryBase
{
wxDynamicEventTableEntry(int evType, int winid, int idLast,
- wxObjectEventFunction fn, wxObject *data)
+ wxObjectEventFunction fn, wxObject *data, wxEvtHandler* eventSink)
: wxEventTableEntryBase(winid, idLast, fn, data),
- m_eventType(evType)
+ m_eventType(evType),
+ m_eventSink(eventSink)
{ }
// not a reference here as we can't keep a reference to a temporary int
// created to wrap the constant value typically passed to Connect() - nor
// do we need it
int m_eventType;
+
+ // Pointer to object whose function is fn - so we don't assume the
+ // EventFunction is always a member of the EventHandler receiving the
+ // message
+ wxEvtHandler* m_eventSink;
+
+ DECLARE_NO_COPY_CLASS(wxDynamicEventTableEntry)
};
#endif // !WXWIN_COMPATIBILITY_EVENT_TYPES
// ----------------------------------------------------------------------------
// wxEventTable: an array of event entries terminated with {0, 0, 0, 0, 0}
// ----------------------------------------------------------------------------
-struct WXDLLEXPORT wxEventTable
+
+struct WXDLLIMPEXP_BASE wxEventTable
{
const wxEventTable *baseTable; // base event table (next in chain)
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
// ----------------------------------------------------------------------------
-class WXDLLEXPORT wxEvtHandler : public wxObject
+class WXDLLIMPEXP_BASE wxEvtHandler : public wxObject
{
public:
wxEvtHandler();
// winid and event type
void Connect( int winid, int lastId, int eventType,
wxObjectEventFunction func,
- wxObject *userData = (wxObject *) NULL );
+ wxObject *userData = (wxObject *) NULL,
+ wxEvtHandler *eventSink = (wxEvtHandler *) NULL );
// Convenience function: take just one id
void Connect( int winid, int eventType,
wxObjectEventFunction func,
- wxObject *userData = (wxObject *) NULL )
- { Connect(winid, wxID_ANY, eventType, func, userData); }
+ wxObject *userData = (wxObject *) NULL,
+ wxEvtHandler *eventSink = (wxEvtHandler *) NULL )
+ { Connect(winid, wxID_ANY, eventType, func, userData, eventSink); }
bool Disconnect( int winid, int lastId, wxEventType eventType,
wxObjectEventFunction func = NULL,
- wxObject *userData = (wxObject *) NULL );
+ wxObject *userData = (wxObject *) NULL,
+ wxEvtHandler *eventSink = (wxEvtHandler *) NULL );
// Convenience function: take just one id
bool Disconnect( int winid, wxEventType eventType = wxEVT_NULL,
wxObjectEventFunction func = NULL,
- wxObject *userData = (wxObject *) NULL )
- { return Disconnect(winid, wxID_ANY, eventType, func, userData); }
+ wxObject *userData = (wxObject *) NULL,
+ wxEvtHandler *eventSink = (wxEvtHandler *) NULL )
+ { return Disconnect(winid, wxID_ANY, eventType, func, userData, eventSink); }
+ wxList* GetDynamicEventTable() const { return m_dynamicEvents ; }
// User data can be associated with each wxEvtHandler
void SetClientObject( wxClientData *data ) { DoSetClientObject(data); }
static const wxEventTableEntry sm_eventTableEntries[];
protected:
- static const wxEventTable sm_eventTable;
+ // hooks for wxWindow used by ProcessEvent()
+ // -----------------------------------------
+
+ // this one is called before trying our own event table to allow plugging
+ // in the validators
+#if wxUSE_VALIDATORS
+ virtual bool TryValidator(wxEvent& WXUNUSED(event)) { return false; }
+#endif // wxUSE_VALIDATORS
+
+ // 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);
+
+ 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;
# endif
#endif
- // optimization: instead of using costly IsKindOf() to decide whether we're
- // a window (which is true in 99% of cases), use this flag
- bool m_isWindow;
-
// Is event handler enabled?
bool m_enabled;
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
+// next event loop iteration
+inline void wxPostEvent(wxEvtHandler *dest, wxEvent& event)
+{
+ wxCHECK_RET( dest, wxT("need an object to post event to in wxPostEvent") );
+
+ dest->AddPendingEvent(event);
+}
+
typedef void (wxEvtHandler::*wxEventFunction)(wxEvent&);
#if wxUSE_GUI
typedef void (wxEvtHandler::*wxCommandEventFunction)(wxCommandEvent&);
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::GetEventTable() const \
- { return &theClass::sm_eventTable; } \
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 ) };
#define EVT_CHAR(func) DECLARE_EVENT_TABLE_ENTRY( wxEVT_CHAR, wxID_ANY, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) (wxCharEventFunction) & func, (wxObject *) NULL ),
#define EVT_KEY_DOWN(func) DECLARE_EVENT_TABLE_ENTRY( wxEVT_KEY_DOWN, wxID_ANY, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) (wxCharEventFunction) & func, (wxObject *) NULL ),
#define EVT_KEY_UP(func) DECLARE_EVENT_TABLE_ENTRY( wxEVT_KEY_UP, wxID_ANY, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) (wxCharEventFunction) & func, (wxObject *) NULL ),
+#if wxUSE_HOTKEY
+#define EVT_HOTKEY(id, func) DECLARE_EVENT_TABLE_ENTRY( wxEVT_HOTKEY, id, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) (wxCharEventFunction) & func, (wxObject *) NULL ),
+#endif
#define EVT_CHAR_HOOK(func) DECLARE_EVENT_TABLE_ENTRY( wxEVT_CHAR_HOOK, wxID_ANY, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) (wxCharEventFunction) & func, NULL ),
#define EVT_MENU_OPEN(func) DECLARE_EVENT_TABLE_ENTRY( wxEVT_MENU_OPEN, wxID_ANY, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) (wxMenuEventFunction) & func, (wxObject *) NULL ),
#define EVT_MENU_CLOSE(func) DECLARE_EVENT_TABLE_ENTRY( wxEVT_MENU_CLOSE, wxID_ANY, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) (wxMenuEventFunction) & func, (wxObject *) NULL ),
// for pending event processing - notice that there is intentionally no
// WXDLLEXPORT here
-extern wxList *wxPendingEvents;
+extern WXDLLIMPEXP_BASE wxList *wxPendingEvents;
#if wxUSE_THREADS
- extern wxCriticalSection *wxPendingEventsLocker;
+ extern WXDLLIMPEXP_BASE wxCriticalSection *wxPendingEventsLocker;
#endif
// ----------------------------------------------------------------------------
#endif // wxUSE_GUI
-#endif
- // _WX_EVENTH__
+#endif // _WX_EVENT_H__
+
projects / wxWidgets.git / blobdiff