ensure all topic overviews have an horizontal rule with the list of the sections...

[wxWidgets.git] / samples / thread / thread.cpp

diff --git a/samples/thread/thread.cpp b/samples/thread/thread.cpp
index 25cec9bb13b49b855a811009d9ae333c268a105b..d85db154a444d8a31f3aa468fb912bd2e8a1d17e 100644 (file)
--- a/samples/thread/thread.cpp
+++ b/samples/thread/thread.cpp
@@ -1,11 +1,11 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        thread.cpp
 /////////////////////////////////////////////////////////////////////////////
 // Name:        thread.cpp

-// Purpose:     wxWindows thread sample
+// Purpose:     wxWidgets thread sample

 // Author:      Guilhem Lavaux, Vadim Zeitlin
 // Modified by:
 // Created:     06/16/98
 // RCS-ID:      $Id$
 // Author:      Guilhem Lavaux, Vadim Zeitlin
 // Modified by:
 // Created:     06/16/98
 // RCS-ID:      $Id$

-// Copyright:   (c) 1998-2002 wxWindows team
+// Copyright:   (c) 1998-2002 wxWidgets team

 // Licence:     wxWindows license
 /////////////////////////////////////////////////////////////////////////////
 
 // Licence:     wxWindows license
 /////////////////////////////////////////////////////////////////////////////
 


@@ -26,10 +26,12 @@
 
 #include "wx/thread.h"
 #include "wx/dynarray.h"
 
 #include "wx/thread.h"
 #include "wx/dynarray.h"

-#include "wx/time.h"
+#include "wx/numdlg.h"

 
 #include "wx/progdlg.h"
 
 
 #include "wx/progdlg.h"
 

+#include "../sample.xpm"
+

 // define this to use wxExecute in the exec tests, otherwise just use system
 #define USE_EXECUTE
 
 // define this to use wxExecute in the exec tests, otherwise just use system
 #define USE_EXECUTE
 


@@ -40,14 +42,14 @@
 #endif
 
 class MyThread;
 #endif
 
 class MyThread;

-WX_DEFINE_ARRAY(wxThread *, wxArrayThread);
+WX_DEFINE_ARRAY_PTR(wxThread *, wxArrayThread);

 
 // Define a new application type
 class MyApp : public wxApp
 {
 public:
     MyApp();
 
 // Define a new application type
 class MyApp : public wxApp
 {
 public:
     MyApp();

-    virtual ~MyApp();
+    virtual ~MyApp(){};

 
     virtual bool OnInit();
 
 
     virtual bool OnInit();
 


@@ -59,12 +61,10 @@ public:
     // crit section protects access to all of the arrays below
     wxCriticalSection m_critsect;
 
     // crit section protects access to all of the arrays below
     wxCriticalSection m_critsect;
 

-    // the (mutex, condition) pair used to wait for the threads to exit, see
-    // MyFrame::OnQuit()
-    wxMutex m_mutexAllDone;
-    wxCondition m_condAllDone;
+    // semaphore used to wait for the threads to exit, see MyFrame::OnQuit()
+    wxSemaphore m_semAllDone;

 
 

-    // the last exiting thread should signal m_condAllDone if this is true
+    // the last exiting thread should post to m_semAllDone if this is true

     // (protected by the same m_critsect)
     bool m_waitingUntilAllDone;
 };
     // (protected by the same m_critsect)
     bool m_waitingUntilAllDone;
 };


@@ -78,6 +78,7 @@ class MyFrame: public wxFrame
 public:
     // ctor
     MyFrame(wxFrame *frame, const wxString& title, int x, int y, int w, int h);
 public:
     // ctor
     MyFrame(wxFrame *frame, const wxString& title, int x, int y, int w, int h);

+    virtual ~MyFrame();

 
     // operations
     void WriteText(const wxString& text) { m_txtctrl->WriteText(text); }
 
     // operations
     void WriteText(const wxString& text) { m_txtctrl->WriteText(text); }


