1. wxLog::FlushActive() added

2. threads can be used in console mode

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@3877 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

diff --git a/include/wx/log.h b/include/wx/log.h
index 842f1ad48789252b2e59136defd69e37fe0c7174..dfe94e16aca6a2ffde3155a399e9a0980070241d 100644 (file)
--- a/include/wx/log.h
+++ b/include/wx/log.h
@@ -132,6 +132,13 @@ public:
     bool HasPendingMessages() const { return m_bHasMessages; }
 
     // only one sink is active at each moment
+        // flush the active target if any
+    static void FlushActive()
+    {
+        wxLog *log = GetActiveTarget();
+        if ( log )
+            log->Flush();
+    }
         // get current log target, will call wxApp::CreateLogTarget() to
         // create one if none exists
     static wxLog *GetActiveTarget();

diff --git a/samples/console/console.cpp b/samples/console/console.cpp
index e90e7b58589d2df22ce166ff870a44167fa11083..804577456c4b5e4cae1eb5d57571e480cff69a92 100644 (file)
--- a/samples/console/console.cpp
+++ b/samples/console/console.cpp
@@ -12,18 +12,95 @@
 #include <stdio.h>
 
 #include <wx/string.h>
+#include <wx/file.h>
 #include <wx/app.h>
+#include <wx/thread.h>
 
