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