@@ -133,7 +134,8 @@ private:
 // ID for the menu commands
 enum
 {
 // ID for the menu commands
 enum
 {

-    THREAD_QUIT          = 1,
+    THREAD_QUIT  = wxID_EXIT,
+    THREAD_ABOUT = wxID_ABOUT,

     THREAD_TEXT          = 101,
     THREAD_CLEAR,
     THREAD_START_THREAD  = 201,
     THREAD_TEXT          = 101,
     THREAD_CLEAR,
     THREAD_START_THREAD  = 201,


@@ -147,7 +149,6 @@ enum
     THREAD_EXEC_THREAD,
 
     THREAD_SHOWCPUS,
     THREAD_EXEC_THREAD,
 
     THREAD_SHOWCPUS,

-    THREAD_ABOUT,

 
     WORKER_EVENT    // this one gets sent from the worker thread
 };
 
     WORKER_EVENT    // this one gets sent from the worker thread
 };


@@ -172,7 +173,7 @@ public:
     void WriteText(const wxString& text);
 
 public:
     void WriteText(const wxString& text);
 
 public:

-    size_t   m_count;
+    unsigned m_count;

     MyFrame *m_frame;
 };
 
     MyFrame *m_frame;
 };
 


@@ -211,10 +212,9 @@ void MyThread::OnExit()
         // waiting for us
         if ( wxGetApp().m_waitingUntilAllDone )
         {
         // waiting for us
         if ( wxGetApp().m_waitingUntilAllDone )
         {

-            wxGetApp().m_waitingUntilAllDone = FALSE;
+            wxGetApp().m_waitingUntilAllDone = false;

 
 

-            wxMutexLocker lock(wxGetApp().m_mutexAllDone);
-            wxGetApp().m_condAllDone.Signal();
+            wxGetApp().m_semAllDone.Post();

         }
     }
 }
         }
     }
 }


@@ -223,7 +223,7 @@ void *MyThread::Entry()
 {
     wxString text;
 
 {
     wxString text;
 

-    text.Printf(wxT("Thread 0x%x started (priority = %u).\n"),
+    text.Printf(wxT("Thread 0x%lx started (priority = %u).\n"),

                 GetId(), GetPriority());
     WriteText(text);
     // wxLogMessage(text); -- test wxLog thread safeness
                 GetId(), GetPriority());
     WriteText(text);
     // wxLogMessage(text); -- test wxLog thread safeness


@@ -234,14 +234,14 @@ void *MyThread::Entry()
         if ( TestDestroy() )
             break;
 
         if ( TestDestroy() )
             break;
 

-        text.Printf(wxT("[%u] Thread 0x%x here.\n"), m_count, GetId());
+        text.Printf(wxT("[%u] Thread 0x%lx here.\n"), m_count, GetId());

         WriteText(text);
 
         // wxSleep() can't be called from non-GUI thread!
         wxThread::Sleep(1000);
     }
 
         WriteText(text);
 
         // wxSleep() can't be called from non-GUI thread!
         wxThread::Sleep(1000);
     }
 

-    text.Printf(wxT("Thread 0x%x finished.\n"), GetId());
+    text.Printf(wxT("Thread 0x%lx finished.\n"), GetId());

     WriteText(text);
     // wxLogMessage(text); -- test wxLog thread safeness
 
     WriteText(text);
     // wxLogMessage(text); -- test wxLog thread safeness
 


@@ -266,7 +266,7 @@ public:
 
 public:
     MyFrame *m_frame;
 
 public:
     MyFrame *m_frame;

-    size_t   m_count;
+    unsigned m_count;

 };
 
 MyWorkerThread::MyWorkerThread(MyFrame *frame)
 };
 
 MyWorkerThread::MyWorkerThread(MyFrame *frame)


@@ -355,30 +355,23 @@ BEGIN_EVENT_TABLE(MyFrame, wxFrame)
 END_EVENT_TABLE()
 
 MyApp::MyApp()
 END_EVENT_TABLE()
 
 MyApp::MyApp()

