implement button support for pre-XP systems (or with themes disabled); using only...

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

diff --git a/src/common/event.cpp b/src/common/event.cpp
index af8b2ac1b2038cf41c96e046f7cb407c0aa23d23..34ec269af161a4d5e5a2dfc76cd14efeb4896992 100644 (file)
--- a/src/common/event.cpp
+++ b/src/common/event.cpp
@@ -126,7 +126,7 @@ const wxEventTableEntry wxEvtHandler::sm_eventTableEntries[] =
 // 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
 // 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
+#if wxUSE_MEMORY_TRACING

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


@@ -140,7 +140,7 @@ public:
 
 IMPLEMENT_DYNAMIC_CLASS(wxEventTableEntryModule, wxModule)
 
 
 IMPLEMENT_DYNAMIC_CLASS(wxEventTableEntryModule, wxModule)
 

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

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


@@ -177,6 +177,8 @@ 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 );
 wxDEFINE_EVENT( wxEVT_COMMAND_SPINCTRL_UPDATED, wxCommandEvent );
 wxDEFINE_EVENT( wxEVT_COMMAND_SPINCTRLDOUBLE_UPDATED, wxCommandEvent );
 wxDEFINE_EVENT( wxEVT_COMMAND_TOOL_DROPDOWN_CLICKED, wxCommandEvent );

+wxDEFINE_EVENT( wxEVT_COMMAND_COMBOBOX_DROPDOWN, wxCommandEvent);
+wxDEFINE_EVENT( wxEVT_COMMAND_COMBOBOX_CLOSEUP, wxCommandEvent);

 
 // Mouse event types
 wxDEFINE_EVENT( wxEVT_LEFT_DOWN, wxMouseEvent );
 
 // Mouse event types
 wxDEFINE_EVENT( wxEVT_LEFT_DOWN, wxMouseEvent );


@@ -402,10 +404,9 @@ wxEvent& wxEvent::operator=(const wxEvent& src)
 
 #if wxUSE_GUI
 
 
 #if wxUSE_GUI
 

-/*
- * Command events
- *
- */
+// ----------------------------------------------------------------------------
+// wxCommandEvent
+// ----------------------------------------------------------------------------

 
 #ifdef __VISUALC__
     // 'this' : used in base member initializer list (for m_commandString)
 
 #ifdef __VISUALC__
     // 'this' : used in base member initializer list (for m_commandString)


@@ -447,9 +448,9 @@ wxString wxCommandEvent::GetString() const
     }
 }
 
     }
 }
 

-/*
- * UI update events
- */
+// ----------------------------------------------------------------------------
+// wxUpdateUIEvent
+// ----------------------------------------------------------------------------

 
 #if wxUSE_LONGLONG
 wxLongLong wxUpdateUIEvent::sm_lastUpdate = 0;
 
 #if wxUSE_LONGLONG
 wxLongLong wxUpdateUIEvent::sm_lastUpdate = 0;


@@ -506,9 +507,9 @@ void wxUpdateUIEvent::ResetUpdateTime()
 #endif
 }
 
 #endif
 }
 

-/*
- * Scroll events
- */
+// ----------------------------------------------------------------------------
+// wxScrollEvent
+// ----------------------------------------------------------------------------

 
 wxScrollEvent::wxScrollEvent(wxEventType commandType,
                              int id,
 
 wxScrollEvent::wxScrollEvent(wxEventType commandType,
                              int id,


@@ -520,9 +521,9 @@ wxScrollEvent::wxScrollEvent(wxEventType commandType,
     m_commandInt = pos;
 }
 
     m_commandInt = pos;
 }
 

-/*
- * ScrollWin events
- */
+// ----------------------------------------------------------------------------
+// wxScrollWinEvent
+// ----------------------------------------------------------------------------

 
 wxScrollWinEvent::wxScrollWinEvent(wxEventType commandType,
                                    int pos,
 
 wxScrollWinEvent::wxScrollWinEvent(wxEventType commandType,
                                    int pos,


@@ -533,10 +534,9 @@ wxScrollWinEvent::wxScrollWinEvent(wxEventType commandType,
     m_commandInt = pos;
 }
 
     m_commandInt = pos;
 }
 

-/*
- * Mouse events
- *
- */
+// ----------------------------------------------------------------------------
+// wxMouseEvent
+// ----------------------------------------------------------------------------

 
 wxMouseEvent::wxMouseEvent(wxEventType commandType)
 {
 
 wxMouseEvent::wxMouseEvent(wxEventType commandType)
 {


@@ -703,34 +703,6 @@ bool wxMouseEvent::Button(int but) const
     }
 }
 
     }
 }
 

