Explain reasoning behind using wxSIZE_FORCE_EVENT

[wxWidgets.git] / src / common / event.cpp

diff --git a/src/common/event.cpp b/src/common/event.cpp
index b270601e5e0b20d1e01d1b952a6bd2717b82d7e0..85951a1b3eb7c32e2681cd44e117f3c053748a0a 100644 (file)
--- a/src/common/event.cpp
+++ b/src/common/event.cpp
@@ -25,27 +25,33 @@
 #endif
 
 #include "wx/event.h"
 #endif
 
 #include "wx/event.h"

+#include "wx/evtloop.h"

 
 #ifndef WX_PRECOMP
     #include "wx/list.h"
     #include "wx/app.h"
     #include "wx/utils.h"
 
 #ifndef WX_PRECOMP
     #include "wx/list.h"
     #include "wx/app.h"
     #include "wx/utils.h"

+    #include "wx/stopwatch.h"
+    #include "wx/module.h"

 
     #if wxUSE_GUI
 
     #if wxUSE_GUI

+        #include "wx/window.h"

         #include "wx/control.h"
         #include "wx/dc.h"
         #include "wx/control.h"
         #include "wx/dc.h"

+        #include "wx/spinbutt.h"

         #include "wx/textctrl.h"
         #include "wx/textctrl.h"

+        #include "wx/validate.h"

     #endif // wxUSE_GUI
 #endif
 
     #endif // wxUSE_GUI
 #endif
 

-#include "wx/module.h"
+#include "wx/thread.h"

 
 

-#if wxUSE_GUI
-    #include "wx/validate.h"
-#if wxUSE_STOPWATCH
-    #include "wx/stopwatch.h"
-#endif
-#endif // wxUSE_GUI
+#if wxUSE_BASE
+    #include "wx/ptr_scpd.h"
+
+    wxDECLARE_SCOPED_PTR(wxEvent, wxEventPtr)
+    wxDEFINE_SCOPED_PTR(wxEvent, wxEventPtr)
+#endif // wxUSE_BASE

 
 // ----------------------------------------------------------------------------
 // wxWin macros
 
 // ----------------------------------------------------------------------------
 // wxWin macros


@@ -54,10 +60,10 @@
 #if wxUSE_BASE
     IMPLEMENT_DYNAMIC_CLASS(wxEvtHandler, wxObject)
     IMPLEMENT_ABSTRACT_CLASS(wxEvent, wxObject)
 #if wxUSE_BASE
     IMPLEMENT_DYNAMIC_CLASS(wxEvtHandler, wxObject)
     IMPLEMENT_ABSTRACT_CLASS(wxEvent, wxObject)

+    IMPLEMENT_DYNAMIC_CLASS(wxIdleEvent, wxEvent)

 #endif // wxUSE_BASE
 
 #if wxUSE_GUI
 #endif // wxUSE_BASE
 
 #if wxUSE_GUI

-    IMPLEMENT_DYNAMIC_CLASS(wxIdleEvent, wxEvent)

     IMPLEMENT_DYNAMIC_CLASS(wxCommandEvent, wxEvent)
     IMPLEMENT_DYNAMIC_CLASS(wxNotifyEvent, wxCommandEvent)
     IMPLEMENT_DYNAMIC_CLASS(wxScrollEvent, wxCommandEvent)
     IMPLEMENT_DYNAMIC_CLASS(wxCommandEvent, wxEvent)
     IMPLEMENT_DYNAMIC_CLASS(wxNotifyEvent, wxCommandEvent)
     IMPLEMENT_DYNAMIC_CLASS(wxScrollEvent, wxCommandEvent)


@@ -92,6 +98,7 @@
     IMPLEMENT_DYNAMIC_CLASS(wxHelpEvent, wxCommandEvent)
     IMPLEMENT_DYNAMIC_CLASS(wxContextMenuEvent, wxCommandEvent)
     IMPLEMENT_DYNAMIC_CLASS(wxMouseCaptureChangedEvent, wxEvent)
     IMPLEMENT_DYNAMIC_CLASS(wxHelpEvent, wxCommandEvent)
     IMPLEMENT_DYNAMIC_CLASS(wxContextMenuEvent, wxCommandEvent)
     IMPLEMENT_DYNAMIC_CLASS(wxMouseCaptureChangedEvent, wxEvent)

+    IMPLEMENT_DYNAMIC_CLASS(wxMouseCaptureLostEvent, wxEvent)

     IMPLEMENT_DYNAMIC_CLASS(wxClipboardTextEvent, wxCommandEvent)
 #endif // wxUSE_GUI
 
     IMPLEMENT_DYNAMIC_CLASS(wxClipboardTextEvent, wxCommandEvent)
 #endif // wxUSE_GUI
 


@@ -109,40 +116,43 @@ wxEventHashTable &wxEvtHandler::GetEventHashTable() const
 wxEventHashTable wxEvtHandler::sm_eventHashTable(wxEvtHandler::sm_eventTable);
 
 const wxEventTableEntry wxEvtHandler::sm_eventTableEntries[] =
 wxEventHashTable wxEvtHandler::sm_eventHashTable(wxEvtHandler::sm_eventTable);
 
 const wxEventTableEntry wxEvtHandler::sm_eventTableEntries[] =

-    { DECLARE_EVENT_TABLE_ENTRY(wxEVT_NULL, 0, 0, (wxObjectEventFunction)NULL, NULL) };
+    { DECLARE_EVENT_TABLE_TERMINATOR() };

 
 
 
 

-#ifdef __WXDEBUG__
-// Clear up event hash table contents or we can get problems
-// when C++ is cleaning up the static object
+// wxUSE_MEMORY_TRACING considers memory freed from the static objects dtors
+// leaked, so we need to manually clean up all event tables before checking for
+// the memory leaks when using it, however this breaks re-initializing the
+// library (i.e. repeated calls to wxInitialize/wxUninitialize) because the
+// event tables won't be rebuilt the next time, so disable this by default
+#if defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING
+

 class wxEventTableEntryModule: public wxModule
 {
 class wxEventTableEntryModule: public wxModule
 {

-DECLARE_DYNAMIC_CLASS(wxEventTableEntryModule)

 public:
 public:

-    wxEventTableEntryModule() {}
-    bool OnInit() { return true; }
-    void OnExit()
-    {
-        wxEventHashTable::ClearAll();
-    }
+    wxEventTableEntryModule() { }
+    virtual bool OnInit() { return true; }
+    virtual void OnExit() { wxEventHashTable::ClearAll(); }
+
+    DECLARE_DYNAMIC_CLASS(wxEventTableEntryModule)

 };
 };

+

 IMPLEMENT_DYNAMIC_CLASS(wxEventTableEntryModule, wxModule)
 IMPLEMENT_DYNAMIC_CLASS(wxEventTableEntryModule, wxModule)

-#endif
+
+#endif // __WXDEBUG__ && wxUSE_MEMORY_TRACING

 
 // ----------------------------------------------------------------------------
 // global variables
 // ----------------------------------------------------------------------------
 
 
 // ----------------------------------------------------------------------------
 // global variables
 // ----------------------------------------------------------------------------
 

-// To put pending event handlers
-wxList *wxPendingEvents = (wxList *)NULL;
+// List containing event handlers with pending events (each handler can occur
+// at most once here)
+wxList *wxHandlersWithPendingEvents = NULL;

 
 #if wxUSE_THREADS
 
 #if wxUSE_THREADS

-    // protects wxPendingEvents list
-    wxCriticalSection *wxPendingEventsLocker = (wxCriticalSection *)NULL;
+    // protects wxHandlersWithPendingEvents list
+    wxCriticalSection *wxHandlersWithPendingEventsLocker = NULL;

 #endif
 
 #endif
 

-#if !WXWIN_COMPATIBILITY_EVENT_TYPES
-

 // common event types are defined here, other event types are defined by the
 // components which use them
 
 // common event types are defined here, other event types are defined by the
 // components which use them
 


@@ -150,170 +160,168 @@ const wxEventType wxEVT_FIRST = 10000;
 const wxEventType wxEVT_USER_FIRST = wxEVT_FIRST + 2000;
 
 DEFINE_EVENT_TYPE(wxEVT_NULL)
 const wxEventType wxEVT_USER_FIRST = wxEVT_FIRST + 2000;
 
 DEFINE_EVENT_TYPE(wxEVT_NULL)

-DEFINE_EVENT_TYPE(wxEVT_IDLE)
-DEFINE_EVENT_TYPE(wxEVT_SOCKET)
-
-#endif // !WXWIN_COMPATIBILITY_EVENT_TYPES
+wxDEFINE_EVENT( wxEVT_IDLE, wxIdleEvent )

 
 #endif // wxUSE_BASE
 
 #if wxUSE_GUI
 
 
 #endif // wxUSE_BASE
 
 #if wxUSE_GUI
 