-     : m_condAllDone(m_mutexAllDone)
-{
-    // the mutex associated with a condition must be initially locked, it will
-    // only be unlocked when we call Wait()
-    m_mutexAllDone.Lock();
-
-    m_waitingUntilAllDone = FALSE;
-}
-
-MyApp::~MyApp()
+     : m_semAllDone()

 {
 {

-    // the mutex must be unlocked before being destroyed
-    m_mutexAllDone.Unlock();
+    m_waitingUntilAllDone = false;

 }
 
 // `Main program' equivalent, creating windows and returning main app frame
 bool MyApp::OnInit()
 {
 }
 
 // `Main program' equivalent, creating windows and returning main app frame
 bool MyApp::OnInit()
 {

+    if ( !wxApp::OnInit() )
+        return false;
+

     // uncomment this to get some debugging messages from the trace code
     // on the console (or just set WXTRACE env variable to include "thread")
     //wxLog::AddTraceMask("thread");
 
     // Create the main frame window
     // uncomment this to get some debugging messages from the trace code
     // on the console (or just set WXTRACE env variable to include "thread")
     //wxLog::AddTraceMask("thread");
 
     // Create the main frame window

-    MyFrame *frame = new MyFrame((wxFrame *)NULL, _T("wxWindows threads sample"),
+    MyFrame *frame = new MyFrame((wxFrame *)NULL, _T("wxWidgets threads sample"),

                                  50, 50, 450, 340);
 
     // Make a menubar
                                  50, 50, 450, 340);
 
     // Make a menubar


@@ -413,31 +406,80 @@ bool MyApp::OnInit()
     menuBar->Append(menuHelp, _T("&Help"));
 
     frame->SetMenuBar(menuBar);
     menuBar->Append(menuHelp, _T("&Help"));
 
     frame->SetMenuBar(menuBar);

-
+    

     // Show the frame
     // Show the frame

-    frame->Show(TRUE);
+    frame->Show(true);

 
     SetTopWindow(frame);
 
 
     SetTopWindow(frame);
 

-    return TRUE;
+    return true;

 }
 
 // My frame constructor
 MyFrame::MyFrame(wxFrame *frame, const wxString& title,
                  int x, int y, int w, int h)
 }
 
 // My frame constructor
 MyFrame::MyFrame(wxFrame *frame, const wxString& title,
                  int x, int y, int w, int h)

-       : wxFrame(frame, -1, title, wxPoint(x, y), wxSize(w, h))
+       : wxFrame(frame, wxID_ANY, title, wxPoint(x, y), wxSize(w, h))

 {
 {

+    SetIcon(wxIcon(sample_xpm));
+    

     m_nRunning = m_nCount = 0;
 
     m_dlgProgress = (wxProgressDialog *)NULL;
 
     m_nRunning = m_nCount = 0;
 
     m_dlgProgress = (wxProgressDialog *)NULL;
 

+#if wxUSE_STATUSBAR

     CreateStatusBar(2);
     CreateStatusBar(2);

+#endif // wxUSE_STATUSBAR

 
 

-    m_txtctrl = new wxTextCtrl(this, -1, _T(""), wxPoint(0, 0), wxSize(0, 0),
+    m_txtctrl = new wxTextCtrl(this, wxID_ANY, _T(""), wxPoint(0, 0), wxSize(0, 0),

                                wxTE_MULTILINE | wxTE_READONLY);
 
 }
 
                                wxTE_MULTILINE | wxTE_READONLY);
 
 }
 

+MyFrame::~MyFrame()
+{
+    // NB: although the OS will terminate all the threads anyhow when the main
+    //     one exits, it's good practice to do it ourselves -- even if it's not
+    //     completely trivial in this example
+
+    // tell all the threads to terminate: note that they can't terminate while
+    // we're deleting them because they will block in their OnExit() -- this is
+    // important as otherwise we might access invalid array elements
+    wxThread *thread;
+
+    wxGetApp().m_critsect.Enter();
+
+    // check if we have any threads running first
+    const wxArrayThread& threads = wxGetApp().m_threads;
+    size_t count = threads.GetCount();
+
+    if ( count )
+    {
+        // set the flag for MyThread::OnExit()
+        wxGetApp().m_waitingUntilAllDone = true;
+
+        // stop all threads
+        while ( ! threads.IsEmpty() )
+        {
+            thread = threads.Last();
+
+            wxGetApp().m_critsect.Leave();
+
+            thread->Delete();
+
+            wxGetApp().m_critsect.Enter();
+        }
+    }
+
+    wxGetApp().m_critsect.Leave();
+
+    if ( count )
+    {
+        // now wait for them to really terminate
+        wxGetApp().m_semAllDone.Wait();
+    }
+    //else: no threads to terminate, no condition to wait for
+}
+

 MyThread *MyFrame::CreateThread()
 {
     MyThread *thread = new MyThread(this);
 MyThread *MyFrame::CreateThread()
 {
     MyThread *thread = new MyThread(this);


@@ -455,7 +497,7 @@ MyThread *MyFrame::CreateThread()
 
 void MyFrame::OnStartThreads(wxCommandEvent& WXUNUSED(event) )
 {
 
 void MyFrame::OnStartThreads(wxCommandEvent& WXUNUSED(event) )
 {

-    static long s_num = 10;
+    static long s_num;

 
     s_num = wxGetNumberFromUser(_T("How many threads to start: "), _T(""),
                                 _T("wxThread sample"), s_num, 1, 10000, this);
 
     s_num = wxGetNumberFromUser(_T("How many threads to start: "), _T(""),
                                 _T("wxThread sample"), s_num, 1, 10000, this);


@@ -466,7 +508,7 @@ void MyFrame::OnStartThreads(wxCommandEvent& WXUNUSED(event) )
         return;
     }
 
         return;
     }
 

-    size_t count = (size_t)s_num, n;
+    unsigned count = unsigned(s_num), n;

 
     wxArrayThread threads;
 
 
     wxArrayThread threads;
 


@@ -488,9 +530,11 @@ void MyFrame::OnStartThreads(wxCommandEvent& WXUNUSED(event) )
         threads.Add(thr);
     }
 
         threads.Add(thr);
     }
 