-int main()
+static size_t gs_counter = (size_t)-1;
+static wxCriticalSection gs_critsect;
+
+class MyThread : public wxThread
+{
+public:
+    MyThread(char ch);
+
+    // thread execution starts here
+    virtual void *Entry();
+
+    // and stops here
+    virtual void OnExit();
+
+public:
+    char m_ch;
+};
+
+MyThread::MyThread(char ch)
+{
+    m_ch = ch;
+
+    Create();
+}
+
+void *MyThread::Entry()
+{
+    {
+        wxCriticalSectionLocker lock(gs_critsect);
+        if ( gs_counter == (size_t)-1 )
+            gs_counter = 1;
+        else
+            gs_counter++;
+    }
+
+    for ( size_t n = 0; n < 10; n++ )
+    {
+        if ( TestDestroy() )
+            break;
+
+        putchar(m_ch);
+        fflush(stdout);
+
+        wxThread::Sleep(100);
+    }
+
+    return NULL;
+}
+
+void MyThread::OnExit()
+{
+    wxCriticalSectionLocker lock(gs_critsect);
+    gs_counter--;
+}
+
+int main(int argc, char **argv)
 {
     if ( !wxInitialize() )
     {
         fprintf(stderr, "Failed to initialize the wxWindows library, aborting.");
     }
 
-    wxString s("Hello, ");
+    static const size_t nThreads = 3;
+    MyThread *threads[nThreads];
+    size_t n;
+    for ( n = 0; n < nThreads; n++ )
+    {
+        threads[n] = new MyThread('+' + n);
+        threads[n]->Run();
+    }
+
+    // wait until all threads terminate
+    for ( ;; )
+    {
+        wxCriticalSectionLocker lock(gs_critsect);
+        if ( !gs_counter )
+            break;
+    }
+
+    puts("\nThat's all, folks!");
 
-    wxLogMessage(s + "world!");
+    for ( n = 0; n < nThreads; n++ )
+    {
+        threads[n]->Delete();
+    }
 
     wxUninitialize();
 

diff --git a/src/common/init.cpp b/src/common/init.cpp
index 1af0b671f5f1e07fa48752a1363f4c184c88733e..63cf1f4eceb156f1e90a17d1be28b8fefedb4d25 100644 (file)
--- a/src/common/init.cpp
+++ b/src/common/init.cpp
@@ -33,6 +33,12 @@ wxApp * WXDLLEXPORT wxTheApp = NULL;
 wxAppInitializerFunction
     wxAppBase::m_appInitFn = (wxAppInitializerFunction)NULL;
 
+#if wxUSE_THREADS
+    // List of events pending processing
+    wxList *wxPendingEvents = NULL;
+    wxCriticalSection *wxPendingEventsLocker = NULL;
+#endif // wxUSE_THREADS
+
 // ----------------------------------------------------------------------------
 // private classes
 // ----------------------------------------------------------------------------
@@ -55,7 +61,7 @@ static size_t gs_nInitCount = 0;
 
 bool WXDLLEXPORT wxInitialize()
 {
-    if ( gs_nInitCount++ )
+    if ( gs_nInitCount )
     {
         // already initialized
         return TRUE;
@@ -64,15 +70,34 @@ bool WXDLLEXPORT wxInitialize()
     wxASSERT_MSG( !wxTheApp,
                   T("either call wxInitialize or create app, not both!") );
 
+    wxClassInfo::InitializeClasses();
+
+    wxModule::RegisterModules();
+    if ( !wxModule::InitializeModules() )
+    {
+        return FALSE;
+    }
+
     wxTheApp = new wxConsoleApp;
 
-    return wxTheApp != NULL;
+    if ( !wxTheApp )
+    {
+        return FALSE;
+    }
+
+    gs_nInitCount++;
+
+    return TRUE;
 }
 
 void WXDLLEXPORT wxUninitialize()
 {
     if ( !--gs_nInitCount )
     {
+        wxModule::CleanUpModules();
+
+        wxClassInfo::CleanUpClasses();
+
         // delete the application object
         delete wxTheApp;
         wxTheApp = (wxApp *)NULL;

diff --git a/src/unix/threadpsx.cpp b/src/unix/threadpsx.cpp
index 513600f3b19133316f8de7f1c22eeab28ed4df22..701bf1eb1d54c742121a1ea19a156fac1e58e991 100644 (file)
--- a/src/unix/threadpsx.cpp
+++ b/src/unix/threadpsx.cpp
@@ -351,6 +351,8 @@ wxThreadInternal::wxThreadInternal()
 {
     m_state = STATE_NEW;
     m_cancelled = FALSE;
+    m_prio = WXTHREAD_DEFAULT_PRIORITY;
+    m_threadId = 0;
 
     // this mutex is locked during almost all thread lifetime - it will only be
     // unlocked in the very end
@@ -536,6 +538,17 @@ wxThreadError wxThread::Create()
         wxLogError(_("Cannot get priority range for scheduling policy %d."),
                    prio);
     }
+    else if ( max_prio == min_prio )
+    {
+        if ( p_internal->GetPriority() != WXTHREAD_DEFAULT_PRIORITY )
+        {
+            // notify the programmer that this doesn't work here
+            wxLogWarning(_("Thread priority setting is ignored."));
+        }
+        //else: we have default priority, so don't complain
+
+        // anyhow, don't do anything because priority is just ignored
+    }
     else
     {
         struct sched_param sp;
@@ -567,6 +580,9 @@ wxThreadError wxThread::Create()
 
 wxThreadError wxThread::Run()
 {
+    wxCHECK_MSG( p_internal->GetId(), wxTHREAD_MISC_ERROR,
+                 T("must call wxThread::Create() first") );
+
     return p_internal->Run();
 }
 
@@ -720,8 +736,8 @@ wxThreadError wxThread::Kill()
 
                 return wxTHREAD_MISC_ERROR;
             }
-           //GL: As we must auto-destroy, the destruction must happen here (2).
-           delete this;
+            //GL: As we must auto-destroy, the destruction must happen here (2).
+            delete this;
 
             return wxTHREAD_NO_ERROR;
     }
@@ -767,13 +783,17 @@ bool wxThread::TestDestroy()
 wxThread::~wxThread()
 {
     m_critsect.Enter();
-    if (p_internal->GetState() != STATE_EXITED &&
-        p_internal->GetState() != STATE_NEW)
-      wxLogDebug(T("The thread is being destroyed althought it is still running ! The application may crash."));
+    if ( p_internal->GetState() != STATE_EXITED &&
+         p_internal->GetState() != STATE_NEW )
+    {
+        wxLogDebug(T("The thread is being destroyed although it is still "
+                     "running! The application may crash."));
+    }
 
     m_critsect.Leave();
 
     delete p_internal;
+
     // remove this thread from the global array
     gs_allThreads.Remove(this);
 }
@@ -858,8 +878,8 @@ void wxThreadModule::OnExit()
 
     for ( size_t n = 0u; n < count; n++ )
     {
-       // Delete calls the destructor which removes the current entry. We
-       // should only delete the first one each time.
+        // Delete calls the destructor which removes the current entry. We
+        // should only delete the first one each time.
         gs_allThreads[0]->Delete();
     }