-bool wxMouseEvent::ButtonIsDown(int but) const
-{
-    switch (but)
-    {
-        default:
-            wxFAIL_MSG(wxT("invalid parameter in wxMouseEvent::ButtonIsDown"));
-            // fall through
-
-        case wxMOUSE_BTN_ANY:
-            return LeftIsDown() || MiddleIsDown() || RightIsDown() || Aux1Down() || Aux2Down();
-
-        case wxMOUSE_BTN_LEFT:
-            return LeftIsDown();
-
-        case wxMOUSE_BTN_MIDDLE:
-            return MiddleIsDown();
-
-        case wxMOUSE_BTN_RIGHT:
-            return RightIsDown();
-
-        case wxMOUSE_BTN_AUX1:
-            return Aux1IsDown();
-
-        case wxMOUSE_BTN_AUX2:
-            return Aux2IsDown();
-    }
-}
-

 int wxMouseEvent::GetButton() const
 {
     for ( int i = 1; i < wxMOUSE_BTN_MAX; i++ )
 int wxMouseEvent::GetButton() const
 {
     for ( int i = 1; i < wxMOUSE_BTN_MAX; i++ )


@@ -751,11 +723,9 @@ wxPoint wxMouseEvent::GetLogicalPosition(const wxDC& dc) const
     return pt;
 }
 
     return pt;
 }
 

-
-/*
- * Keyboard event
- *
- */
+// ----------------------------------------------------------------------------
+// wxKeyEvent
+// ----------------------------------------------------------------------------

 
 wxKeyEvent::wxKeyEvent(wxEventType type)
 {
 
 wxKeyEvent::wxKeyEvent(wxEventType type)
 {


@@ -782,18 +752,30 @@ wxKeyEvent::wxKeyEvent(const wxKeyEvent& evt)
 #endif
 }
 
 #endif
 }
 

+// ----------------------------------------------------------------------------
+// wxWindowCreateEvent
+// ----------------------------------------------------------------------------
+

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

+// ----------------------------------------------------------------------------
+// wxWindowDestroyEvent
+// ----------------------------------------------------------------------------
+

 wxWindowDestroyEvent::wxWindowDestroyEvent(wxWindow *win)
 {
     SetEventType(wxEVT_DESTROY);
     SetEventObject(win);
 }
 
 wxWindowDestroyEvent::wxWindowDestroyEvent(wxWindow *win)
 {
     SetEventType(wxEVT_DESTROY);
     SetEventObject(win);
 }
 

+// ----------------------------------------------------------------------------
+// wxChildFocusEvent
+// ----------------------------------------------------------------------------
+

 wxChildFocusEvent::wxChildFocusEvent(wxWindow *win)
                  : wxCommandEvent(wxEVT_CHILD_FOCUS)
 {
 wxChildFocusEvent::wxChildFocusEvent(wxWindow *win)
                  : wxCommandEvent(wxEVT_CHILD_FOCUS)
 {


@@ -868,7 +850,7 @@ void wxEventHashTable::Clear()
     m_size = 0;
 }
 
     m_size = 0;
 }
 

-#if defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING
+#if wxUSE_MEMORY_TRACING

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


@@ -881,7 +863,7 @@ void wxEventHashTable::ClearAll()
     }
 }
 
     }
 }
 

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

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


@@ -1071,14 +1053,11 @@ wxEvtHandler::~wxEvtHandler()
         delete m_dynamicEvents;
     }
 
         delete m_dynamicEvents;
     }
 

-    if (m_pendingEvents)
-        m_pendingEvents->DeleteContents(true);
-    delete m_pendingEvents;
-

     // Remove us from the list of the pending events if necessary.
     // Remove us from the list of the pending events if necessary.

-    wxEventLoopBase *loop = wxEventLoopBase::GetActive();
-    if (loop)
-        loop->RemovePendingEventHandler(this);
+    if (wxTheApp)
+        wxTheApp->RemovePendingEventHandler(this);
+
+    DeletePendingEvents();

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


