Don't set the initial size as minimal size for top level windows.

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

diff --git a/src/common/evtloopcmn.cpp b/src/common/evtloopcmn.cpp
index 482324cd4e0ac64d8788db88a9560c6095ec2da8..5f9894d12501b99563129bcd4b3a1d8005627106 100644 (file)
--- a/src/common/evtloopcmn.cpp
+++ b/src/common/evtloopcmn.cpp
@@ -23,7 +23,7 @@
 #endif //WX_PRECOMP
 
 // ----------------------------------------------------------------------------
 #endif //WX_PRECOMP
 
 // ----------------------------------------------------------------------------

-// globals
+// wxEventLoopBase

 // ----------------------------------------------------------------------------
 
 wxEventLoopBase *wxEventLoopBase::ms_activeLoop = NULL;
 // ----------------------------------------------------------------------------
 
 wxEventLoopBase *wxEventLoopBase::ms_activeLoop = NULL;


@@ -34,114 +34,26 @@ wxEventLoopBase::wxEventLoopBase()
     m_eventsToProcessInsideYield = wxEVT_CATEGORY_ALL;
 }
 
     m_eventsToProcessInsideYield = wxEVT_CATEGORY_ALL;
 }
 

-void wxEventLoopBase::DelayPendingEventHandler(wxEvtHandler* toDelay)
+bool wxEventLoopBase::IsMain() const

 {
 {

-    wxENTER_CRIT_SECT(m_handlersWithPendingEventsLocker);
-
-    // move the handler from the list of handlers with processable pending events
-    // to the list of handlers with pending events which needs to be processed later
-    m_handlersWithPendingEvents.Remove(toDelay);
-
-    if (m_handlersWithPendingDelayedEvents.Index(toDelay) == wxNOT_FOUND)
-        m_handlersWithPendingDelayedEvents.Add(toDelay);
-
-    wxLEAVE_CRIT_SECT(m_handlersWithPendingEventsLocker);
-}
-
-void wxEventLoopBase::RemovePendingEventHandler(wxEvtHandler* toRemove)
-{
-    wxENTER_CRIT_SECT(m_handlersWithPendingEventsLocker);
-
-    if (m_handlersWithPendingEvents.Index(toRemove) != wxNOT_FOUND)
-    {
-        m_handlersWithPendingEvents.Remove(toRemove);
-
-        // check that the handler was present only once in the list
-        wxASSERT_MSG( m_handlersWithPendingEvents.Index(toRemove) == wxNOT_FOUND,
-                        "Handler occurs twice in the m_handlersWithPendingEvents list!" );
-    }
-    //else: it wasn't in this list at all, it's ok
-
-    if (m_handlersWithPendingDelayedEvents.Index(toRemove) != wxNOT_FOUND)
-    {
-        m_handlersWithPendingDelayedEvents.Remove(toRemove);
-
-        // check that the handler was present only once in the list
-        wxASSERT_MSG( m_handlersWithPendingDelayedEvents.Index(toRemove) == wxNOT_FOUND,
-                        "Handler occurs twice in m_handlersWithPendingDelayedEvents list!" );
-    }
-    //else: it wasn't in this list at all, it's ok
-
-    wxLEAVE_CRIT_SECT(m_handlersWithPendingEventsLocker);
+    if (wxTheApp)
+        return wxTheApp->GetMainLoop() == this;
+    return false;

 }
 
 }
 

