X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/223d09f6b523aac674ef9b72a883dfa8d37c5d4e..e15421ad3b12cbcbf4f1d5abfb153b00a7018bb8:/src/common/event.cpp

diff --git a/src/common/event.cpp b/src/common/event.cpp
index c20371c475..eaf9a7eff9 100644
--- a/src/common/event.cpp
+++ b/src/common/event.cpp
@@ -9,6 +9,14 @@
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
+// ============================================================================
+// declarations
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+
 #ifdef __GNUG__
     #pragma implementation "event.h"
 #endif
@@ -38,7 +46,10 @@
     #include "wx/validate.h"
 #endif // wxUSE_GUI
 
-#if !USE_SHARED_LIBRARY
+// ----------------------------------------------------------------------------
+// wxWin macros
+// ----------------------------------------------------------------------------
+
     IMPLEMENT_DYNAMIC_CLASS(wxEvtHandler, wxObject)
     IMPLEMENT_ABSTRACT_CLASS(wxEvent, wxObject)
     IMPLEMENT_DYNAMIC_CLASS(wxIdleEvent, wxEvent)
@@ -82,14 +93,27 @@
     const wxEventTableEntry wxEvtHandler::sm_eventTableEntries[] =
         { { 0, 0, 0, (wxObjectEventFunction) NULL, (wxObject*) NULL } };
 
-#endif // !USE_SHARED_LIBRARY
+
+// ----------------------------------------------------------------------------
+// global variables
+// ----------------------------------------------------------------------------
+
+// To put pending event handlers
+wxList *wxPendingEvents = (wxList *)NULL;
 
 #if wxUSE_THREADS
-/* To put pending event handlers */
-extern wxList *wxPendingEvents;
-extern wxCriticalSection *wxPendingEventsLocker;
+    // protects wxPendingEvents list
+    wxCriticalSection *wxPendingEventsLocker = (wxCriticalSection *)NULL;
 #endif
 