+#if wxUSE_STATUSBAR

     wxString msg;
     msg.Printf(wxT("%d new threads created."), count);
     SetStatusText(msg, 1);
     wxString msg;
     msg.Printf(wxT("%d new threads created."), count);
     SetStatusText(msg, 1);

+#endif // wxUSE_STATUSBAR

 
     // ...and then start them
     for ( n = 0; n < count; n++ )
 
     // ...and then start them
     for ( n = 0; n < count; n++ )


@@ -508,7 +552,9 @@ void MyFrame::OnStartThread(wxCommandEvent& WXUNUSED(event) )
         wxLogError(wxT("Can't start thread!"));
     }
 
         wxLogError(wxT("Can't start thread!"));
     }
 

+#if wxUSE_STATUSBAR

     SetStatusText(_T("New thread started."), 1);
     SetStatusText(_T("New thread started."), 1);

+#endif // wxUSE_STATUSBAR

 }
 
 void MyFrame::OnStopThread(wxCommandEvent& WXUNUSED(event) )
 }
 
 void MyFrame::OnStopThread(wxCommandEvent& WXUNUSED(event) )


@@ -533,7 +579,9 @@ void MyFrame::OnStopThread(wxCommandEvent& WXUNUSED(event) )
 
         thread->Delete();
 
 
         thread->Delete();
 

+#if wxUSE_STATUSBAR

         SetStatusText(_T("Thread stopped."), 1);
         SetStatusText(_T("Thread stopped."), 1);

+#endif // wxUSE_STATUSBAR

     }
 }
 
     }
 }
 


@@ -554,7 +602,9 @@ void MyFrame::OnResumeThread(wxCommandEvent& WXUNUSED(event) )
     {
         wxGetApp().m_threads[n]->Resume();
 
     {
         wxGetApp().m_threads[n]->Resume();
 

+#if wxUSE_STATUSBAR

         SetStatusText(_T("Thread resumed."), 1);
         SetStatusText(_T("Thread resumed."), 1);

+#endif // wxUSE_STATUSBAR

     }
 }
 
     }
 }
 


@@ -575,12 +625,14 @@ void MyFrame::OnPauseThread(wxCommandEvent& WXUNUSED(event) )
     {
         wxGetApp().m_threads[n]->Pause();
 
     {
         wxGetApp().m_threads[n]->Pause();
 

+#if wxUSE_STATUSBAR

         SetStatusText(_T("Thread paused."), 1);
         SetStatusText(_T("Thread paused."), 1);

+#endif // wxUSE_STATUSBAR

     }
 }
 
 // set the frame title indicating the current number of threads
     }
 }
 
 // set the frame title indicating the current number of threads

-void MyFrame::OnIdle(wxIdleEvent &event)
+void MyFrame::OnIdle(wxIdleEvent& event)

 {
     wxCriticalSectionLocker enter(wxGetApp().m_critsect);
 
 {
     wxCriticalSectionLocker enter(wxGetApp().m_critsect);
 


@@ -598,55 +650,16 @@ void MyFrame::OnIdle(wxIdleEvent &event)
         m_nRunning = nRunning;
         m_nCount = nCount;
 
         m_nRunning = nRunning;
         m_nCount = nCount;
 

-        wxLogStatus(this, wxT("%u threads total, %u running."), nCount, nRunning);
+        wxLogStatus(this, wxT("%u threads total, %u running."), unsigned(nCount), unsigned(nRunning));

     }
     //else: avoid flicker - don't print anything
     }
     //else: avoid flicker - don't print anything