-void wxEventLoopBase::AppendPendingEventHandler(wxEvtHandler* toAppend)
+/* static */
+void wxEventLoopBase::SetActive(wxEventLoopBase* loop)

 {
 {

-    wxENTER_CRIT_SECT(m_handlersWithPendingEventsLocker);
-
-    if ( m_handlersWithPendingEvents.Index(toAppend) == wxNOT_FOUND )
-        m_handlersWithPendingEvents.Add(toAppend);
-
-    wxLEAVE_CRIT_SECT(m_handlersWithPendingEventsLocker);
-}
-
-bool wxEventLoopBase::HasPendingEvents() const
-{
-    wxENTER_CRIT_SECT(const_cast<wxEventLoopBase*>(this)->m_handlersWithPendingEventsLocker);
-
-    bool has = !m_handlersWithPendingEvents.IsEmpty();
-
-    wxLEAVE_CRIT_SECT(const_cast<wxEventLoopBase*>(this)->m_handlersWithPendingEventsLocker);
+    ms_activeLoop = loop;

 
 

-    return has;
+    if (wxTheApp)
+        wxTheApp->OnEventLoopEnter(loop);

 }
 
 }
 

-void wxEventLoopBase::SuspendProcessingOfPendingEvents()
+void wxEventLoopBase::OnExit()

 {
 {

-    wxENTER_CRIT_SECT(m_handlersWithPendingEventsLocker);
-}
-
-void wxEventLoopBase::ResumeProcessingOfPendingEvents()
-{
-    wxLEAVE_CRIT_SECT(m_handlersWithPendingEventsLocker);
-}
-
-void wxEventLoopBase::ProcessPendingEvents()
-{
-    wxENTER_CRIT_SECT(m_handlersWithPendingEventsLocker);
-
-    wxCHECK_RET( m_handlersWithPendingDelayedEvents.IsEmpty(),
-                 "this helper list should be empty" );
-
-    // iterate until the list becomes empty: the handlers remove themselves
-    // from it when they don't have any more pending events
-    while (!m_handlersWithPendingEvents.IsEmpty())
-    {
-        // In ProcessPendingEvents(), new handlers might be added
-        // and we can safely leave the critical section here.
-        wxENTER_CRIT_SECT(m_handlersWithPendingEventsLocker);
-
-        // NOTE: we always call ProcessPendingEvents() on the first event handler
-        //       with pending events because handlers auto-remove themselves
-        //       from this list (see RemovePendingEventHandler) if they have no
-        //       more pending events.
-        m_handlersWithPendingEvents[0]->ProcessPendingEvents();
-
-        wxLEAVE_CRIT_SECT(m_handlersWithPendingEventsLocker);
-    }
-
-    // now the wxHandlersWithPendingEvents is surely empty; however some event
-    // handlers may have moved themselves into wxHandlersWithPendingDelayedEvents
-    // because of a selective wxYield call in progress.
-    // Now we need to move them back to wxHandlersWithPendingEvents so the next
-    // call to this function has the chance of processing them:
-    if (!m_handlersWithPendingDelayedEvents.IsEmpty())
-    {
-        WX_APPEND_ARRAY(m_handlersWithPendingEvents, m_handlersWithPendingDelayedEvents);
-        m_handlersWithPendingDelayedEvents.Clear();
-    }
-
-    wxLEAVE_CRIT_SECT(m_handlersWithPendingEventsLocker);
+    if (wxTheApp)
+        wxTheApp->OnEventLoopExit(this);

 }
 
 void wxEventLoopBase::WakeUpIdle()
 }
 
 void wxEventLoopBase::WakeUpIdle()


@@ -151,14 +63,7 @@ void wxEventLoopBase::WakeUpIdle()
 
 bool wxEventLoopBase::ProcessIdle()
 {
 
 bool wxEventLoopBase::ProcessIdle()
 {

-    // process pending wx events before sending idle events
-    ProcessPendingEvents();
-
-    wxIdleEvent event;
-
-    event.SetEventObject(wxTheApp);
-    wxTheApp->ProcessEvent(event);
-    return event.MoreRequested();
+    return wxTheApp && wxTheApp->ProcessIdle();

 }
 
 bool wxEventLoopBase::Yield(bool onlyIfNeeded)
 }
 
 bool wxEventLoopBase::Yield(bool onlyIfNeeded)