@@ -1124,12 +1103,11 @@ void wxEvtHandler::QueueEvent(wxEvent *event)
 {
     wxCHECK_RET( event, "NULL event can't be posted" );
 
 {
     wxCHECK_RET( event, "NULL event can't be posted" );
 

-    wxEventLoopBase* loop = wxEventLoopBase::GetActive();
-    if (!loop)
+    if (!wxTheApp)

     {
         // we need an event loop which manages the list of event handlers with
         // pending events... cannot proceed without it!
     {
         // we need an event loop which manages the list of event handlers with
         // pending events... cannot proceed without it!

-        wxLogDebug("No event loop is running! Cannot queue this event!");
+        wxLogDebug("No application object! Cannot queue this event!");

 
         // anyway delete the given event to avoid memory leaks
         delete event;
 
         // anyway delete the given event to avoid memory leaks
         delete event;


@@ -1141,14 +1119,14 @@ void wxEvtHandler::QueueEvent(wxEvent *event)
     wxENTER_CRIT_SECT( m_pendingEventsLock );
 
     if ( !m_pendingEvents )
     wxENTER_CRIT_SECT( m_pendingEventsLock );
 
     if ( !m_pendingEvents )

-      m_pendingEvents = new wxList;
+        m_pendingEvents = new wxList;

 
     m_pendingEvents->Append(event);
 
     // 2) Add this event handler to list of event handlers that
     //    have pending events.
 
 
     m_pendingEvents->Append(event);
 
     // 2) Add this event handler to list of event handlers that
     //    have pending events.
 

-    loop->AppendPendingEventHandler(this);
+    wxTheApp->AppendPendingEventHandler(this);

 
     // only release m_pendingEventsLock now because otherwise there is a race
     // condition as described in the ticket #9093: we could process the event
 
     // only release m_pendingEventsLock now because otherwise there is a race
     // condition as described in the ticket #9093: we could process the event


@@ -1163,14 +1141,20 @@ void wxEvtHandler::QueueEvent(wxEvent *event)
     wxWakeUpIdle();
 }
 
     wxWakeUpIdle();
 }
 

+void wxEvtHandler::DeletePendingEvents()
+{
+    if (m_pendingEvents)
+        m_pendingEvents->DeleteContents(true);
+    wxDELETE(m_pendingEvents);
+}
+

 void wxEvtHandler::ProcessPendingEvents()
 {
 void wxEvtHandler::ProcessPendingEvents()
 {

-    wxEventLoopBase* loop = wxEventLoopBase::GetActive();
-    if (!loop)
+    if (!wxTheApp)

     {
         // we need an event loop which manages the list of event handlers with
         // pending events... cannot proceed without it!
     {
         // we need an event loop which manages the list of event handlers with
         // pending events... cannot proceed without it!

-        wxLogDebug("No event loop is running! Cannot process pending events!");
+        wxLogDebug("No application object! Cannot process pending events!");

         return;
     }
 
         return;
     }
 


@@ -1201,7 +1185,7 @@ void wxEvtHandler::ProcessPendingEvents()
         if (!node)
         {
             // all our events are NOT processable now... signal this:
         if (!node)
         {
             // all our events are NOT processable now... signal this:

-            loop->DelayPendingEventHandler(this);
+            wxTheApp->DelayPendingEventHandler(this);

 
             // see the comment at the beginning of evtloop.h header for the
             // logic behind YieldFor() and behind DelayPendingEventHandler()
 
             // see the comment at the beginning of evtloop.h header for the
             // logic behind YieldFor() and behind DelayPendingEventHandler()


@@ -1223,7 +1207,7 @@ void wxEvtHandler::ProcessPendingEvents()
     {
         // if there are no more pending events left, we don't need to
         // stay in this list
     {
         // if there are no more pending events left, we don't need to
         // stay in this list

-        loop->RemovePendingEventHandler(this);
+        wxTheApp->RemovePendingEventHandler(this);

     }
 
     wxLEAVE_CRIT_SECT( m_pendingEventsLock );
     }
 
     wxLEAVE_CRIT_SECT( m_pendingEventsLock );


@@ -1235,13 +1219,10 @@ void wxEvtHandler::ProcessPendingEvents()
     // of this object any more
 }
 
     // of this object any more
 }
 

-/*
- * Event table stuff
- */
-/* static */ bool
-wxEvtHandler::ProcessEventIfMatchesId(const wxEventTableEntryBase& entry,
-                                      wxEvtHandler *handler,
-                                      wxEvent& event)
+/* static */
+bool 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;


@@ -1298,7 +1279,7 @@ bool wxEvtHandler::DoTryApp(wxEvent& event)
 
 bool wxEvtHandler::TryBefore(wxEvent& event)
 {
 
 bool wxEvtHandler::TryBefore(wxEvent& event)
 {

-#ifdef WXWIN_COMPATIBILITY_2_8
+#if WXWIN_COMPATIBILITY_2_8

     // call the old virtual function to keep the code overriding it working
     return TryValidator(event);
 #else
     // call the old virtual function to keep the code overriding it working
     return TryValidator(event);
 #else


@@ -1309,7 +1290,7 @@ bool wxEvtHandler::TryBefore(wxEvent& event)
 
 bool wxEvtHandler::TryAfter(wxEvent& event)
 {
 
 bool wxEvtHandler::TryAfter(wxEvent& event)
 {

-#ifdef WXWIN_COMPATIBILITY_2_8
+#if WXWIN_COMPATIBILITY_2_8

     // as above, call the old virtual function for compatibility
     return TryParent(event);
 #else
     // as above, call the old virtual function for compatibility
     return TryParent(event);
 #else


@@ -1387,9 +1368,15 @@ bool wxEvtHandler::SafelyProcessEvent(wxEvent& event)
     }
     catch ( ... )
     {
     }
     catch ( ... )
     {

-        wxEventLoopBase *loop = wxEventLoopBase::GetActive();
+        // notice that we do it in 2 steps to avoid warnings about possibly
+        // uninitialized loop variable from some versions of g++ which are not
+        // smart enough to figure out that GetActive() doesn't throw and so
+        // that loop will always be initialized
+        wxEventLoopBase *loop = NULL;

         try
         {
         try
         {

+            loop = wxEventLoopBase::GetActive();
+

             if ( !wxTheApp || !wxTheApp->OnExceptionInMainLoop() )
             {
                 if ( loop )
             if ( !wxTheApp || !wxTheApp->OnExceptionInMainLoop() )
             {
                 if ( loop )


@@ -1412,7 +1399,6 @@ bool wxEvtHandler::SafelyProcessEvent(wxEvent& event)
 #endif // wxUSE_EXCEPTIONS
 }
 
 #endif // wxUSE_EXCEPTIONS
 }
 

-

 bool wxEvtHandler::SearchEventTable(wxEventTable& table, wxEvent& event)
 {
     const wxEventType eventType = event.GetEventType();
 bool wxEvtHandler::SearchEventTable(wxEventTable& table, wxEvent& event)
 {
     const wxEventType eventType = event.GetEventType();


@@ -1429,11 +1415,11 @@ bool wxEvtHandler::SearchEventTable(wxEventTable& table, wxEvent& event)
     return false;
 }
 
     return false;
 }
 

-void wxEvtHandler::DoConnect(int id,
-                             int lastId,
-                             wxEventType eventType,
-                             wxEventFunctor *func,
-                             wxObject *userData)
+void wxEvtHandler::DoBind(int id,
+                          int lastId,
+                          wxEventType eventType,
+                          wxEventFunctor *func,
+                          wxObject *userData)

 {
     wxDynamicEventTableEntry *entry =
         new wxDynamicEventTableEntry(eventType, id, lastId, func, userData);
 {
     wxDynamicEventTableEntry *entry =
         new wxDynamicEventTableEntry(eventType, id, lastId, func, userData);


@@ -1457,11 +1443,11 @@ void wxEvtHandler::DoConnect(int id,
 }
 
 bool
 }
 
 bool

-wxEvtHandler::DoDisconnect(int id,
-                           int lastId,
-                           wxEventType eventType,
-                           const wxEventFunctor& func,
-                           wxObject *userData)
+wxEvtHandler::DoUnbind(int id,
+                       int lastId,
+                       wxEventType eventType,
+                       const wxEventFunctor& func,
+                       wxObject *userData)

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


@@ -1483,7 +1469,7 @@ wxEvtHandler::DoDisconnect(int id,
         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->Matches(func) &&
+            entry->m_fn->IsMatching(func) &&

             ((entry->m_callbackUserData == userData) || !userData))
         {
             delete entry->m_callbackUserData;
             ((entry->m_callbackUserData == userData) || !userData))
         {
             delete entry->m_callbackUserData;