-#if !WXWIN_COMPATIBILITY_EVENT_TYPES
-
-DEFINE_EVENT_TYPE(wxEVT_COMMAND_BUTTON_CLICKED)
-DEFINE_EVENT_TYPE(wxEVT_COMMAND_CHECKBOX_CLICKED)
-DEFINE_EVENT_TYPE(wxEVT_COMMAND_CHOICE_SELECTED)
-DEFINE_EVENT_TYPE(wxEVT_COMMAND_LISTBOX_SELECTED)
-DEFINE_EVENT_TYPE(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED)
-DEFINE_EVENT_TYPE(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED)
-DEFINE_EVENT_TYPE(wxEVT_COMMAND_MENU_SELECTED)
-DEFINE_EVENT_TYPE(wxEVT_COMMAND_SLIDER_UPDATED)
-DEFINE_EVENT_TYPE(wxEVT_COMMAND_RADIOBOX_SELECTED)
-DEFINE_EVENT_TYPE(wxEVT_COMMAND_RADIOBUTTON_SELECTED)
-DEFINE_EVENT_TYPE(wxEVT_COMMAND_SCROLLBAR_UPDATED)
-DEFINE_EVENT_TYPE(wxEVT_COMMAND_VLBOX_SELECTED)
-DEFINE_EVENT_TYPE(wxEVT_COMMAND_COMBOBOX_SELECTED)
-DEFINE_EVENT_TYPE(wxEVT_COMMAND_TOOL_RCLICKED)
-DEFINE_EVENT_TYPE(wxEVT_COMMAND_TOOL_ENTER)
-DEFINE_EVENT_TYPE(wxEVT_COMMAND_SPINCTRL_UPDATED)
-
-// Sockets and timers send events, too
-DEFINE_EVENT_TYPE(wxEVT_TIMER)
+wxDEFINE_EVENT( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEvent )
+wxDEFINE_EVENT( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEvent )
+wxDEFINE_EVENT( wxEVT_COMMAND_CHOICE_SELECTED, wxCommandEvent )
+wxDEFINE_EVENT( wxEVT_COMMAND_LISTBOX_SELECTED, wxCommandEvent )
+wxDEFINE_EVENT( wxEVT_COMMAND_LISTBOX_DOUBLECLICKED, wxCommandEvent )
+wxDEFINE_EVENT( wxEVT_COMMAND_CHECKLISTBOX_TOGGLED, wxCommandEvent )
+wxDEFINE_EVENT( wxEVT_COMMAND_MENU_SELECTED, wxCommandEvent )
+wxDEFINE_EVENT( wxEVT_COMMAND_SLIDER_UPDATED, wxCommandEvent )
+wxDEFINE_EVENT( wxEVT_COMMAND_RADIOBOX_SELECTED, wxCommandEvent )
+wxDEFINE_EVENT( wxEVT_COMMAND_RADIOBUTTON_SELECTED, wxCommandEvent )
+wxDEFINE_EVENT( wxEVT_COMMAND_SCROLLBAR_UPDATED, wxCommandEvent )
+wxDEFINE_EVENT( wxEVT_COMMAND_VLBOX_SELECTED, wxCommandEvent )
+wxDEFINE_EVENT( wxEVT_COMMAND_COMBOBOX_SELECTED, wxCommandEvent )
+wxDEFINE_EVENT( wxEVT_COMMAND_TOOL_RCLICKED, wxCommandEvent )
+wxDEFINE_EVENT( wxEVT_COMMAND_TOOL_ENTER, wxCommandEvent )
+wxDEFINE_EVENT( wxEVT_COMMAND_SPINCTRL_UPDATED, wxCommandEvent )
+wxDEFINE_EVENT( wxEVT_COMMAND_SPINCTRLDOUBLE_UPDATED, wxCommandEvent )
+wxDEFINE_EVENT( wxEVT_COMMAND_TOOL_DROPDOWN_CLICKED, wxCommandEvent )

 
 // Mouse event types
 
 // Mouse event types

-DEFINE_EVENT_TYPE(wxEVT_LEFT_DOWN)
-DEFINE_EVENT_TYPE(wxEVT_LEFT_UP)
-DEFINE_EVENT_TYPE(wxEVT_MIDDLE_DOWN)
-DEFINE_EVENT_TYPE(wxEVT_MIDDLE_UP)
-DEFINE_EVENT_TYPE(wxEVT_RIGHT_DOWN)
-DEFINE_EVENT_TYPE(wxEVT_RIGHT_UP)
-DEFINE_EVENT_TYPE(wxEVT_MOTION)
-DEFINE_EVENT_TYPE(wxEVT_ENTER_WINDOW)
-DEFINE_EVENT_TYPE(wxEVT_LEAVE_WINDOW)
-DEFINE_EVENT_TYPE(wxEVT_LEFT_DCLICK)
-DEFINE_EVENT_TYPE(wxEVT_MIDDLE_DCLICK)
-DEFINE_EVENT_TYPE(wxEVT_RIGHT_DCLICK)
-DEFINE_EVENT_TYPE(wxEVT_SET_FOCUS)
-DEFINE_EVENT_TYPE(wxEVT_KILL_FOCUS)
-DEFINE_EVENT_TYPE(wxEVT_CHILD_FOCUS)
-DEFINE_EVENT_TYPE(wxEVT_MOUSEWHEEL)
-
-// Non-client mouse events
-DEFINE_EVENT_TYPE(wxEVT_NC_LEFT_DOWN)
-DEFINE_EVENT_TYPE(wxEVT_NC_LEFT_UP)
-DEFINE_EVENT_TYPE(wxEVT_NC_MIDDLE_DOWN)
-DEFINE_EVENT_TYPE(wxEVT_NC_MIDDLE_UP)
-DEFINE_EVENT_TYPE(wxEVT_NC_RIGHT_DOWN)
-DEFINE_EVENT_TYPE(wxEVT_NC_RIGHT_UP)
-DEFINE_EVENT_TYPE(wxEVT_NC_MOTION)
-DEFINE_EVENT_TYPE(wxEVT_NC_ENTER_WINDOW)
-DEFINE_EVENT_TYPE(wxEVT_NC_LEAVE_WINDOW)
-DEFINE_EVENT_TYPE(wxEVT_NC_LEFT_DCLICK)
-DEFINE_EVENT_TYPE(wxEVT_NC_MIDDLE_DCLICK)
-DEFINE_EVENT_TYPE(wxEVT_NC_RIGHT_DCLICK)
+wxDEFINE_EVENT( wxEVT_LEFT_DOWN, wxMouseEvent )
+wxDEFINE_EVENT( wxEVT_LEFT_UP, wxMouseEvent )
+wxDEFINE_EVENT( wxEVT_MIDDLE_DOWN, wxMouseEvent )
+wxDEFINE_EVENT( wxEVT_MIDDLE_UP, wxMouseEvent )
+wxDEFINE_EVENT( wxEVT_RIGHT_DOWN, wxMouseEvent )
+wxDEFINE_EVENT( wxEVT_RIGHT_UP, wxMouseEvent )
+wxDEFINE_EVENT( wxEVT_MOTION, wxMouseEvent )
+wxDEFINE_EVENT( wxEVT_ENTER_WINDOW, wxMouseEvent )
+wxDEFINE_EVENT( wxEVT_LEAVE_WINDOW, wxMouseEvent )
+wxDEFINE_EVENT( wxEVT_LEFT_DCLICK, wxMouseEvent )
+wxDEFINE_EVENT( wxEVT_MIDDLE_DCLICK, wxMouseEvent )
+wxDEFINE_EVENT( wxEVT_RIGHT_DCLICK, wxMouseEvent )
+wxDEFINE_EVENT( wxEVT_SET_FOCUS, wxFocusEvent )
+wxDEFINE_EVENT( wxEVT_KILL_FOCUS, wxFocusEvent )
+wxDEFINE_EVENT( wxEVT_CHILD_FOCUS, wxChildFocusEvent )
+wxDEFINE_EVENT( wxEVT_MOUSEWHEEL, wxMouseEvent )
+wxDEFINE_EVENT( wxEVT_AUX1_DOWN, wxMouseEvent )
+wxDEFINE_EVENT( wxEVT_AUX1_UP, wxMouseEvent )
+wxDEFINE_EVENT( wxEVT_AUX1_DCLICK, wxMouseEvent )
+wxDEFINE_EVENT( wxEVT_AUX2_DOWN, wxMouseEvent )
+wxDEFINE_EVENT( wxEVT_AUX2_UP, wxMouseEvent )
+wxDEFINE_EVENT( wxEVT_AUX2_DCLICK, wxMouseEvent )

 
 // Character input event type
 
 // Character input event type

-DEFINE_EVENT_TYPE(wxEVT_CHAR)
-DEFINE_EVENT_TYPE(wxEVT_CHAR_HOOK)
-DEFINE_EVENT_TYPE(wxEVT_NAVIGATION_KEY)
-DEFINE_EVENT_TYPE(wxEVT_KEY_DOWN)
-DEFINE_EVENT_TYPE(wxEVT_KEY_UP)
+wxDEFINE_EVENT( wxEVT_CHAR, wxKeyEvent )
+wxDEFINE_EVENT( wxEVT_CHAR_HOOK, wxKeyEvent )
+wxDEFINE_EVENT( wxEVT_NAVIGATION_KEY, wxNavigationKeyEvent )
+wxDEFINE_EVENT( wxEVT_KEY_DOWN, wxKeyEvent )
+wxDEFINE_EVENT( wxEVT_KEY_UP, wxKeyEvent )

 #if wxUSE_HOTKEY
 #if wxUSE_HOTKEY

-DEFINE_EVENT_TYPE(wxEVT_HOTKEY)
+wxDEFINE_EVENT( wxEVT_HOTKEY, wxKeyEvent )

 #endif
 
 // Set cursor event
 #endif
 
 // Set cursor event

-DEFINE_EVENT_TYPE(wxEVT_SET_CURSOR)
+wxDEFINE_EVENT( wxEVT_SET_CURSOR, wxSetCursorEvent )

 
 // wxScrollbar and wxSlider event identifiers
 
 // wxScrollbar and wxSlider event identifiers

-DEFINE_EVENT_TYPE(wxEVT_SCROLL_TOP)
-DEFINE_EVENT_TYPE(wxEVT_SCROLL_BOTTOM)
-DEFINE_EVENT_TYPE(wxEVT_SCROLL_LINEUP)
-DEFINE_EVENT_TYPE(wxEVT_SCROLL_LINEDOWN)
-DEFINE_EVENT_TYPE(wxEVT_SCROLL_PAGEUP)
-DEFINE_EVENT_TYPE(wxEVT_SCROLL_PAGEDOWN)
-DEFINE_EVENT_TYPE(wxEVT_SCROLL_THUMBTRACK)
-DEFINE_EVENT_TYPE(wxEVT_SCROLL_THUMBRELEASE)
-DEFINE_EVENT_TYPE(wxEVT_SCROLL_CHANGED)
+wxDEFINE_EVENT( wxEVT_SCROLL_TOP, wxScrollEvent )
+wxDEFINE_EVENT( wxEVT_SCROLL_BOTTOM, wxScrollEvent )
+wxDEFINE_EVENT( wxEVT_SCROLL_LINEUP, wxScrollEvent )
+wxDEFINE_EVENT( wxEVT_SCROLL_LINEDOWN, wxScrollEvent )
+wxDEFINE_EVENT( wxEVT_SCROLL_PAGEUP, wxScrollEvent )
+wxDEFINE_EVENT( wxEVT_SCROLL_PAGEDOWN, wxScrollEvent )
+wxDEFINE_EVENT( wxEVT_SCROLL_THUMBTRACK, wxScrollEvent )
+wxDEFINE_EVENT( wxEVT_SCROLL_THUMBRELEASE, wxScrollEvent )
+wxDEFINE_EVENT( wxEVT_SCROLL_CHANGED, wxScrollEvent )
+
+// Due to a bug in older wx versions, wxSpinEvents were being sent with type of
+// wxEVT_SCROLL_LINEUP, wxEVT_SCROLL_LINEDOWN and wxEVT_SCROLL_THUMBTRACK. But
+// with the type-safe events in place, these event types are associated with
+// wxScrollEvent. To allow handling of spin events, new event types have been
+// defined in spinbutt.h/spinnbuttcmn.cpp. To maintain backward compatibility
+// the spin event types are being initialized with the scroll event types.
+
+#if wxUSE_SPINBTN
+
+wxDEFINE_EVENT_ALIAS( wxEVT_SPIN_UP,   wxSpinEvent, wxEVT_SCROLL_LINEUP )
+wxDEFINE_EVENT_ALIAS( wxEVT_SPIN_DOWN, wxSpinEvent, wxEVT_SCROLL_LINEDOWN )
+wxDEFINE_EVENT_ALIAS( wxEVT_SPIN,      wxSpinEvent, wxEVT_SCROLL_THUMBTRACK )
+
+#endif // wxUSE_SPINBTN

 
 // Scroll events from wxWindow
 
 // Scroll events from wxWindow