@@ -189,18 +94,33 @@ wxEventLoopManual::wxEventLoopManual()
     m_shouldExit = false;
 }
 
     m_shouldExit = false;
 }
 

+bool wxEventLoopManual::ProcessEvents()
+{
+    // process pending wx events first as they correspond to low-level events
+    // which happened before, i.e. typically pending events were queued by a
+    // previous call to Dispatch() and if we didn't process them now the next
+    // call to it might enqueue them again (as happens with e.g. socket events
+    // which would be generated as long as there is input available on socket
+    // and this input is only removed from it when pending event handlers are
+    // executed)
+    if ( wxTheApp )
+        wxTheApp->ProcessPendingEvents();
+
+    return Dispatch();
+}
+

 int wxEventLoopManual::Run()
 {
     // event loops are not recursive, you need to create another loop!
 int wxEventLoopManual::Run()
 {
     // event loops are not recursive, you need to create another loop!

-    wxCHECK_MSG( !IsRunning(), -1, _T("can't reenter a message loop") );
+    wxCHECK_MSG( !IsRunning(), -1, wxT("can't reenter a message loop") );

 
 

-    // ProcessIdle() and Dispatch() below may throw so the code here should
+    // ProcessIdle() and ProcessEvents() below may throw so the code here should

     // be exception-safe, hence we must use local objects for all actions we
     // should undo
     wxEventLoopActivator activate(this);
 
     // we must ensure that OnExit() is called even if an exception is thrown
     // be exception-safe, hence we must use local objects for all actions we
     // should undo
     wxEventLoopActivator activate(this);
 
     // we must ensure that OnExit() is called even if an exception is thrown

-    // from inside Dispatch() but we must call it from Exit() in normal
+    // from inside ProcessEvents() but we must call it from Exit() in normal

     // situations because it is supposed to be called synchronously,
     // wxModalEventLoop depends on this (so we can't just use ON_BLOCK_EXIT or
     // something similar here)
     // situations because it is supposed to be called synchronously,
     // wxModalEventLoop depends on this (so we can't just use ON_BLOCK_EXIT or
     // something similar here)


@@ -219,7 +139,7 @@ int wxEventLoopManual::Run()
 
                 // generate and process idle events for as long as we don't
                 // have anything else to do
 
                 // generate and process idle events for as long as we don't
                 // have anything else to do

-                while ( !Pending() && (wxTheApp && wxTheApp->ProcessIdle()) )
+                while ( !Pending() && ProcessIdle() )

                     ;
 
                 // if the "should exit" flag is set, the loop should terminate
                     ;
 
                 // if the "should exit" flag is set, the loop should terminate


@@ -228,14 +148,15 @@ int wxEventLoopManual::Run()
                 if ( m_shouldExit )
                 {
                     while ( Pending() )
                 if ( m_shouldExit )
                 {
                     while ( Pending() )

-                        Dispatch();
+                        ProcessEvents();

 
                     break;
                 }
 
 
                     break;
                 }
 

-                // a message came or no more idle processing to do, sit in
-                // Dispatch() waiting for the next message
-                if ( !Dispatch() )
+                // a message came or no more idle processing to do, dispatch
+                // all the pending events and call Dispatch() to wait for the
+                // next message
+                if ( !ProcessEvents() )

                 {
                     // we got WM_QUIT
                     break;
                 {
                     // we got WM_QUIT
                     break;


@@ -274,7 +195,7 @@ int wxEventLoopManual::Run()
 
 void wxEventLoopManual::Exit(int rc)
 {
 
 void wxEventLoopManual::Exit(int rc)
 {

-    wxCHECK_RET( IsRunning(), _T("can't call Exit() if not running") );
+    wxCHECK_RET( IsRunning(), wxT("can't call Exit() if not running") );

 
     m_exitcode = rc;
     m_shouldExit = true;
 
     m_exitcode = rc;
     m_shouldExit = true;