+// ============================================================================
+// implementation
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// wxEvent
+// ----------------------------------------------------------------------------
+
 /*
  * General wxWindows events, covering
  * all interesting things that might happen (button clicking, resizing,
@@ -149,10 +173,24 @@ void wxCommandEvent::CopyObject(wxObject& obj_d) const
 
     wxEvent::CopyObject(obj_d);
 
-    obj->m_clientData   = m_clientData;
-    obj->m_clientObject = m_clientObject;
-    obj->m_extraLong    = m_extraLong;
-    obj->m_commandInt   = m_commandInt;
+    obj->m_clientData    = m_clientData;
+    obj->m_clientObject  = m_clientObject;
+    obj->m_extraLong     = m_extraLong;
+    obj->m_commandInt    = m_commandInt;
+    obj->m_commandString = m_commandString;
+}
+
+/*
+ * Notify events
+ */
+
+void wxNotifyEvent::CopyObject(wxObject& obj_d) const
+{
+    wxNotifyEvent *obj = (wxNotifyEvent *)&obj_d;
+
+    wxEvent::CopyObject(obj_d);
+
+    if (!m_bAllow) obj->Veto();
 }
 
 /*
@@ -167,6 +205,16 @@ wxScrollEvent::wxScrollEvent(wxEventType commandType,
 {
     m_extraLong = orient;
     m_commandInt = pos;
+    m_isScrolling = TRUE;
+}
+
+void wxScrollEvent::CopyObject(wxObject& obj_d) const
+{
+    wxScrollEvent *obj = (wxScrollEvent*)&obj_d;
+
+    wxCommandEvent::CopyObject(obj_d);
+
+    obj->m_isScrolling  = m_isScrolling;
 }
 
 /*
@@ -180,6 +228,7 @@ wxScrollWinEvent::wxScrollWinEvent(wxEventType commandType,
     m_eventType = commandType;
     m_extraLong = orient;
     m_commandInt = pos;
+    m_isScrolling = TRUE;
 }
 
 void wxScrollWinEvent::CopyObject(wxObject& obj_d) const
@@ -190,6 +239,7 @@ void wxScrollWinEvent::CopyObject(wxObject& obj_d) const
 
     obj->m_extraLong    = m_extraLong;
     obj->m_commandInt   = m_commandInt;
+    obj->m_isScrolling  = m_isScrolling;
 }
 
 /*
@@ -295,7 +345,7 @@ bool wxMouseEvent::Button(int but) const
 {
     switch (but) {
         case -1:
-            return (ButtonUp(-1) || ButtonDown(-1) || ButtonDClick(-1)) ;
+            return (ButtonUp(-1) || ButtonDown(-1) || ButtonDClick(-1));
         case 1:
             return (LeftDown() || LeftUp() || LeftDClick());
         case 2:
@@ -356,6 +406,10 @@ void wxKeyEvent::CopyObject(wxObject& obj_d) const
     wxKeyEvent *obj = (wxKeyEvent *)&obj_d;
     wxEvent::CopyObject(obj_d);
 
+    obj->m_x = m_x;
+    obj->m_y = m_y;
+    obj->m_keyCode = m_keyCode;
+    
     obj->m_shiftDown   = m_shiftDown;
     obj->m_controlDown = m_controlDown;
     obj->m_metaDown    = m_metaDown;
@@ -482,14 +536,16 @@ void wxQueryNewPaletteEvent::CopyObject(wxObject& obj_d) const
 }
 
 wxWindowCreateEvent::wxWindowCreateEvent(wxWindow *win)
-                   : wxEvent(wxEVT_CREATE)
+                   : wxEvent()
 {
+    SetEventType(wxEVT_CREATE);
     SetEventObject(win);
 }
 
 wxWindowDestroyEvent::wxWindowDestroyEvent(wxWindow *win)
-                    : wxEvent(wxEVT_DESTROY)
+                    : wxEvent()
 {
+    SetEventType(wxEVT_DESTROY);
     SetEventObject(win);
 }
 
@@ -514,10 +570,12 @@ wxEvtHandler::wxEvtHandler()
     m_enabled = TRUE;
     m_dynamicEvents = (wxList *) NULL;
     m_isWindow = FALSE;
+    m_pendingEvents = (wxList *) NULL;
 #if wxUSE_THREADS
-    m_eventsLocker = new wxCriticalSection();
+#  if !defined(__VISAGECPP__)
+    m_eventsLocker = new wxCriticalSection;
+#  endif
 #endif
-    m_pendingEvents = (wxList *) NULL;
 }
 
 wxEvtHandler::~wxEvtHandler()
@@ -542,63 +600,107 @@ wxEvtHandler::~wxEvtHandler()
         delete m_dynamicEvents;
     };
 
-#if wxUSE_THREADS
-    if (m_pendingEvents)
-      delete m_pendingEvents;
+    delete m_pendingEvents;
 
+#if wxUSE_THREADS
+#  if !defined(__VISAGECPP__)
     delete m_eventsLocker;
+#  endif
 #endif
 }
 
 #if wxUSE_THREADS
 
-#ifdef __WXGTK__
-extern bool g_isIdle;
-extern void wxapp_install_idle_handler();
-#endif
-
 bool wxEvtHandler::ProcessThreadEvent(wxEvent& event)
 {
-    wxEvent *event_main;
-    wxCriticalSectionLocker locker(*m_eventsLocker);
-
     // check that we are really in a child thread
-    wxASSERT( !wxThread::IsMain() );
+    wxASSERT_MSG( !wxThread::IsMain(),
+                  wxT("use ProcessEvent() in main thread") );
 
-    if (m_pendingEvents == NULL)
-      m_pendingEvents = new wxList();
+    AddPendingEvent(event);
 
-    event_main = (wxEvent *)event.Clone();
+    return TRUE;
+}
 
-    m_pendingEvents->Append(event_main);
+#endif // wxUSE_THREADS
 
-    wxPendingEventsLocker->Enter();
-    wxPendingEvents->Append(this);
-    wxPendingEventsLocker->Leave();
+void wxEvtHandler::AddPendingEvent(wxEvent& event)
+{
+    // 1) Add event to list of pending events of this event handler
 
-    // TODO: Wake up idle handler for the other platforms.
-#ifdef __WXGTK__
-    if (g_isIdle)
-        wxapp_install_idle_handler();
+#if defined(__VISAGECPP__)
+    wxENTER_CRIT_SECT( m_eventsLocker);
+#else
+    wxENTER_CRIT_SECT( *m_eventsLocker);
 #endif
 
-    return TRUE;
+    if ( !m_pendingEvents )
+      m_pendingEvents = new wxList;
+
+    wxEvent *event2 = (wxEvent *)event.Clone();
+
+    m_pendingEvents->Append(event2);
+
+#if defined(__VISAGECPP__)
+    wxLEAVE_CRIT_SECT( m_eventsLocker);
+#else
+    wxLEAVE_CRIT_SECT( *m_eventsLocker);
+#endif
+
+    // 2) Add this event handler to list of event handlers that
+    //    have pending events.
+
+    wxENTER_CRIT_SECT(*wxPendingEventsLocker);
+
+    if ( !wxPendingEvents )
+        wxPendingEvents = new wxList;
+    wxPendingEvents->Append(this);
+
+    wxLEAVE_CRIT_SECT(*wxPendingEventsLocker);
+    
+    // 3) Inform the system that new pending events are somwehere,
+    //    and that these should be processed in idle time.
+    wxWakeUpIdle();
 }
 
 void wxEvtHandler::ProcessPendingEvents()
 {
-    wxCriticalSectionLocker locker(*m_eventsLocker);
+#if defined(__VISAGECPP__)
+    wxENTER_CRIT_SECT( m_eventsLocker);
+#else
+    wxENTER_CRIT_SECT( *m_eventsLocker);
+#endif
+
     wxNode *node = m_pendingEvents->First();
-    wxEvent *event;
+    while ( node )
+    {
+        wxEvent *event = (wxEvent *)node->Data();
+        delete node;
 
-    while (node != NULL) {
-      event = (wxEvent *)node->Data();
-      ProcessEvent(*event);
-      delete node;
-      node = m_pendingEvents->First();
+        // In ProcessEvent, new events might get added and
+	    // we can safely leave the crtical section here.
+#if defined(__VISAGECPP__)
+        wxLEAVE_CRIT_SECT( m_eventsLocker);
+#else
+        wxLEAVE_CRIT_SECT( *m_eventsLocker);
+#endif
+        ProcessEvent(*event);
+        delete event;
+#if defined(__VISAGECPP__)
+        wxENTER_CRIT_SECT( m_eventsLocker);
+#else
+        wxENTER_CRIT_SECT( *m_eventsLocker);
+#endif
+
+        node = m_pendingEvents->First();
     }
-}
+
+#if defined(__VISAGECPP__)
+    wxLEAVE_CRIT_SECT( m_eventsLocker);
+#else
+    wxLEAVE_CRIT_SECT( *m_eventsLocker);
 #endif
+}
 
 /*
  * Event table stuff
@@ -607,25 +709,31 @@ void wxEvtHandler::ProcessPendingEvents()
 bool wxEvtHandler::ProcessEvent(wxEvent& event)
 {
 #if wxUSE_GUI
-    /* check that our flag corresponds to reality */
+    // check that our flag corresponds to reality
     wxASSERT( m_isWindow == IsKindOf(CLASSINFO(wxWindow)) );
 #endif // wxUSE_GUI
 
