samples/thread/thread.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        thread.cpp
   3 // Purpose:     wxWidgets thread sample
   4 // Author:      Guilhem Lavaux, Vadim Zeitlin
   5 // Modified by:
   6 // Created:     06/16/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 1998-2002 wxWidgets team
   9 // Licence:     wxWindows license
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // For compilers that support precompilation, includes "wx/wx.h".
  13 #include "wx/wxprec.h"
  14
  15 #ifdef __BORLANDC__
  16     #pragma hdrstop
  17 #endif
  18
  19 #ifndef WX_PRECOMP
  20     #include "wx/wx.h"
  21 #endif
  22
  23 #if !wxUSE_THREADS
  24     #error "This sample requires thread support!"
  25 #endif // wxUSE_THREADS
  26
  27 #include "wx/thread.h"
  28 #include "wx/dynarray.h"
  29 #include "wx/numdlg.h"
  30
  31 #include "wx/progdlg.h"
  32
  33 #include "../sample.xpm"
  34
  35 // define this to use wxExecute in the exec tests, otherwise just use system
  36 #define USE_EXECUTE
  37
  38 #ifdef USE_EXECUTE
  39     #define EXEC(cmd) wxExecute((cmd), wxEXEC_SYNC)
  40 #else
  41     #define EXEC(cmd) system(cmd)
  42 #endif
  43
  44 class MyThread;
  45 WX_DEFINE_ARRAY_PTR(wxThread *, wxArrayThread);
  46
  47 // Define a new application type
  48 class MyApp : public wxApp
  49 {
  50 public:
  51     MyApp();
  52     virtual ~MyApp(){};
  53
  54     virtual bool OnInit();
  55
  56 public:
  57     // all the threads currently alive - as soon as the thread terminates, it's
  58     // removed from the array
  59     wxArrayThread m_threads;
  60
  61     // crit section protects access to all of the arrays below
  62     wxCriticalSection m_critsect;
  63
  64     // semaphore used to wait for the threads to exit, see MyFrame::OnQuit()
  65     wxSemaphore m_semAllDone;
  66
  67     // the last exiting thread should post to m_semAllDone if this is true
  68     // (protected by the same m_critsect)
  69     bool m_waitingUntilAllDone;
  70 };
  71
  72 // Create a new application object
  73 IMPLEMENT_APP(MyApp)
  74
  75 // Define a new frame type
  76 class MyFrame: public wxFrame
  77 {
  78 public:
  79     // ctor
  80     MyFrame(wxFrame *frame, const wxString& title, int x, int y, int w, int h);
  81     virtual ~MyFrame();
  82
  83     // operations
  84     void WriteText(const wxString& text) { m_txtctrl->WriteText(text); }
  85
  86     // accessors for MyWorkerThread (called in its context!)
  87     bool Cancelled();
  88
  89 protected:
  90     // callbacks
  91     void OnQuit(wxCommandEvent& event);
  92     void OnClear(wxCommandEvent& event);
  93
  94     void OnStartThread(wxCommandEvent& event);
  95     void OnStartThreads(wxCommandEvent& event);
  96     void OnStopThread(wxCommandEvent& event);
  97     void OnPauseThread(wxCommandEvent& event);
  98     void OnResumeThread(wxCommandEvent& event);
  99
 100     void OnStartWorker(wxCommandEvent& event);
 101     void OnWorkerEvent(wxCommandEvent& event);
 102     void OnUpdateWorker(wxUpdateUIEvent& event);
 103
 104     void OnExecMain(wxCommandEvent& event);
 105     void OnExecThread(wxCommandEvent& event);
 106
 107     void OnShowCPUs(wxCommandEvent& event);
 108     void OnAbout(wxCommandEvent& event);
 109
 110     void OnIdle(wxIdleEvent &event);
 111
 112 private:
 113     // helper function - creates a new thread (but doesn't run it)
 114     MyThread *CreateThread();
 115
 116     // just some place to put our messages in
 117     wxTextCtrl *m_txtctrl;
 118
 119     // remember the number of running threads and total number of threads
 120     size_t m_nRunning, m_nCount;
 121
 122     // the progress dialog which we show while worker thread is running
 123     wxProgressDialog *m_dlgProgress;
 124
 125     // was the worker thread cancelled by user?
 126     bool m_cancelled;
 127
 128     // protects m_cancelled
 129     wxCriticalSection m_critsectWork;
 130
 131     DECLARE_EVENT_TABLE()
 132 };
 133
 134 // ID for the menu commands
 135 enum
 136 {
 137     THREAD_QUIT  = wxID_EXIT,
 138     THREAD_ABOUT = wxID_ABOUT,
 139     THREAD_TEXT          = 101,
 140     THREAD_CLEAR,
 141     THREAD_START_THREAD  = 201,
 142     THREAD_START_THREADS,
 143     THREAD_STOP_THREAD,
 144     THREAD_PAUSE_THREAD,
 145     THREAD_RESUME_THREAD,
 146     THREAD_START_WORKER,
 147
 148     THREAD_EXEC_MAIN,
 149     THREAD_EXEC_THREAD,
 150
 151     THREAD_SHOWCPUS,
 152
 153     WORKER_EVENT    // this one gets sent from the worker thread
 154 };
 155
 156 // ----------------------------------------------------------------------------
 157 // GUI thread
 158 // ----------------------------------------------------------------------------
 159
 160 class MyThread : public wxThread
 161 {
 162 public:
 163     MyThread(MyFrame *frame);
 164
 165     // thread execution starts here
 166     virtual void *Entry();
 167
 168     // called when the thread exits - whether it terminates normally or is
 169     // stopped with Delete() (but not when it is Kill()ed!)
 170     virtual void OnExit();
 171
 172     // write something to the text control
 173     void WriteText(const wxString& text);
 174
 175 public:
 176     unsigned m_count;
 177     MyFrame *m_frame;
 178 };
 179
 180 MyThread::MyThread(MyFrame *frame)
 181         : wxThread()
 182 {
 183     m_count = 0;
 184     m_frame = frame;
 185 }
 186
 187 void MyThread::WriteText(const wxString& text)
 188 {
 189     wxString msg;
 190
 191     // before doing any GUI calls we must ensure that this thread is the only
 192     // one doing it!
 193
 194     wxMutexGuiEnter();
 195
 196     msg << text;
 197     m_frame->WriteText(msg);
 198
 199     wxMutexGuiLeave();
 200 }
 201
 202 void MyThread::OnExit()
 203 {
 204     wxCriticalSectionLocker locker(wxGetApp().m_critsect);
 205
 206     wxArrayThread& threads = wxGetApp().m_threads;
 207     threads.Remove(this);
 208
 209     if ( threads.IsEmpty() )
 210     {
 211         // signal the main thread that there are no more threads left if it is
 212         // waiting for us
 213         if ( wxGetApp().m_waitingUntilAllDone )
 214         {
 215             wxGetApp().m_waitingUntilAllDone = false;
 216
 217             wxGetApp().m_semAllDone.Post();
 218         }
 219     }
 220 }
 221
 222 void *MyThread::Entry()
 223 {
 224     wxString text;
 225
 226     text.Printf(wxT("Thread 0x%lx started (priority = %u).\n"),
 227                 GetId(), GetPriority());
 228     WriteText(text);
 229     // wxLogMessage(text); -- test wxLog thread safeness
 230
 231     for ( m_count = 0; m_count < 10; m_count++ )
 232     {
 233         // check if we were asked to exit
 234         if ( TestDestroy() )
 235             break;
 236
 237         text.Printf(wxT("[%u] Thread 0x%lx here.\n"), m_count, GetId());
 238         WriteText(text);
 239
 240         // wxSleep() can't be called from non-GUI thread!
 241         wxThread::Sleep(1000);
 242     }
 243
 244     text.Printf(wxT("Thread 0x%lx finished.\n"), GetId());
 245     WriteText(text);
 246     // wxLogMessage(text); -- test wxLog thread safeness
 247
 248     return NULL;
 249 }
 250
 251 // ----------------------------------------------------------------------------
 252 // worker thread
 253 // ----------------------------------------------------------------------------
 254
 255 class MyWorkerThread : public wxThread
 256 {
 257 public:
 258     MyWorkerThread(MyFrame *frame);
 259
 260     // thread execution starts here
 261     virtual void *Entry();
 262
 263     // called when the thread exits - whether it terminates normally or is
 264     // stopped with Delete() (but not when it is Kill()ed!)
 265     virtual void OnExit();
 266
 267 public:
 268     MyFrame *m_frame;
 269     unsigned m_count;
 270 };
 271
 272 MyWorkerThread::MyWorkerThread(MyFrame *frame)
 273         : wxThread()
 274 {
 275     m_frame = frame;
 276     m_count = 0;
 277 }
 278
 279 void MyWorkerThread::OnExit()
 280 {
 281 }
 282
 283 void *MyWorkerThread::Entry()
 284 {
 285     for ( m_count = 0; !m_frame->Cancelled() && (m_count < 100); m_count++ )
 286     {
 287         // check if we were asked to exit
 288         if ( TestDestroy() )
 289             break;
 290
 291         // create any type of command event here
 292         wxCommandEvent event( wxEVT_COMMAND_MENU_SELECTED, WORKER_EVENT );
 293         event.SetInt( m_count );
 294
 295         // send in a thread-safe way
 296         wxPostEvent( m_frame, event );
 297
 298         // wxSleep() can't be called from non-main thread!
 299         wxThread::Sleep(200);
 300     }
 301
 302     wxCommandEvent event( wxEVT_COMMAND_MENU_SELECTED, WORKER_EVENT );
 303     event.SetInt(-1); // that's all
 304     wxPostEvent( m_frame, event );
 305
 306     return NULL;
 307 }
 308
 309 // ----------------------------------------------------------------------------
 310 // a thread which simply calls wxExecute
 311 // ----------------------------------------------------------------------------
 312
 313 class MyExecThread : public wxThread
 314 {
 315 public:
 316     MyExecThread(const wxChar *command) : wxThread(wxTHREAD_JOINABLE),
 317                                           m_command(command)
 318     {
 319         Create();
 320     }
 321
 322     virtual ExitCode Entry()
 323     {
 324         return wxUIntToPtr(EXEC(m_command));
 325     }
 326
 327 private:
 328     wxString m_command;
 329 };
 330
 331 // ----------------------------------------------------------------------------
 332 // implementation
 333 // ----------------------------------------------------------------------------
 334
 335 BEGIN_EVENT_TABLE(MyFrame, wxFrame)
 336     EVT_MENU(THREAD_QUIT, MyFrame::OnQuit)
 337     EVT_MENU(THREAD_CLEAR, MyFrame::OnClear)
 338     EVT_MENU(THREAD_START_THREAD, MyFrame::OnStartThread)
 339     EVT_MENU(THREAD_START_THREADS, MyFrame::OnStartThreads)
 340     EVT_MENU(THREAD_STOP_THREAD, MyFrame::OnStopThread)
 341     EVT_MENU(THREAD_PAUSE_THREAD, MyFrame::OnPauseThread)
 342     EVT_MENU(THREAD_RESUME_THREAD, MyFrame::OnResumeThread)
 343
 344     EVT_MENU(THREAD_EXEC_MAIN, MyFrame::OnExecMain)
 345     EVT_MENU(THREAD_EXEC_THREAD, MyFrame::OnExecThread)
 346
 347     EVT_MENU(THREAD_SHOWCPUS, MyFrame::OnShowCPUs)
 348     EVT_MENU(THREAD_ABOUT, MyFrame::OnAbout)
 349
 350     EVT_UPDATE_UI(THREAD_START_WORKER, MyFrame::OnUpdateWorker)
 351     EVT_MENU(THREAD_START_WORKER, MyFrame::OnStartWorker)
 352     EVT_MENU(WORKER_EVENT, MyFrame::OnWorkerEvent)
 353
 354     EVT_IDLE(MyFrame::OnIdle)
 355 END_EVENT_TABLE()
 356
 357 MyApp::MyApp()
 358      : m_semAllDone()
 359 {
 360     m_waitingUntilAllDone = false;
 361 }
 362
 363 // `Main program' equivalent, creating windows and returning main app frame
 364 bool MyApp::OnInit()
 365 {
 366     if ( !wxApp::OnInit() )
 367         return false;
 368
 369     // uncomment this to get some debugging messages from the trace code
 370     // on the console (or just set WXTRACE env variable to include "thread")
 371     //wxLog::AddTraceMask("thread");
 372
 373     // Create the main frame window
 374     MyFrame *frame = new MyFrame((wxFrame *)NULL, _T("wxWidgets threads sample"),
 375                                  50, 50, 450, 340);
 376
 377     // Make a menubar
 378     wxMenuBar *menuBar = new wxMenuBar;
 379
 380     wxMenu *menuFile = new wxMenu;
 381     menuFile->Append(THREAD_CLEAR, _T("&Clear log\tCtrl-L"));
 382     menuFile->AppendSeparator();
 383     menuFile->Append(THREAD_QUIT, _T("E&xit\tAlt-X"));
 384     menuBar->Append(menuFile, _T("&File"));
 385
 386     wxMenu *menuThread = new wxMenu;
 387     menuThread->Append(THREAD_START_THREAD, _T("&Start a new thread\tCtrl-N"));
 388     menuThread->Append(THREAD_START_THREADS, _T("Start &many threads at once"));
 389     menuThread->Append(THREAD_STOP_THREAD, _T("S&top a running thread\tCtrl-S"));
 390     menuThread->AppendSeparator();
 391     menuThread->Append(THREAD_PAUSE_THREAD, _T("&Pause a running thread\tCtrl-P"));
 392     menuThread->Append(THREAD_RESUME_THREAD, _T("&Resume suspended thread\tCtrl-R"));
 393     menuThread->AppendSeparator();
 394     menuThread->Append(THREAD_START_WORKER, _T("Start &worker thread\tCtrl-W"));
 395     menuBar->Append(menuThread, _T("&Thread"));
 396
 397     wxMenu *menuExec = new wxMenu;
 398     menuExec->Append(THREAD_EXEC_MAIN, _T("&Launch a program from main thread\tF5"));
 399     menuExec->Append(THREAD_EXEC_THREAD, _T("L&aunch a program from a thread\tCtrl-F5"));
 400     menuBar->Append(menuExec, _T("&Execute"));
 401
 402     wxMenu *menuHelp = new wxMenu;
 403     menuHelp->Append(THREAD_SHOWCPUS, _T("&Show CPU count"));
 404     menuHelp->AppendSeparator();
 405     menuHelp->Append(THREAD_ABOUT, _T("&About..."));
 406     menuBar->Append(menuHelp, _T("&Help"));
 407
 408     frame->SetMenuBar(menuBar);
 409
 410     // Show the frame
 411     frame->Show(true);
 412
 413     SetTopWindow(frame);
 414
 415     return true;
 416 }
 417
 418 // My frame constructor
 419 MyFrame::MyFrame(wxFrame *frame, const wxString& title,
 420                  int x, int y, int w, int h)
 421        : wxFrame(frame, wxID_ANY, title, wxPoint(x, y), wxSize(w, h))
 422 {
 423     SetIcon(wxIcon(sample_xpm));
 424
 425     m_nRunning = m_nCount = 0;
 426
 427     m_dlgProgress = (wxProgressDialog *)NULL;
 428
 429 #if wxUSE_STATUSBAR
 430     CreateStatusBar(2);
 431 #endif // wxUSE_STATUSBAR
 432
 433     m_txtctrl = new wxTextCtrl(this, wxID_ANY, _T(""), wxPoint(0, 0), wxSize(0, 0),
 434                                wxTE_MULTILINE | wxTE_READONLY);
 435
 436 }
 437
 438 MyFrame::~MyFrame()
 439 {
 440     // NB: although the OS will terminate all the threads anyhow when the main
 441     //     one exits, it's good practice to do it ourselves -- even if it's not
 442     //     completely trivial in this example
 443
 444     // tell all the threads to terminate: note that they can't terminate while
 445     // we're deleting them because they will block in their OnExit() -- this is
 446     // important as otherwise we might access invalid array elements
 447     wxThread *thread;
 448
 449     wxGetApp().m_critsect.Enter();
 450
 451     // check if we have any threads running first
 452     const wxArrayThread& threads = wxGetApp().m_threads;
 453     size_t count = threads.GetCount();
 454
 455     if ( count )
 456     {
 457         // set the flag for MyThread::OnExit()
 458         wxGetApp().m_waitingUntilAllDone = true;
 459
 460         // stop all threads
 461         while ( ! threads.IsEmpty() )
 462         {
 463             thread = threads.Last();
 464
 465             wxGetApp().m_critsect.Leave();
 466
 467             thread->Delete();
 468
 469             wxGetApp().m_critsect.Enter();
 470         }
 471     }
 472
 473     wxGetApp().m_critsect.Leave();
 474
 475     if ( count )
 476     {
 477         // now wait for them to really terminate
 478         wxGetApp().m_semAllDone.Wait();
 479     }
 480     //else: no threads to terminate, no condition to wait for
 481 }
 482
 483 MyThread *MyFrame::CreateThread()
 484 {
 485     MyThread *thread = new MyThread(this);
 486
 487     if ( thread->Create() != wxTHREAD_NO_ERROR )
 488     {
 489         wxLogError(wxT("Can't create thread!"));
 490     }
 491
 492     wxCriticalSectionLocker enter(wxGetApp().m_critsect);
 493     wxGetApp().m_threads.Add(thread);
 494
 495     return thread;
 496 }
 497
 498 void MyFrame::OnStartThreads(wxCommandEvent& WXUNUSED(event) )
 499 {
 500     static long s_num;
 501
 502     s_num = wxGetNumberFromUser(_T("How many threads to start: "), _T(""),
 503                                 _T("wxThread sample"), s_num, 1, 10000, this);
 504     if ( s_num == -1 )
 505     {
 506         s_num = 10;
 507
 508         return;
 509     }
 510
 511     unsigned count = unsigned(s_num), n;
 512
 513     wxArrayThread threads;
 514
 515     // first create them all...
 516     for ( n = 0; n < count; n++ )
 517     {
 518         wxThread *thr = CreateThread();
 519
 520         // we want to show the effect of SetPriority(): the first thread will
 521         // have the lowest priority, the second - the highest, all the rest
 522         // the normal one
 523         if ( n == 0 )
 524             thr->SetPriority(WXTHREAD_MIN_PRIORITY);
 525         else if ( n == 1 )
 526             thr->SetPriority(WXTHREAD_MAX_PRIORITY);
 527         else
 528             thr->SetPriority(WXTHREAD_DEFAULT_PRIORITY);
 529
 530         threads.Add(thr);
 531     }
 532
 533 #if wxUSE_STATUSBAR
 534     wxString msg;
 535     msg.Printf(wxT("%d new threads created."), count);
 536     SetStatusText(msg, 1);
 537 #endif // wxUSE_STATUSBAR
 538
 539     // ...and then start them
 540     for ( n = 0; n < count; n++ )
 541     {
 542         threads[n]->Run();
 543     }
 544 }
 545
 546 void MyFrame::OnStartThread(wxCommandEvent& WXUNUSED(event) )
 547 {
 548     MyThread *thread = CreateThread();
 549
 550     if ( thread->Run() != wxTHREAD_NO_ERROR )
 551     {
 552         wxLogError(wxT("Can't start thread!"));
 553     }
 554
 555 #if wxUSE_STATUSBAR
 556     SetStatusText(_T("New thread started."), 1);
 557 #endif // wxUSE_STATUSBAR
 558 }
 559
 560 void MyFrame::OnStopThread(wxCommandEvent& WXUNUSED(event) )
 561 {
 562     wxGetApp().m_critsect.Enter();
 563
 564     // stop the last thread
 565     if ( wxGetApp().m_threads.IsEmpty() )
 566     {
 567         wxLogError(wxT("No thread to stop!"));
 568
 569         wxGetApp().m_critsect.Leave();
 570     }
 571     else
 572     {
 573         wxThread *thread = wxGetApp().m_threads.Last();
 574
 575         // it's important to leave critical section before calling Delete()
 576         // because delete will (implicitly) call OnExit() which also tries
 577         // to enter the same crit section - would dead lock.
 578         wxGetApp().m_critsect.Leave();
 579
 580         thread->Delete();
 581
 582 #if wxUSE_STATUSBAR
 583         SetStatusText(_T("Thread stopped."), 1);
 584 #endif // wxUSE_STATUSBAR
 585     }
 586 }
 587
 588 void MyFrame::OnResumeThread(wxCommandEvent& WXUNUSED(event) )
 589 {
 590     wxCriticalSectionLocker enter(wxGetApp().m_critsect);
 591
 592     // resume first suspended thread
 593     size_t n = 0, count = wxGetApp().m_threads.Count();
 594     while ( n < count && !wxGetApp().m_threads[n]->IsPaused() )
 595         n++;
 596
 597     if ( n == count )
 598     {
 599         wxLogError(wxT("No thread to resume!"));
 600     }
 601     else
 602     {
 603         wxGetApp().m_threads[n]->Resume();
 604
 605 #if wxUSE_STATUSBAR
 606         SetStatusText(_T("Thread resumed."), 1);
 607 #endif // wxUSE_STATUSBAR
 608     }
 609 }
 610
 611 void MyFrame::OnPauseThread(wxCommandEvent& WXUNUSED(event) )
 612 {
 613     wxCriticalSectionLocker enter(wxGetApp().m_critsect);
 614
 615     // pause last running thread
 616     int n = wxGetApp().m_threads.Count() - 1;
 617     while ( n >= 0 && !wxGetApp().m_threads[n]->IsRunning() )
 618         n--;
 619
 620     if ( n < 0 )
 621     {
 622         wxLogError(wxT("No thread to pause!"));
 623     }
 624     else
 625     {
 626         wxGetApp().m_threads[n]->Pause();
 627
 628 #if wxUSE_STATUSBAR
 629         SetStatusText(_T("Thread paused."), 1);
 630 #endif // wxUSE_STATUSBAR
 631     }
 632 }
 633
 634 // set the frame title indicating the current number of threads
 635 void MyFrame::OnIdle(wxIdleEvent& event)
 636 {
 637     wxCriticalSectionLocker enter(wxGetApp().m_critsect);
 638
 639     // update the counts of running/total threads
 640     size_t nRunning = 0,
 641            nCount = wxGetApp().m_threads.Count();
 642     for ( size_t n = 0; n < nCount; n++ )
 643     {
 644         if ( wxGetApp().m_threads[n]->IsRunning() )
 645             nRunning++;
 646     }
 647
 648     if ( nCount != m_nCount || nRunning != m_nRunning )
 649     {
 650         m_nRunning = nRunning;
 651         m_nCount = nCount;
 652
 653         wxLogStatus(this, wxT("%u threads total, %u running."), unsigned(nCount), unsigned(nRunning));
 654     }
 655     //else: avoid flicker - don't print anything
 656
 657     event.Skip();
 658 }
 659
 660 void MyFrame::OnQuit(wxCommandEvent& WXUNUSED(event) )
 661 {
 662     Close(true);
 663 }
 664
 665 void MyFrame::OnExecMain(wxCommandEvent& WXUNUSED(event))
 666 {
 667     wxLogMessage(wxT("The exit code from the main program is %ld"),
 668                  EXEC(_T("/bin/echo \"main program\"")));
 669 }
 670
 671 void MyFrame::OnExecThread(wxCommandEvent& WXUNUSED(event))
 672 {
 673     MyExecThread thread(wxT("/bin/echo \"child thread\""));
 674     thread.Run();
 675
 676     wxLogMessage(wxT("The exit code from a child thread is %ld"),
 677                  (long)wxPtrToUInt(thread.Wait()));
 678 }
 679
 680 void MyFrame::OnShowCPUs(wxCommandEvent& WXUNUSED(event))
 681 {
 682     wxString msg;
 683
 684     int nCPUs = wxThread::GetCPUCount();
 685     switch ( nCPUs )
 686     {
 687         case -1:
 688             msg = _T("Unknown number of CPUs");
 689             break;
 690
 691         case 0:
 692             msg = _T("WARNING: you're running without any CPUs!");
 693             break;
 694
 695         case 1:
 696             msg = _T("This system only has one CPU.");
 697             break;
 698
 699         default:
 700             msg.Printf(wxT("This system has %d CPUs"), nCPUs);
 701     }
 702
 703     wxLogMessage(msg);
 704 }
 705
 706 void MyFrame::OnAbout(wxCommandEvent& WXUNUSED(event) )
 707 {
 708     wxMessageDialog dialog(this,
 709                            _T("wxWidgets multithreaded application sample\n")
 710                            _T("(c) 1998 Julian Smart, Guilhem Lavaux\n")
 711                            _T("(c) 1999 Vadim Zeitlin\n")
 712                            _T("(c) 2000 Robert Roebling"),
 713                            _T("About wxThread sample"),
 714                            wxOK | wxICON_INFORMATION);
 715
 716     dialog.ShowModal();
 717 }
 718
 719 void MyFrame::OnClear(wxCommandEvent& WXUNUSED(event))
 720 {
 721     m_txtctrl->Clear();
 722 }
 723
 724 void MyFrame::OnUpdateWorker(wxUpdateUIEvent& event)
 725 {
 726     event.Enable( m_dlgProgress == NULL );
 727 }
 728
 729 void MyFrame::OnStartWorker(wxCommandEvent& WXUNUSED(event))
 730 {
 731     MyWorkerThread *thread = new MyWorkerThread(this);
 732
 733     if ( thread->Create() != wxTHREAD_NO_ERROR )
 734     {
 735         wxLogError(wxT("Can't create thread!"));
 736         return;
 737     }
 738
 739     m_dlgProgress = new wxProgressDialog
 740                         (
 741                          _T("Progress dialog"),
 742                          _T("Wait until the thread terminates or press [Cancel]"),
 743                          100,
 744                          this,
 745                          wxPD_CAN_ABORT |
 746                          wxPD_APP_MODAL |
 747                          wxPD_ELAPSED_TIME |
 748                          wxPD_ESTIMATED_TIME |
 749                          wxPD_REMAINING_TIME
 750                         );
 751
 752     // thread is not running yet, no need for crit sect
 753     m_cancelled = false;
 754
 755     thread->Run();
 756 }
 757
 758 void MyFrame::OnWorkerEvent(wxCommandEvent& event)
 759 {
 760 #if 0
 761     WriteText( _T("Got message from worker thread: ") );
 762     WriteText( event.GetString() );
 763     WriteText( _T("\n") );
 764 #else
 765     int n = event.GetInt();
 766     if ( n == -1 )
 767     {
 768         m_dlgProgress->Destroy();
 769         m_dlgProgress = (wxProgressDialog *)NULL;
 770
 771         // the dialog is aborted because the event came from another thread, so
 772         // we may need to wake up the main event loop for the dialog to be
 773         // really closed
 774         wxWakeUpIdle();
 775     }
 776     else
 777     {
 778         if ( !m_dlgProgress->Update(n) )
 779         {
 780             wxCriticalSectionLocker lock(m_critsectWork);
 781
 782             m_cancelled = true;
 783         }
 784     }
 785 #endif
 786 }
 787
 788 bool MyFrame::Cancelled()
 789 {
 790     wxCriticalSectionLocker lock(m_critsectWork);
 791
 792     return m_cancelled;
 793 }