+
+    event.Skip();

 }
 
 void MyFrame::OnQuit(wxCommandEvent& WXUNUSED(event) )
 {
 }
 
 void MyFrame::OnQuit(wxCommandEvent& WXUNUSED(event) )
 {

-    // NB: although the OS will terminate all the threads anyhow when the main
-    //     one exits, it's good practice to do it ourselves -- even if it's not
-    //     completely trivial in this example
-
-    // tell all the threads to terminate: note that they can't terminate while
-    // we're deleting them because they will block in their OnExit() -- this is
-    // important as otherwise we might access invalid array elements
-    {
-        wxGetApp().m_critsect.Enter();
-
-        // check if we have any threads running first
-        const wxArrayThread& threads = wxGetApp().m_threads;
-        size_t count = threads.GetCount();
-
-        if ( count )
-        {
-            // we do, ask them to stop
-            for ( size_t n = 0; n < count; n++ )
-            {
-                threads[n]->Delete();
-            }
-
-            // set the flag for MyThread::OnExit()
-            wxGetApp().m_waitingUntilAllDone = TRUE;
-        }
-
-        wxGetApp().m_critsect.Leave();
-
-        if ( count )
-        {
-            // now wait for them to really terminate but leave the GUI mutex
-            // before doing it as otherwise we might dead lock
-            wxMutexGuiLeave();
-
-            wxGetApp().m_condAllDone.Wait();
-
-            wxMutexGuiEnter();
-        }
-        //else: no threads to terminate, no condition to wait for
-    }
-
-    Close(TRUE);
+    Close(true);

 }
 
 void MyFrame::OnExecMain(wxCommandEvent& WXUNUSED(event))
 }
 
 void MyFrame::OnExecMain(wxCommandEvent& WXUNUSED(event))


@@ -686,14 +699,14 @@ void MyFrame::OnShowCPUs(wxCommandEvent& WXUNUSED(event))
         default:
             msg.Printf(wxT("This system has %d CPUs"), nCPUs);
     }
         default:
             msg.Printf(wxT("This system has %d CPUs"), nCPUs);
     }

-            
+

     wxLogMessage(msg);
 }
 
 void MyFrame::OnAbout(wxCommandEvent& WXUNUSED(event) )
 {
     wxLogMessage(msg);
 }
 
 void MyFrame::OnAbout(wxCommandEvent& WXUNUSED(event) )
 {

-    wxMessageDialog dialog(this, 
-                           _T("wxWindows multithreaded application sample\n")
+    wxMessageDialog dialog(this,
+                           _T("wxWidgets multithreaded application sample\n")

                            _T("(c) 1998 Julian Smart, Guilhem Lavaux\n")
                            _T("(c) 1999 Vadim Zeitlin\n")
                            _T("(c) 2000 Robert Roebling"),
                            _T("(c) 1998 Julian Smart, Guilhem Lavaux\n")
                            _T("(c) 1999 Vadim Zeitlin\n")
                            _T("(c) 2000 Robert Roebling"),


@@ -720,6 +733,7 @@ void MyFrame::OnStartWorker(wxCommandEvent& WXUNUSED(event))
     if ( thread->Create() != wxTHREAD_NO_ERROR )
     {
         wxLogError(wxT("Can't create thread!"));
     if ( thread->Create() != wxTHREAD_NO_ERROR )
     {
         wxLogError(wxT("Can't create thread!"));

+        return;

     }
 
     m_dlgProgress = new wxProgressDialog
     }
 
     m_dlgProgress = new wxProgressDialog


@@ -736,7 +750,7 @@ void MyFrame::OnStartWorker(wxCommandEvent& WXUNUSED(event))
                         );
 
     // thread is not running yet, no need for crit sect
                         );
 
     // thread is not running yet, no need for crit sect

-    m_cancelled = FALSE;
+    m_cancelled = false;

 
     thread->Run();
 }
 
     thread->Run();
 }


@@ -765,7 +779,7 @@ void MyFrame::OnWorkerEvent(wxCommandEvent& event)
         {
             wxCriticalSectionLocker lock(m_critsectWork);
 
         {
             wxCriticalSectionLocker lock(m_critsectWork);
 

-            m_cancelled = TRUE;
+            m_cancelled = true;

         }
     }
 #endif
         }
     }
 #endif