-    /* An event handler can be enabled or disabled */
+    // An event handler can be enabled or disabled
     if ( GetEvtHandlerEnabled() )
     {
-#if wxUSE_THREADS
-        /* Check whether we are in a child thread. */
-        if (!wxThread::IsMain())
+    
+#if 0
+/*
+        What is this? When using GUI threads, a non main
+        threads can send an event and process it itself.
+        This breaks GTK's GUI threads, so please explain.
+*/
+
+        // Check whether we are in a child thread.
+        if ( !wxThread::IsMain() )
           return ProcessThreadEvent(event);
 #endif
-        /* Handle per-instance dynamic event tables first */
 
+        // Handle per-instance dynamic event tables first
         if ( m_dynamicEvents && SearchDynamicEventTable(event) )
             return TRUE;
 
-        /* Then static per-class event tables */
-
+        // Then static per-class event tables
         const wxEventTable *table = GetEventTable();
 
 #if wxUSE_GUI && wxUSE_VALIDATORS
@@ -732,6 +840,7 @@ bool wxEvtHandler::SearchEventTable(wxEventTable& table, wxEvent& event)
     }
     return FALSE;
 }
+
 void wxEvtHandler::Connect( int id, int lastId,
                             wxEventType eventType,
                             wxObjectEventFunction func,
@@ -750,6 +859,33 @@ void wxEvtHandler::Connect( int id, int lastId,
     m_dynamicEvents->Append( (wxObject*) entry );
 }
 
+bool wxEvtHandler::Disconnect( int id, int lastId, wxEventType eventType,
+                  wxObjectEventFunction func,
+                  wxObject *userData )
+{
+    if (!m_dynamicEvents)
+        return FALSE;
+
+    wxNode *node = m_dynamicEvents->First();
+    while (node)
+    {
+        wxEventTableEntry *entry = (wxEventTableEntry*)node->Data();
+        if ((entry->m_id == id) &&
+            ((entry->m_lastId == lastId) || (lastId == -1)) &&
+            ((entry->m_eventType == eventType) || (eventType == wxEVT_NULL)) &&
+            ((entry->m_fn == func) || (func == (wxObjectEventFunction)NULL)) &&
+            ((entry->m_callbackUserData == userData) || (userData == (wxObject*)NULL)))
+        {
+            if (entry->m_callbackUserData) delete entry->m_callbackUserData;
+            m_dynamicEvents->DeleteNode( node );
+            delete entry;
+            return TRUE;
+        }
+        node = node->Next();
+    }
+    return FALSE;
+}
+
 bool wxEvtHandler::SearchDynamicEventTable( wxEvent& event )
 {
     wxCHECK_MSG( m_dynamicEvents, FALSE,