-DEFINE_EVENT_TYPE(wxEVT_SCROLLWIN_TOP)
-DEFINE_EVENT_TYPE(wxEVT_SCROLLWIN_BOTTOM)
-DEFINE_EVENT_TYPE(wxEVT_SCROLLWIN_LINEUP)
-DEFINE_EVENT_TYPE(wxEVT_SCROLLWIN_LINEDOWN)
-DEFINE_EVENT_TYPE(wxEVT_SCROLLWIN_PAGEUP)
-DEFINE_EVENT_TYPE(wxEVT_SCROLLWIN_PAGEDOWN)
-DEFINE_EVENT_TYPE(wxEVT_SCROLLWIN_THUMBTRACK)
-DEFINE_EVENT_TYPE(wxEVT_SCROLLWIN_THUMBRELEASE)
+wxDEFINE_EVENT( wxEVT_SCROLLWIN_TOP, wxScrollWinEvent )
+wxDEFINE_EVENT( wxEVT_SCROLLWIN_BOTTOM, wxScrollWinEvent )
+wxDEFINE_EVENT( wxEVT_SCROLLWIN_LINEUP, wxScrollWinEvent )
+wxDEFINE_EVENT( wxEVT_SCROLLWIN_LINEDOWN, wxScrollWinEvent )
+wxDEFINE_EVENT( wxEVT_SCROLLWIN_PAGEUP, wxScrollWinEvent )
+wxDEFINE_EVENT( wxEVT_SCROLLWIN_PAGEDOWN, wxScrollWinEvent )
+wxDEFINE_EVENT( wxEVT_SCROLLWIN_THUMBTRACK, wxScrollWinEvent )
+wxDEFINE_EVENT( wxEVT_SCROLLWIN_THUMBRELEASE, wxScrollWinEvent )

 
 // System events
 
 // System events

-DEFINE_EVENT_TYPE(wxEVT_SIZE)
-DEFINE_EVENT_TYPE(wxEVT_SIZING)
-DEFINE_EVENT_TYPE(wxEVT_MOVE)
-DEFINE_EVENT_TYPE(wxEVT_MOVING)
-DEFINE_EVENT_TYPE(wxEVT_CLOSE_WINDOW)
-DEFINE_EVENT_TYPE(wxEVT_END_SESSION)
-DEFINE_EVENT_TYPE(wxEVT_QUERY_END_SESSION)
-DEFINE_EVENT_TYPE(wxEVT_HIBERNATE)
-DEFINE_EVENT_TYPE(wxEVT_ACTIVATE_APP)
-DEFINE_EVENT_TYPE(wxEVT_POWER)
-DEFINE_EVENT_TYPE(wxEVT_ACTIVATE)
-DEFINE_EVENT_TYPE(wxEVT_CREATE)
-DEFINE_EVENT_TYPE(wxEVT_DESTROY)
-DEFINE_EVENT_TYPE(wxEVT_SHOW)
-DEFINE_EVENT_TYPE(wxEVT_ICONIZE)
-DEFINE_EVENT_TYPE(wxEVT_MAXIMIZE)
-DEFINE_EVENT_TYPE(wxEVT_MOUSE_CAPTURE_CHANGED)
-DEFINE_EVENT_TYPE(wxEVT_PAINT)
-DEFINE_EVENT_TYPE(wxEVT_ERASE_BACKGROUND)
-DEFINE_EVENT_TYPE(wxEVT_NC_PAINT)
-DEFINE_EVENT_TYPE(wxEVT_PAINT_ICON)
-DEFINE_EVENT_TYPE(wxEVT_MENU_OPEN)
-DEFINE_EVENT_TYPE(wxEVT_MENU_CLOSE)
-DEFINE_EVENT_TYPE(wxEVT_MENU_HIGHLIGHT)
-DEFINE_EVENT_TYPE(wxEVT_CONTEXT_MENU)
-DEFINE_EVENT_TYPE(wxEVT_SYS_COLOUR_CHANGED)
-DEFINE_EVENT_TYPE(wxEVT_DISPLAY_CHANGED)
-DEFINE_EVENT_TYPE(wxEVT_SETTING_CHANGED)
-DEFINE_EVENT_TYPE(wxEVT_QUERY_NEW_PALETTE)
-DEFINE_EVENT_TYPE(wxEVT_PALETTE_CHANGED)
-DEFINE_EVENT_TYPE(wxEVT_JOY_BUTTON_DOWN)
-DEFINE_EVENT_TYPE(wxEVT_JOY_BUTTON_UP)
-DEFINE_EVENT_TYPE(wxEVT_JOY_MOVE)
-DEFINE_EVENT_TYPE(wxEVT_JOY_ZMOVE)
-DEFINE_EVENT_TYPE(wxEVT_DROP_FILES)
-DEFINE_EVENT_TYPE(wxEVT_DRAW_ITEM)
-DEFINE_EVENT_TYPE(wxEVT_MEASURE_ITEM)
-DEFINE_EVENT_TYPE(wxEVT_COMPARE_ITEM)
-DEFINE_EVENT_TYPE(wxEVT_INIT_DIALOG)
-DEFINE_EVENT_TYPE(wxEVT_UPDATE_UI)
+wxDEFINE_EVENT( wxEVT_SIZE, wxSizeEvent )
+wxDEFINE_EVENT( wxEVT_SIZING, wxSizeEvent )
+wxDEFINE_EVENT( wxEVT_MOVE, wxMoveEvent )
+wxDEFINE_EVENT( wxEVT_MOVING, wxMoveEvent )
+wxDEFINE_EVENT( wxEVT_MOVE_START, wxMoveEvent )
+wxDEFINE_EVENT( wxEVT_MOVE_END, wxMoveEvent )
+wxDEFINE_EVENT( wxEVT_CLOSE_WINDOW, wxCloseEvent )
+wxDEFINE_EVENT( wxEVT_END_SESSION, wxCloseEvent )
+wxDEFINE_EVENT( wxEVT_QUERY_END_SESSION, wxCloseEvent )
+wxDEFINE_EVENT( wxEVT_HIBERNATE, wxActivateEvent )
+wxDEFINE_EVENT( wxEVT_ACTIVATE_APP, wxActivateEvent )
+wxDEFINE_EVENT( wxEVT_ACTIVATE, wxActivateEvent )
+wxDEFINE_EVENT( wxEVT_CREATE, wxWindowCreateEvent )
+wxDEFINE_EVENT( wxEVT_DESTROY, wxWindowDestroyEvent )
+wxDEFINE_EVENT( wxEVT_SHOW, wxShowEvent )
+wxDEFINE_EVENT( wxEVT_ICONIZE, wxIconizeEvent )
+wxDEFINE_EVENT( wxEVT_MAXIMIZE, wxMaximizeEvent )
+wxDEFINE_EVENT( wxEVT_MOUSE_CAPTURE_CHANGED, wxMouseCaptureChangedEvent )
+wxDEFINE_EVENT( wxEVT_MOUSE_CAPTURE_LOST, wxMouseCaptureLostEvent )
+wxDEFINE_EVENT( wxEVT_PAINT, wxPaintEvent )
+wxDEFINE_EVENT( wxEVT_ERASE_BACKGROUND, wxEraseEvent )
+wxDEFINE_EVENT( wxEVT_NC_PAINT, wxNcPaintEvent )
+wxDEFINE_EVENT( wxEVT_MENU_OPEN, wxMenuEvent )
+wxDEFINE_EVENT( wxEVT_MENU_CLOSE, wxMenuEvent )
+wxDEFINE_EVENT( wxEVT_MENU_HIGHLIGHT, wxMenuEvent )
+wxDEFINE_EVENT( wxEVT_CONTEXT_MENU, wxContextMenuEvent )
+wxDEFINE_EVENT( wxEVT_SYS_COLOUR_CHANGED, wxSysColourChangedEvent )
+wxDEFINE_EVENT( wxEVT_DISPLAY_CHANGED, wxDisplayChangedEvent )
+wxDEFINE_EVENT( wxEVT_QUERY_NEW_PALETTE, wxQueryNewPaletteEvent )
+wxDEFINE_EVENT( wxEVT_PALETTE_CHANGED, wxPaletteChangedEvent )
+wxDEFINE_EVENT( wxEVT_JOY_BUTTON_DOWN, wxJoystickEvent )
+wxDEFINE_EVENT( wxEVT_JOY_BUTTON_UP, wxJoystickEvent )
+wxDEFINE_EVENT( wxEVT_JOY_MOVE, wxJoystickEvent )
+wxDEFINE_EVENT( wxEVT_JOY_ZMOVE, wxJoystickEvent )
+wxDEFINE_EVENT( wxEVT_DROP_FILES, wxDropFilesEvent )
+wxDEFINE_EVENT( wxEVT_INIT_DIALOG, wxInitDialogEvent )
+wxDEFINE_EVENT( wxEVT_UPDATE_UI, wxUpdateUIEvent )

 
 // Clipboard events
 
 // Clipboard events

-DEFINE_EVENT_TYPE(wxEVT_COMMAND_TEXT_COPY)
-DEFINE_EVENT_TYPE(wxEVT_COMMAND_TEXT_CUT)
-DEFINE_EVENT_TYPE(wxEVT_COMMAND_TEXT_PASTE)
+wxDEFINE_EVENT( wxEVT_COMMAND_TEXT_COPY, wxClipboardTextEvent )
+wxDEFINE_EVENT( wxEVT_COMMAND_TEXT_CUT, wxClipboardTextEvent )
+wxDEFINE_EVENT( wxEVT_COMMAND_TEXT_PASTE, wxClipboardTextEvent )

 
 // Generic command events
 // Note: a click is a higher-level event than button down/up
 
 // Generic command events
 // Note: a click is a higher-level event than button down/up

-DEFINE_EVENT_TYPE(wxEVT_COMMAND_LEFT_CLICK)
-DEFINE_EVENT_TYPE(wxEVT_COMMAND_LEFT_DCLICK)
-DEFINE_EVENT_TYPE(wxEVT_COMMAND_RIGHT_CLICK)
-DEFINE_EVENT_TYPE(wxEVT_COMMAND_RIGHT_DCLICK)
-DEFINE_EVENT_TYPE(wxEVT_COMMAND_SET_FOCUS)
-DEFINE_EVENT_TYPE(wxEVT_COMMAND_KILL_FOCUS)
-DEFINE_EVENT_TYPE(wxEVT_COMMAND_ENTER)
+wxDEFINE_EVENT( wxEVT_COMMAND_LEFT_CLICK, wxCommandEvent )
+wxDEFINE_EVENT( wxEVT_COMMAND_LEFT_DCLICK, wxCommandEvent )
+wxDEFINE_EVENT( wxEVT_COMMAND_RIGHT_CLICK, wxCommandEvent )
+wxDEFINE_EVENT( wxEVT_COMMAND_RIGHT_DCLICK, wxCommandEvent )
+wxDEFINE_EVENT( wxEVT_COMMAND_SET_FOCUS, wxCommandEvent )
+wxDEFINE_EVENT( wxEVT_COMMAND_KILL_FOCUS, wxCommandEvent )
+wxDEFINE_EVENT( wxEVT_COMMAND_ENTER, wxCommandEvent )

 
 // Help events
 
 // Help events

-DEFINE_EVENT_TYPE(wxEVT_HELP)
-DEFINE_EVENT_TYPE(wxEVT_DETAILED_HELP)
-
-#endif // !WXWIN_COMPATIBILITY_EVENT_TYPES
+wxDEFINE_EVENT( wxEVT_HELP, wxHelpEvent )
+wxDEFINE_EVENT( wxEVT_DETAILED_HELP, wxHelpEvent )

 
 #endif // wxUSE_GUI
 
 #if wxUSE_BASE
 
 
 #endif // wxUSE_GUI
 
 #if wxUSE_BASE
 

+wxIdleMode wxIdleEvent::sm_idleMode = wxIDLE_PROCESS_ALL;
+

 // ============================================================================
 // implementation
 // ============================================================================
 // ============================================================================
 // implementation
 // ============================================================================


@@ -329,6 +337,13 @@ int wxNewEventType()
 
     return s_lastUsedEventType++;
 }
 
     return s_lastUsedEventType++;
 }

+// ----------------------------------------------------------------------------
+// wxEventFunctor
+// ----------------------------------------------------------------------------
+
+wxEventFunctor::~wxEventFunctor()
+{
+}

 
 // ----------------------------------------------------------------------------
 // wxEvent
 
 // ----------------------------------------------------------------------------
 // wxEvent


@@ -346,17 +361,18 @@ int wxNewEventType()
 wxEvent::wxEvent(int theId, wxEventType commandType )
 {
     m_eventType = commandType;
 wxEvent::wxEvent(int theId, wxEventType commandType )
 {
     m_eventType = commandType;

-    m_eventObject = (wxObject *) NULL;
+    m_eventObject = NULL;

     m_timeStamp = 0;
     m_id = theId;
     m_skipped = false;
     m_timeStamp = 0;
     m_id = theId;
     m_skipped = false;

-    m_callbackUserData = (wxObject *) NULL;
+    m_callbackUserData = NULL;

     m_isCommandEvent = false;
     m_propagationLevel = wxEVENT_PROPAGATE_NONE;
     m_isCommandEvent = false;
     m_propagationLevel = wxEVENT_PROPAGATE_NONE;

+    m_wasProcessed = false;

 }
 
 }
 

-wxEvent::wxEvent(const wxEvent &src)
-    : wxObject()
+wxEvent::wxEvent(const wxEvent& src)
+    : wxObject(src)

     , m_eventObject(src.m_eventObject)
     , m_eventType(src.m_eventType)
     , m_timeStamp(src.m_timeStamp)
     , m_eventObject(src.m_eventObject)
     , m_eventType(src.m_eventType)
     , m_timeStamp(src.m_timeStamp)


@@ -365,7 +381,26 @@ wxEvent::wxEvent(const wxEvent &src)
     , m_propagationLevel(src.m_propagationLevel)
     , m_skipped(src.m_skipped)
     , m_isCommandEvent(src.m_isCommandEvent)
     , m_propagationLevel(src.m_propagationLevel)
     , m_skipped(src.m_skipped)
     , m_isCommandEvent(src.m_isCommandEvent)

+    , m_wasProcessed(false)
+{
+}
+
+wxEvent& wxEvent::operator=(const wxEvent& src)

 {
 {

+    wxObject::operator=(src);
+
+    m_eventObject = src.m_eventObject;
+    m_eventType = src.m_eventType;
+    m_timeStamp = src.m_timeStamp;
+    m_id = src.m_id;
+    m_callbackUserData = src.m_callbackUserData;
+    m_propagationLevel = src.m_propagationLevel;
+    m_skipped = src.m_skipped;
+    m_isCommandEvent = src.m_isCommandEvent;
+
+    // don't change m_wasProcessed
+
+    return *this;

 }
 
 #endif // wxUSE_BASE
 }
 
 #endif // wxUSE_BASE


@@ -384,12 +419,9 @@ wxEvent::wxEvent(const wxEvent &src)
 
 wxCommandEvent::wxCommandEvent(wxEventType commandType, int theId)
               : wxEvent(theId, commandType)
 
 wxCommandEvent::wxCommandEvent(wxEventType commandType, int theId)
               : wxEvent(theId, commandType)

-#if WXWIN_COMPATIBILITY_2_4
-              , m_commandString(this)
-#endif

 {
 {

-    m_clientData = (char *) NULL;
-    m_clientObject = (wxClientData *) NULL;
+    m_clientData = NULL;
+    m_clientObject = NULL;

     m_extraLong = 0;
     m_commandInt = 0;
     m_isCommandEvent = true;
     m_extraLong = 0;
     m_commandInt = 0;
     m_isCommandEvent = true;


@@ -404,13 +436,15 @@ wxCommandEvent::wxCommandEvent(wxEventType commandType, int theId)
 
 wxString wxCommandEvent::GetString() const
 {
 
 wxString wxCommandEvent::GetString() const
 {

-    if(m_eventType != wxEVT_COMMAND_TEXT_UPDATED || !m_eventObject)
+    if (m_eventType != wxEVT_COMMAND_TEXT_UPDATED || !m_eventObject)
+    {

         return m_cmdString;
         return m_cmdString;

+    }

     else
     {
 #if wxUSE_TEXTCTRL
         wxTextCtrl *txt = wxDynamicCast(m_eventObject, wxTextCtrl);
     else
     {
 #if wxUSE_TEXTCTRL
         wxTextCtrl *txt = wxDynamicCast(m_eventObject, wxTextCtrl);

-        if(txt)
+        if ( txt )

             return txt->GetValue();
         else
 #endif // wxUSE_TEXTCTRL
             return txt->GetValue();
         else
 #endif // wxUSE_TEXTCTRL


@@ -477,25 +511,6 @@ void wxUpdateUIEvent::ResetUpdateTime()
 #endif
 }
 
 #endif
 }
 

-/*
- * Idle events
- */
-
-wxIdleMode wxIdleEvent::sm_idleMode = wxIDLE_PROCESS_ALL;
-
-// Can we send an idle event?
-bool wxIdleEvent::CanSend(wxWindow* win)
-{
-    // Don't update if we've switched global updating off
-    // and this window doesn't support updates.
-    if (win &&
-       (GetMode() == wxIDLE_PROCESS_SPECIFIED &&
-       ((win->GetExtraStyle() & wxWS_EX_PROCESS_IDLE) == 0)))
-        return false;
-
-    return true;
-}
-

 /*
  * Scroll events
  */
 /*
  * Scroll events
  */


@@ -531,23 +546,31 @@ wxScrollWinEvent::wxScrollWinEvent(wxEventType commandType,
 wxMouseEvent::wxMouseEvent(wxEventType commandType)
 {
     m_eventType = commandType;
 wxMouseEvent::wxMouseEvent(wxEventType commandType)
 {
     m_eventType = commandType;

-    m_metaDown = false;
-    m_altDown = false;
-    m_controlDown = false;
-    m_shiftDown = false;
-    m_leftDown = false;
-    m_rightDown = false;
-    m_middleDown = false;
+

     m_x = 0;
     m_y = 0;
     m_x = 0;
     m_y = 0;

+
+    m_leftDown = false;
+    m_middleDown = false;
+    m_rightDown = false;
+    m_aux1Down = false;
+    m_aux2Down = false;
+
+    m_clickCount = -1;
+

     m_wheelRotation = 0;
     m_wheelDelta = 0;
     m_linesPerAction = 0;
     m_wheelRotation = 0;
     m_wheelDelta = 0;
     m_linesPerAction = 0;

+    m_wheelAxis = 0;

 }
 
 void wxMouseEvent::Assign(const wxMouseEvent& event)
 {
 }
 
 void wxMouseEvent::Assign(const wxMouseEvent& event)
 {

-    m_eventType = event.m_eventType;
+    wxEvent::operator=(event);
+
+    // Borland C++ 5.82 doesn't compile an explicit call to an implicitly
+    // defined operator=() so need to do it this way:
+    *static_cast<wxMouseState *>(this) = event;

 
     m_x = event.m_x;
     m_y = event.m_y;
 
     m_x = event.m_x;
     m_y = event.m_y;


@@ -555,15 +578,13 @@ void wxMouseEvent::Assign(const wxMouseEvent& event)
     m_leftDown = event.m_leftDown;
     m_middleDown = event.m_middleDown;
     m_rightDown = event.m_rightDown;
     m_leftDown = event.m_leftDown;
     m_middleDown = event.m_middleDown;
     m_rightDown = event.m_rightDown;

-
-    m_controlDown = event.m_controlDown;
-    m_shiftDown = event.m_shiftDown;
-    m_altDown = event.m_altDown;
-    m_metaDown = event.m_metaDown;
+    m_aux1Down = event.m_aux1Down;
+    m_aux2Down = event.m_aux2Down;

 
     m_wheelRotation = event.m_wheelRotation;
     m_wheelDelta = event.m_wheelDelta;
     m_linesPerAction = event.m_linesPerAction;
 
     m_wheelRotation = event.m_wheelRotation;
     m_wheelDelta = event.m_wheelDelta;
     m_linesPerAction = event.m_linesPerAction;

+    m_wheelAxis = event.m_wheelAxis;

 }
 
 // return true if was a button dclick event
 }
 
 // return true if was a button dclick event


@@ -576,7 +597,8 @@ bool wxMouseEvent::ButtonDClick(int but) const
             // fall through
 
         case wxMOUSE_BTN_ANY:
             // fall through
 
         case wxMOUSE_BTN_ANY:

-            return (LeftDClick() || MiddleDClick() || RightDClick());
+            return (LeftDClick() || MiddleDClick() || RightDClick() ||
+                    Aux1DClick() || Aux2DClick());

 
         case wxMOUSE_BTN_LEFT:
             return LeftDClick();
 
         case wxMOUSE_BTN_LEFT:
             return LeftDClick();


@@ -586,6 +608,12 @@ bool wxMouseEvent::ButtonDClick(int but) const
 
         case wxMOUSE_BTN_RIGHT:
             return RightDClick();
 
         case wxMOUSE_BTN_RIGHT:
             return RightDClick();

+
+        case wxMOUSE_BTN_AUX1:
+            return Aux1DClick();
+
+        case wxMOUSE_BTN_AUX2:
+            return Aux2DClick();

     }
 }
 
     }
 }
 


@@ -599,7 +627,8 @@ bool wxMouseEvent::ButtonDown(int but) const
             // fall through
 
         case wxMOUSE_BTN_ANY:
             // fall through
 
         case wxMOUSE_BTN_ANY:

-            return (LeftDown() || MiddleDown() || RightDown());
+            return (LeftDown() || MiddleDown() || RightDown() ||
+                    Aux1Down() || Aux2Down());

 
         case wxMOUSE_BTN_LEFT:
             return LeftDown();
 
         case wxMOUSE_BTN_LEFT:
             return LeftDown();


@@ -609,6 +638,12 @@ bool wxMouseEvent::ButtonDown(int but) const
 
         case wxMOUSE_BTN_RIGHT:
             return RightDown();
 
         case wxMOUSE_BTN_RIGHT:
             return RightDown();

+
+        case wxMOUSE_BTN_AUX1:
+            return Aux1Down();
+
+        case wxMOUSE_BTN_AUX2:
+            return Aux2Down();

     }
 }
 
     }
 }
 


@@ -622,7 +657,8 @@ bool wxMouseEvent::ButtonUp(int but) const
             // fall through
 
         case wxMOUSE_BTN_ANY:
             // fall through
 
         case wxMOUSE_BTN_ANY:

-            return (LeftUp() || MiddleUp() || RightUp());
+            return (LeftUp() || MiddleUp() || RightUp() ||
+                    Aux1Up() || Aux2Up());

 
         case wxMOUSE_BTN_LEFT:
             return LeftUp();
 
         case wxMOUSE_BTN_LEFT:
             return LeftUp();


@@ -632,6 +668,12 @@ bool wxMouseEvent::ButtonUp(int but) const
 
         case wxMOUSE_BTN_RIGHT:
             return RightUp();
 
         case wxMOUSE_BTN_RIGHT:
             return RightUp();

+
+        case wxMOUSE_BTN_AUX1:
+            return Aux1Up();
+
+        case wxMOUSE_BTN_AUX2:
+            return Aux2Up();

     }
 }
 
     }
 }
 


@@ -657,6 +699,12 @@ bool wxMouseEvent::Button(int but) const
 
         case wxMOUSE_BTN_RIGHT:
             return RightDown() || RightUp() || RightDClick();
 
         case wxMOUSE_BTN_RIGHT:
             return RightDown() || RightUp() || RightDClick();

+
+        case wxMOUSE_BTN_AUX1:
+           return Aux1Down() || Aux1Up() || Aux1DClick();
+
+        case wxMOUSE_BTN_AUX2:
+           return Aux2Down() || Aux2Up() || Aux2DClick();

     }
 }
 
     }
 }
 


@@ -669,7 +717,7 @@ bool wxMouseEvent::ButtonIsDown(int but) const
             // fall through
 
         case wxMOUSE_BTN_ANY:
             // fall through
 
         case wxMOUSE_BTN_ANY:

-            return LeftIsDown() || MiddleIsDown() || RightIsDown();
+            return LeftIsDown() || MiddleIsDown() || RightIsDown() || Aux1Down() || Aux2Down();

 
         case wxMOUSE_BTN_LEFT:
             return LeftIsDown();
 
         case wxMOUSE_BTN_LEFT:
             return LeftIsDown();


@@ -679,12 +727,18 @@ bool wxMouseEvent::ButtonIsDown(int but) const
 
         case wxMOUSE_BTN_RIGHT:
             return RightIsDown();
 
         case wxMOUSE_BTN_RIGHT:
             return RightIsDown();

+
+        case wxMOUSE_BTN_AUX1:
+            return Aux1IsDown();
+
+        case wxMOUSE_BTN_AUX2:
+            return Aux2IsDown();

     }
 }
 
 int wxMouseEvent::GetButton() const
 {
     }
 }
 
 int wxMouseEvent::GetButton() const
 {

-    for ( int i = 1; i <= 3; i++ )
+    for ( int i = 1; i < wxMOUSE_BTN_MAX; i++ )

     {
         if ( Button(i) )
         {
     {
         if ( Button(i) )
         {


@@ -711,10 +765,6 @@ wxPoint wxMouseEvent::GetLogicalPosition(const wxDC& dc) const
 wxKeyEvent::wxKeyEvent(wxEventType type)
 {
     m_eventType = type;
 wxKeyEvent::wxKeyEvent(wxEventType type)
 {
     m_eventType = type;

-    m_shiftDown = false;
-    m_controlDown = false;
-    m_metaDown = false;
-    m_altDown = false;

     m_keyCode = 0;
     m_scanCode = 0;
 #if wxUSE_UNICODE
     m_keyCode = 0;
     m_scanCode = 0;
 #if wxUSE_UNICODE


@@ -723,17 +773,14 @@ wxKeyEvent::wxKeyEvent(wxEventType type)
 }
 
 wxKeyEvent::wxKeyEvent(const wxKeyEvent& evt)
 }
 
 wxKeyEvent::wxKeyEvent(const wxKeyEvent& evt)

-    : wxEvent(evt)
+          : wxEvent(evt),
+            wxKeyboardState(evt)

 {
     m_x = evt.m_x;
     m_y = evt.m_y;
 
     m_keyCode = evt.m_keyCode;
 
 {
     m_x = evt.m_x;
     m_y = evt.m_y;
 
     m_keyCode = evt.m_keyCode;
 

-    m_controlDown = evt.m_controlDown;
-    m_shiftDown = evt.m_shiftDown;
-    m_altDown = evt.m_altDown;
-    m_metaDown = evt.m_metaDown;

     m_scanCode = evt.m_scanCode;
     m_rawCode = evt.m_rawCode;
     m_rawFlags = evt.m_rawFlags;
     m_scanCode = evt.m_scanCode;
     m_rawCode = evt.m_rawCode;
     m_rawFlags = evt.m_rawFlags;


@@ -743,13 +790,6 @@ wxKeyEvent::wxKeyEvent(const wxKeyEvent& evt)
 #endif
 }
 
 #endif
 }
 

-#if WXWIN_COMPATIBILITY_2_6
-long wxKeyEvent::KeyCode() const
-{
-    return m_keyCode;
-}
-#endif // WXWIN_COMPATIBILITY_2_6
-

 wxWindowCreateEvent::wxWindowCreateEvent(wxWindow *win)
 {
     SetEventType(wxEVT_CREATE);
 wxWindowCreateEvent::wxWindowCreateEvent(wxWindow *win)
 {
     SetEventType(wxEVT_CREATE);


@@ -824,25 +864,20 @@ wxEventHashTable::~wxEventHashTable()
 
 void wxEventHashTable::Clear()
 {
 
 void wxEventHashTable::Clear()
 {

-    size_t i;
-    for(i = 0; i < m_size; i++)
+    for ( size_t i = 0; i < m_size; i++ )

     {
         EventTypeTablePointer  eTTnode = m_eventTypeTable[i];
     {
         EventTypeTablePointer  eTTnode = m_eventTypeTable[i];

-        if (eTTnode)
-        {
-            delete eTTnode;
-        }
+        delete eTTnode;

     }
 
     }
 

-    // Necessary in order to not invoke the
-    // overloaded delete operator when statics are cleaned up
-    if (m_eventTypeTable)
-        delete[] m_eventTypeTable;
-
+    delete[] m_eventTypeTable;

     m_eventTypeTable = NULL;
     m_eventTypeTable = NULL;

+

     m_size = 0;
 }
 
     m_size = 0;
 }
 

+#if defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING
+

 // Clear all tables
 void wxEventHashTable::ClearAll()
 {
 // Clear all tables
 void wxEventHashTable::ClearAll()
 {


@@ -854,6 +889,8 @@ void wxEventHashTable::ClearAll()
     }
 }
 
     }
 }
 

+#endif // __WXDEBUG__ && wxUSE_MEMORY_TRACING
+

 bool wxEventHashTable::HandleEvent(wxEvent &event, wxEvtHandler *self)
 {
     if (m_rebuildHash)
 bool wxEventHashTable::HandleEvent(wxEvent &event, wxEvtHandler *self)
 {
     if (m_rebuildHash)


@@ -878,11 +915,9 @@ bool wxEventHashTable::HandleEvent(wxEvent &event, wxEvtHandler *self)
         const size_t count = eventEntryTable.GetCount();
         for (size_t n = 0; n < count; n++)
         {
         const size_t count = eventEntryTable.GetCount();
         for (size_t n = 0; n < count; n++)
         {

-            if ( wxEvtHandler::
-                    ProcessEventIfMatches(*eventEntryTable[n], self, event) )
-            {
+            const wxEventTableEntry& entry = *eventEntryTable[n];
+            if ( wxEvtHandler::ProcessEventIfMatchesId(entry, self, event) )

                 return true;
                 return true;

-            }

         }
     }
 
         }
     }
 


@@ -994,7 +1029,6 @@ void wxEventHashTable::GrowEventTypeTable()
     delete[] oldEventTypeTable;
 }
 
     delete[] oldEventTypeTable;
 }
 

-

 // ----------------------------------------------------------------------------
 // wxEvtHandler
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxEvtHandler
 // ----------------------------------------------------------------------------


@@ -1005,16 +1039,12 @@ void wxEventHashTable::GrowEventTypeTable()
 
 wxEvtHandler::wxEvtHandler()
 {
 
 wxEvtHandler::wxEvtHandler()
 {

-    m_nextHandler = (wxEvtHandler *) NULL;
-    m_previousHandler = (wxEvtHandler *) NULL;
+    m_nextHandler = NULL;
+    m_previousHandler = NULL;

     m_enabled = true;
     m_enabled = true;

-    m_dynamicEvents = (wxList *) NULL;
-    m_pendingEvents = (wxList *) NULL;
-#if wxUSE_THREADS
-#  if !defined(__VISAGECPP__)
-    m_eventsLocker = new wxCriticalSection;
-#  endif
-#endif
+    m_dynamicEvents = NULL;
+    m_pendingEvents = NULL;
+

     // no client data (yet)
     m_clientData = NULL;
     m_clientDataType = wxClientData_None;
     // no client data (yet)
     m_clientData = NULL;
     m_clientDataType = wxClientData_None;


@@ -1022,27 +1052,32 @@ wxEvtHandler::wxEvtHandler()
 
 wxEvtHandler::~wxEvtHandler()
 {
 
 wxEvtHandler::~wxEvtHandler()
 {

-    // Takes itself out of the list of handlers
-    if (m_previousHandler)
-        m_previousHandler->m_nextHandler = m_nextHandler;
-
-    if (m_nextHandler)
-        m_nextHandler->m_previousHandler = m_previousHandler;
+    Unlink();

 
     if (m_dynamicEvents)
     {
 
     if (m_dynamicEvents)
     {

-        wxList::iterator it = m_dynamicEvents->begin(),
-                         en = m_dynamicEvents->end();
-        for (;it != en; ++it)
+        for ( wxList::iterator it = m_dynamicEvents->begin(),
+                               end = m_dynamicEvents->end();
+              it != end;
+              ++it )

         {
         {

-#if WXWIN_COMPATIBILITY_EVENT_TYPES
-            wxEventTableEntry *entry = (wxEventTableEntry*)*it;
-#else // !WXWIN_COMPATIBILITY_EVENT_TYPES

             wxDynamicEventTableEntry *entry = (wxDynamicEventTableEntry*)*it;
             wxDynamicEventTableEntry *entry = (wxDynamicEventTableEntry*)*it;

-#endif // WXWIN_COMPATIBILITY_EVENT_TYPES/!WXWIN_COMPATIBILITY_EVENT_TYPES

 
 

-            if (entry->m_callbackUserData)
-                delete entry->m_callbackUserData;
+            // Remove ourselves from sink destructor notifications
+            // (this has usually been done, in wxTrackable destructor)
+            wxEvtHandler *eventSink = entry->m_fn->GetHandler();
+            if ( eventSink )
+            {
+                wxEventConnectionRef * const
+                    evtConnRef = FindRefInTrackerList(eventSink);
+                if ( evtConnRef )
+                {
+                    eventSink->RemoveNode(evtConnRef);
+                    delete evtConnRef;
+                }
+            }
+
+            delete entry->m_callbackUserData;

             delete entry;
         }
         delete m_dynamicEvents;
             delete entry;
         }
         delete m_dynamicEvents;


@@ -1052,31 +1087,56 @@ wxEvtHandler::~wxEvtHandler()
         m_pendingEvents->DeleteContents(true);
     delete m_pendingEvents;
 
         m_pendingEvents->DeleteContents(true);
     delete m_pendingEvents;
 

-#if wxUSE_THREADS
-#  if !defined(__VISAGECPP__)
-    delete m_eventsLocker;
-#  endif
-
-    // Remove us from wxPendingEvents if necessary.
-    if(wxPendingEventsLocker)
-        wxENTER_CRIT_SECT(*wxPendingEventsLocker);
-    if ( wxPendingEvents )
+    // Remove us from wxHandlersWithPendingEvents if necessary.
+    if ( wxHandlersWithPendingEvents )

     {
     {

-        // Delete all occurences of this from the list of pending events
-        while (wxPendingEvents->DeleteObject(this)) { } // Do nothing
-    }
-    if(wxPendingEventsLocker)
-        wxLEAVE_CRIT_SECT(*wxPendingEventsLocker);
+#if wxUSE_THREADS
+        if (wxHandlersWithPendingEventsLocker)
+            wxENTER_CRIT_SECT(*wxHandlersWithPendingEventsLocker);

 #endif
 
 #endif
 

+        if ( wxHandlersWithPendingEvents->DeleteObject(this) )
+        {
+            // check that we were present only once in the list
+            wxASSERT_MSG( !wxHandlersWithPendingEvents->Find(this),
+                          "Handler occurs twice in wxHandlersWithPendingEvents list" );
+        }
+        //else: we weren't in this list at all, it's ok
+
+#if wxUSE_THREADS
+        if (wxHandlersWithPendingEventsLocker)
+            wxLEAVE_CRIT_SECT(*wxHandlersWithPendingEventsLocker);
+#endif
+    }
+

     // we only delete object data, not untyped
     if ( m_clientDataType == wxClientData_Object )
         delete m_clientObject;
 }
 
     // we only delete object data, not untyped
     if ( m_clientDataType == wxClientData_Object )
         delete m_clientObject;
 }
 

+void wxEvtHandler::Unlink()
+{
+    // this event handler must take itself out of the chain of handlers:
+
+    if (m_previousHandler)
+        m_previousHandler->SetNextHandler(m_nextHandler);
+
+    if (m_nextHandler)
+        m_nextHandler->SetPreviousHandler(m_previousHandler);
+
+    m_nextHandler = NULL;
+    m_previousHandler = NULL;
+}
+
+bool wxEvtHandler::IsUnlinked() const
+{
+    return m_previousHandler == NULL &&
+           m_nextHandler == NULL;
+}
+

 #if wxUSE_THREADS
 
 #if wxUSE_THREADS
 

-bool wxEvtHandler::ProcessThreadEvent(wxEvent& event)
+bool wxEvtHandler::ProcessThreadEvent(const wxEvent& event)

 {
     // check that we are really in a child thread
     wxASSERT_MSG( !wxThread::IsMain(),
 {
     // check that we are really in a child thread
     wxASSERT_MSG( !wxThread::IsMain(),


@@ -1087,46 +1147,39 @@ bool wxEvtHandler::ProcessThreadEvent(wxEvent& event)
     return true;
 }
 
     return true;
 }
 

-void wxEvtHandler::ClearEventLocker()
-{
-#if !defined(__VISAGECPP__)
-    delete m_eventsLocker;
-    m_eventsLocker = NULL;
-#endif
-}
-

 #endif // wxUSE_THREADS
 
 #endif // wxUSE_THREADS
 

-void wxEvtHandler::AddPendingEvent(wxEvent& event)
+void wxEvtHandler::QueueEvent(wxEvent *event)

 {
 {

-    // 1) Add event to list of pending events of this event handler
-
-    wxEvent *eventCopy = event.Clone();
-
-    // we must be able to copy the events here so the event class must
-    // implement Clone() properly instead of just providing a NULL stab for it
-    wxCHECK_RET( eventCopy,
-                 _T("events of this type aren't supposed to be posted") );
+    wxCHECK_RET( event, "NULL event can't be posted" );

 
 

-    wxENTER_CRIT_SECT( Lock() );
+    // 1) Add this event to our list of pending events
+    wxENTER_CRIT_SECT( m_pendingEventsLock );

 
     if ( !m_pendingEvents )
       m_pendingEvents = new wxList;
 
 
     if ( !m_pendingEvents )
       m_pendingEvents = new wxList;
 

-    m_pendingEvents->Append(eventCopy);
-
-    wxLEAVE_CRIT_SECT( Lock() );
+    m_pendingEvents->Append(event);

 
     // 2) Add this event handler to list of event handlers that
     //    have pending events.
 
 
     // 2) Add this event handler to list of event handlers that
     //    have pending events.
 

-    wxENTER_CRIT_SECT(*wxPendingEventsLocker);
+    wxENTER_CRIT_SECT(*wxHandlersWithPendingEventsLocker);
+
+    if ( !wxHandlersWithPendingEvents )
+        wxHandlersWithPendingEvents = new wxList;
+    if ( !wxHandlersWithPendingEvents->Find(this) )
+        wxHandlersWithPendingEvents->Append(this);

 
 

-    if ( !wxPendingEvents )
-        wxPendingEvents = new wxList;
-    wxPendingEvents->Append(this);
+    wxLEAVE_CRIT_SECT(*wxHandlersWithPendingEventsLocker);

 
 

-    wxLEAVE_CRIT_SECT(*wxPendingEventsLocker);
+    // only release m_pendingEventsLock now because otherwise there is a race
+    // condition as described in the ticket #9093: we could process the event
+    // just added to m_pendingEvents in our ProcessPendingEvents() below before
+    // we had time to append this pointer to wxHandlersWithPendingEvents list; thus
+    // breaking the invariant that a handler should be in the list iff it has
+    // any pending events to process
+    wxLEAVE_CRIT_SECT( m_pendingEventsLock );

 
     // 3) Inform the system that new pending events are somewhere,
     //    and that these should be processed in idle time.
 
     // 3) Inform the system that new pending events are somewhere,
     //    and that these should be processed in idle time.


@@ -1135,50 +1188,52 @@ void wxEvtHandler::AddPendingEvent(wxEvent& event)
 
 void wxEvtHandler::ProcessPendingEvents()
 {
 
 void wxEvtHandler::ProcessPendingEvents()
 {

-    // this method is only called by wxApp if this handler does have pending
-    // events
-    wxCHECK_RET( m_pendingEvents,
-                 wxT("Please call wxApp::ProcessPendingEvents() instead") );
-
-    wxENTER_CRIT_SECT( Lock() );
-
-    // we leave the loop once we have processed all events that were present at
-    // the start of ProcessPendingEvents because otherwise we could get into
-    // infinite loop if the pending event handler execution resulted in another
-    // event being posted
-    size_t n = m_pendingEvents->size();
-    for ( wxList::compatibility_iterator node = m_pendingEvents->GetFirst();
-          node;
-          node = m_pendingEvents->GetFirst() )
-    {
-        wxEvent *event = (wxEvent *)node->GetData();
-
-        // It's importan we remove event from list before processing it.
-        // Else a nested event loop, for example from a modal dialog, might
-        // process the same event again.
-        m_pendingEvents->Erase(node);
+    wxENTER_CRIT_SECT( m_pendingEventsLock );

 
 

-        wxLEAVE_CRIT_SECT( Lock() );
+    // this method is only called by wxApp if this handler does have
+    // pending events
+    wxCHECK_RET( m_pendingEvents && !m_pendingEvents->IsEmpty(),
+                 "should have pending events if called" );

 
 

-        ProcessEvent(*event);
-        delete event;
+    wxList::compatibility_iterator node = m_pendingEvents->GetFirst();
+    wxEventPtr event(static_cast<wxEvent *>(node->GetData()));

 
 

-        wxENTER_CRIT_SECT( Lock() );
+    // it's important we remove event from list before processing it, else a
+    // nested event loop, for example from a modal dialog, might process the
+    // same event again.
+    m_pendingEvents->Erase(node);

 
 

-        if ( --n == 0 )
-            break;
+    // if there are no more pending events left, we don't need to stay in this
+    // list
+    if ( m_pendingEvents->IsEmpty() )
+    {
+#if wxUSE_THREADS
+        if (wxHandlersWithPendingEventsLocker)
+            wxENTER_CRIT_SECT(*wxHandlersWithPendingEventsLocker);
+#endif
+        wxHandlersWithPendingEvents->DeleteObject(this);
+#if wxUSE_THREADS
+        if (wxHandlersWithPendingEventsLocker)
+            wxLEAVE_CRIT_SECT(*wxHandlersWithPendingEventsLocker);
+#endif

     }
 
     }
 

-    wxLEAVE_CRIT_SECT( Lock() );
+    wxLEAVE_CRIT_SECT( m_pendingEventsLock );
+
+    ProcessEvent(*event);
+
+    // careful: this object could have been deleted by the event handler
+    // executed by the above ProcessEvent() call, so we can't access any fields
+    // of this object any more

 }
 
 /*
  * Event table stuff
  */
 /* static */ bool
 }
 
 /*
  * Event table stuff
  */
 /* static */ bool

-wxEvtHandler::ProcessEventIfMatches(const wxEventTableEntryBase& entry,
-                                    wxEvtHandler *handler,
-                                    wxEvent& event)
+wxEvtHandler::ProcessEventIfMatchesId(const wxEventTableEntryBase& entry,
+                                      wxEvtHandler *handler,
+                                      wxEvent& event)

 {
     int tableId1 = entry.m_id,
         tableId2 = entry.m_lastId;
 {
     int tableId1 = entry.m_id,
         tableId2 = entry.m_lastId;


@@ -1201,13 +1256,12 @@ wxEvtHandler::ProcessEventIfMatches(const wxEventTableEntryBase& entry,
             // call the handler via wxApp method which allows the user to catch
             // any exceptions which may be thrown by any handler in the program
             // in one place
             // call the handler via wxApp method which allows the user to catch
             // any exceptions which may be thrown by any handler in the program
             // in one place

-            wxTheApp->HandleEvent(handler, (wxEventFunction)entry.m_fn, event);
+            wxTheApp->CallEventHandler(handler, *entry.m_fn, event);

         }
         else
 #endif // wxUSE_EXCEPTIONS
         {
         }
         else
 #endif // wxUSE_EXCEPTIONS
         {

-            // no need for an extra virtual function call
-            (handler->*((wxEventFunction) (entry.m_fn)))(event);
+            (*entry.m_fn)(handler, event);

         }
 
         if (!event.GetSkipped())
         }
 
         if (!event.GetSkipped())


@@ -1219,6 +1273,13 @@ wxEvtHandler::ProcessEventIfMatches(const wxEventTableEntryBase& entry,
 
 bool wxEvtHandler::TryParent(wxEvent& event)
 {
 
 bool wxEvtHandler::TryParent(wxEvent& event)
 {

+    if ( GetNextHandler() )
+    {
+        // the next handler will pass it to wxTheApp if it doesn't process it,
+        // so return from here to avoid doing it again
+        return GetNextHandler()->TryParent(event);
+    }
+

     if ( wxTheApp && (this != wxTheApp) )
     {
         // Special case: don't pass wxEVT_IDLE to wxApp, since it'll always
     if ( wxTheApp && (this != wxTheApp) )
     {
         // Special case: don't pass wxEVT_IDLE to wxApp, since it'll always


@@ -1237,46 +1298,97 @@ bool wxEvtHandler::TryParent(wxEvent& event)
 bool wxEvtHandler::ProcessEvent(wxEvent& event)
 {
     // allow the application to hook into event processing
 bool wxEvtHandler::ProcessEvent(wxEvent& event)
 {
     // allow the application to hook into event processing

-    if ( wxTheApp )
+    //
+    // note that we should only do it if we're the first event handler called
+    // to avoid calling FilterEvent() multiple times as the event goes through
+    // the event handler chain and possibly upwards the window hierarchy
+    if ( !event.WasProcessed() )

     {
     {

-        int rc = wxTheApp->FilterEvent(event);
-        if ( rc != -1 )
+        if ( wxTheApp )

         {
         {

-            wxASSERT_MSG( rc == 1 || rc == 0,
-                          _T("unexpected wxApp::FilterEvent return value") );
+            int rc = wxTheApp->FilterEvent(event);
+            if ( rc != -1 )
+            {
+                wxASSERT_MSG( rc == 1 || rc == 0,
+                              "unexpected wxApp::FilterEvent return value" );

 
 

-            return rc != 0;
+                return rc != 0;
+            }
+            //else: proceed normally

         }
         }

-        //else: proceed normally

     }
 
     }
 

-    // An event handler can be enabled or disabled
-    if ( GetEvtHandlerEnabled() )
-    {
-        // if we have a validator, it has higher priority than our own event
-        // table
-        if ( TryValidator(event) )
-            return true;
+    if ( ProcessEventHere(event) )
+        return true;

 
 

-        // Handle per-instance dynamic event tables first
-        if ( m_dynamicEvents && SearchDynamicEventTable(event) )
-            return true;
+    // pass the event to the next handler, notice that we shouldn't call
+    // TryParent() even if it doesn't handle the event as the last handler in
+    // the chain will do it
+    if ( GetNextHandler() )
+        return GetNextHandler()->ProcessEvent(event);

 
 

-        // Then static per-class event tables
-        if ( GetEventHashTable().HandleEvent(event, this) )
-            return true;
-    }
+    // propagate the event upwards the window chain and/or to the application
+    // object if it wasn't processed at this level
+    return TryParent(event);
+}

 
 

-    // Try going down the event handler chain
-    if ( GetNextHandler() )
+bool wxEvtHandler::ProcessEventHere(wxEvent& event)
+{
+    // If the event handler is disabled it doesn't process any events
+    if ( !GetEvtHandlerEnabled() )
+        return false;
+
+    // If we have a validator, it has higher priority than our own event
+    // handlers
+    if ( TryValidator(event) )
+        return true;
+
+    // Handle per-instance dynamic event tables first
+    if ( m_dynamicEvents && SearchDynamicEventTable(event) )
+        return true;
+
+    // Then static per-class event tables
+    if ( GetEventHashTable().HandleEvent(event, this) )
+        return true;
+
+    // We don't have a handler for this event.
+    return false;
+}
+
+bool wxEvtHandler::SafelyProcessEvent(wxEvent& event)
+{
+#if wxUSE_EXCEPTIONS
+    try

     {
     {

-        if ( GetNextHandler()->ProcessEvent(event) )
-            return true;
+#endif
+        return ProcessEvent(event);
+#if wxUSE_EXCEPTIONS

     }
     }

+    catch ( ... )
+    {
+        wxEventLoopBase *loop = wxEventLoopBase::GetActive();
+        try
+        {
+            if ( !wxTheApp || !wxTheApp->OnExceptionInMainLoop() )
+            {
+                if ( loop )
+                    loop->Exit();
+            }
+            //else: continue running current event loop

 
 

-    // Finally propagate the event upwards the window chain and/or to the
-    // application object as necessary
-    return TryParent(event);
+            return false;
+        }
+        catch ( ... )
+        {
+            // OnExceptionInMainLoop() threw, possibly rethrowing the same
+            // exception again: very good, but we still need Exit() to
+            // be called
+            if ( loop )
+                loop->Exit();
+            throw;
+        }
+    }
+#endif // wxUSE_EXCEPTIONS

 }
 
 
 }
 
 


@@ -1288,7 +1400,7 @@ bool wxEvtHandler::SearchEventTable(wxEventTable& table, wxEvent& event)
         const wxEventTableEntry& entry = table.entries[i];
         if ( eventType == entry.m_eventType )
         {
         const wxEventTableEntry& entry = table.entries[i];
         if ( eventType == entry.m_eventType )
         {

-            if ( ProcessEventIfMatches(entry, this, event) )
+            if ( ProcessEventIfMatchesId(entry, this, event) )

                 return true;
         }
     }
                 return true;
         }
     }


@@ -1296,57 +1408,63 @@ bool wxEvtHandler::SearchEventTable(wxEventTable& table, wxEvent& event)
     return false;
 }
 
     return false;
 }
 

-void wxEvtHandler::Connect( int id, int lastId,
-                            int eventType,
-                            wxObjectEventFunction func,
-                            wxObject *userData,
-                            wxEvtHandler* eventSink )
+void wxEvtHandler::Subscribe( int id, int lastId,
+                            wxEventType eventType,
+                            wxEventFunctor *func,
+                            wxObject *userData )

 {
 {

-#if WXWIN_COMPATIBILITY_EVENT_TYPES
-    wxEventTableEntry *entry = new wxEventTableEntry;
-    entry->m_eventType = eventType;
-    entry->m_id = id;
-    entry->m_lastId = lastId;
-    entry->m_fn = func;
-    entry->m_callbackUserData = userData;
-#else // !WXWIN_COMPATIBILITY_EVENT_TYPES

     wxDynamicEventTableEntry *entry =
     wxDynamicEventTableEntry *entry =

-        new wxDynamicEventTableEntry(eventType, id, lastId, func, userData, eventSink);
-#endif // WXWIN_COMPATIBILITY_EVENT_TYPES/!WXWIN_COMPATIBILITY_EVENT_TYPES
+        new wxDynamicEventTableEntry(eventType, id, lastId, func, userData);

 
     if (!m_dynamicEvents)
         m_dynamicEvents = new wxList;
 
     // Insert at the front of the list so most recent additions are found first
     m_dynamicEvents->Insert( (wxObject*) entry );
 
     if (!m_dynamicEvents)
         m_dynamicEvents = new wxList;
 
     // Insert at the front of the list so most recent additions are found first
     m_dynamicEvents->Insert( (wxObject*) entry );

+
+    // Make sure we get to know when a sink is destroyed
+    wxEvtHandler *eventSink = func->GetHandler();
+    if ( eventSink && eventSink != this )
+    {
+        wxEventConnectionRef *evtConnRef = FindRefInTrackerList(eventSink);
+        if ( evtConnRef )
+            evtConnRef->IncRef( );
+        else
+            new wxEventConnectionRef(this, eventSink);
+    }

 }
 
 }
 

-bool wxEvtHandler::Disconnect( int id, int lastId, wxEventType eventType,
-                  wxObjectEventFunction func,
-                  wxObject *userData,
-                  wxEvtHandler* eventSink )
+bool
+wxEvtHandler::Unsubscribe(int id,
+                          int lastId,
+                          wxEventType eventType,
+                          const wxEventFunctor& func,
+                          wxObject *userData)

 {
     if (!m_dynamicEvents)
         return false;
 
 {
     if (!m_dynamicEvents)
         return false;
 

+    // Remove connection from tracker node (wxEventConnectionRef)
+    wxEvtHandler *eventSink = func.GetHandler();
+    if ( eventSink && eventSink != this )
+    {
+        wxEventConnectionRef *evtConnRef = FindRefInTrackerList(eventSink);
+        if ( evtConnRef )
+            evtConnRef->DecRef();
+    }
+

     wxList::compatibility_iterator node = m_dynamicEvents->GetFirst();
     while (node)
     {
     wxList::compatibility_iterator node = m_dynamicEvents->GetFirst();
     while (node)
     {

-#if WXWIN_COMPATIBILITY_EVENT_TYPES
-            wxEventTableEntry *entry = (wxEventTableEntry*)node->GetData();
-#else // !WXWIN_COMPATIBILITY_EVENT_TYPES
-            wxDynamicEventTableEntry *entry = (wxDynamicEventTableEntry*)node->GetData();
-#endif // WXWIN_COMPATIBILITY_EVENT_TYPES/!WXWIN_COMPATIBILITY_EVENT_TYPES
+        wxDynamicEventTableEntry *entry = (wxDynamicEventTableEntry*)node->GetData();

 
         if ((entry->m_id == id) &&
             ((entry->m_lastId == lastId) || (lastId == wxID_ANY)) &&
             ((entry->m_eventType == eventType) || (eventType == wxEVT_NULL)) &&
 
         if ((entry->m_id == id) &&
             ((entry->m_lastId == lastId) || (lastId == wxID_ANY)) &&
             ((entry->m_eventType == eventType) || (eventType == wxEVT_NULL)) &&

-            ((entry->m_fn == func) || (func == (wxObjectEventFunction)NULL)) &&
-            ((entry->m_eventSink == eventSink) || (eventSink == (wxEvtHandler*)NULL)) &&
-            ((entry->m_callbackUserData == userData) || (userData == (wxObject*)NULL)))
+            entry->m_fn->Matches(func) &&
+            ((entry->m_callbackUserData == userData) || !userData))

         {
         {

-            if (entry->m_callbackUserData)
-                delete entry->m_callbackUserData;
+            delete entry->m_callbackUserData;

             m_dynamicEvents->Erase( node );
             delete entry;
             return true;
             m_dynamicEvents->Erase( node );
             delete entry;
             return true;


@@ -1364,29 +1482,19 @@ bool wxEvtHandler::SearchDynamicEventTable( wxEvent& event )
     wxList::compatibility_iterator node = m_dynamicEvents->GetFirst();
     while (node)
     {
     wxList::compatibility_iterator node = m_dynamicEvents->GetFirst();
     while (node)
     {

-#if WXWIN_COMPATIBILITY_EVENT_TYPES
-        wxEventTableEntry *entry = (wxEventTableEntry*)node->GetData();
-#else // !WXWIN_COMPATIBILITY_EVENT_TYPES

         wxDynamicEventTableEntry *entry = (wxDynamicEventTableEntry*)node->GetData();
         wxDynamicEventTableEntry *entry = (wxDynamicEventTableEntry*)node->GetData();

-#endif // WXWIN_COMPATIBILITY_EVENT_TYPES/!WXWIN_COMPATIBILITY_EVENT_TYPES

 
         // get next node before (maybe) calling the event handler as it could
         // call Disconnect() invalidating the current node
         node = node->GetNext();
 
 
         // get next node before (maybe) calling the event handler as it could
         // call Disconnect() invalidating the current node
         node = node->GetNext();
 

-        if ((event.GetEventType() == entry->m_eventType) && (entry->m_fn != 0))
+        if ( event.GetEventType() == entry->m_eventType )

         {
         {

-            wxEvtHandler *handler =
-#if !WXWIN_COMPATIBILITY_EVENT_TYPES
-                                    entry->m_eventSink ? entry->m_eventSink
-                                                       :
-#endif
-                                                         this;
-
-            if ( ProcessEventIfMatches(*entry, handler, event) )
-            {
+            wxEvtHandler *handler = entry->m_fn->GetHandler();
+            if ( !handler )
+               handler = this;
+            if ( ProcessEventIfMatchesId(*entry, handler, event) )

                 return true;
                 return true;

-            }

         }
     }
 
         }
     }
 


@@ -1434,6 +1542,45 @@ void *wxEvtHandler::DoGetClientData() const
     return m_clientData;
 }
 
     return m_clientData;
 }
 

+// A helper to find an wxEventConnectionRef object
+wxEventConnectionRef *
+wxEvtHandler::FindRefInTrackerList(wxEvtHandler *eventSink)
+{
+    for ( wxTrackerNode *node = eventSink->GetFirst(); node; node = node->m_nxt )
+    {
+        // we only want wxEventConnectionRef nodes here
+        wxEventConnectionRef *evtConnRef = node->ToEventConnection();
+        if ( evtConnRef && evtConnRef->m_src == this )
+        {
+            wxASSERT( evtConnRef->m_sink==eventSink );
+            return evtConnRef;
+        }
+    }
+
+    return NULL;
+}
+
+void wxEvtHandler::OnSinkDestroyed( wxEvtHandler *sink )
+{
+    wxASSERT(m_dynamicEvents);
+
+    // remove all connections with this sink
+    wxList::compatibility_iterator node = m_dynamicEvents->GetFirst(), node_nxt;
+    while (node)
+    {
+        wxDynamicEventTableEntry *entry = (wxDynamicEventTableEntry*)node->GetData();
+        node_nxt = node->GetNext();
+
+        if ( entry->m_fn->GetHandler() == sink )
+        {
+            delete entry->m_callbackUserData;
+            m_dynamicEvents->Erase( node );
+            delete entry;
+        }
+        node = node_nxt;
+    }
+}
+

 #endif // wxUSE_BASE
 
 #if wxUSE_GUI
 #endif // wxUSE_BASE
 
 #if wxUSE_GUI


@@ -1455,10 +1602,45 @@ wxWindow* wxFindFocusDescendant(wxWindow* ancestor)
         else
             win = win->GetParent();
     }
         else
             win = win->GetParent();
     }

-    if (win == (wxWindow*) NULL)
-        focusWin = (wxWindow*) NULL;
+    if (win == NULL)
+        focusWin = NULL;

 
     return focusWin;
 }
 
 
     return focusWin;
 }
 

+// ----------------------------------------------------------------------------
+// wxEventBlocker
+// ----------------------------------------------------------------------------
+
+wxEventBlocker::wxEventBlocker(wxWindow *win, wxEventType type)
+{
+    wxCHECK_RET(win, wxT("Null window given to wxEventBlocker"));
+
+    m_window = win;
+
+    Block(type);
+    m_window->PushEventHandler(this);
+}
+
+wxEventBlocker::~wxEventBlocker()
+{
+    wxEvtHandler *popped = m_window->PopEventHandler(false);
+    wxCHECK_RET(popped == this,
+        wxT("Don't push other event handlers into a window managed by wxEventBlocker!"));
+}
+
+bool wxEventBlocker::ProcessEvent(wxEvent& event)
+{
+    // should this event be blocked?
+    for ( size_t i = 0; i < m_eventsToBlock.size(); i++ )
+    {
+        wxEventType t = (wxEventType)m_eventsToBlock[i];
+        if ( t == wxEVT_ANY || t == event.GetEventType() )
+            return true;   // yes, it should: mark this event as processed
+    }
+
+    return false;
+}
+

 #endif // wxUSE_GUI
 #endif // wxUSE_GUI

+