]> git.saurik.com Git - wxWidgets.git/blob - samples/thread/thread.cpp
Add missing wxSTDCALL to fix wxWebView compilation with Borland.
[wxWidgets.git] / 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-2009 wxWidgets team
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 // ============================================================================
13 // declarations
14 // ============================================================================
15
16 // ----------------------------------------------------------------------------
17 // headers
18 // ----------------------------------------------------------------------------
19
20 // For compilers that support precompilation, includes "wx/wx.h".
21 #include "wx/wxprec.h"
22
23 #ifdef __BORLANDC__
24 #pragma hdrstop
25 #endif
26
27 #ifndef WX_PRECOMP
28 #include "wx/wx.h"
29 #endif
30
31 #if !wxUSE_THREADS
32 #error "This sample requires thread support!"
33 #endif // wxUSE_THREADS
34
35 #include "wx/thread.h"
36 #include "wx/dynarray.h"
37 #include "wx/numdlg.h"
38 #include "wx/progdlg.h"
39
40 // ----------------------------------------------------------------------------
41 // resources
42 // ----------------------------------------------------------------------------
43
44 #include "../sample.xpm"
45
46 // ----------------------------------------------------------------------------
47 // private classes
48 // ----------------------------------------------------------------------------
49
50 // define this to use wxExecute in the exec tests, otherwise just use system
51 #define USE_EXECUTE
52
53 #ifdef USE_EXECUTE
54 #define EXEC(cmd) wxExecute((cmd), wxEXEC_SYNC)
55 #else
56 #define EXEC(cmd) system(cmd)
57 #endif
58
59 class MyThread;
60 WX_DEFINE_ARRAY_PTR(wxThread *, wxArrayThread);
61
62 // ----------------------------------------------------------------------------
63 // the application object
64 // ----------------------------------------------------------------------------
65
66 class MyApp : public wxApp
67 {
68 public:
69 MyApp();
70 virtual ~MyApp(){};
71
72 virtual bool OnInit();
73
74 // critical section protects access to all of the fields below
75 wxCriticalSection m_critsect;
76
77 // all the threads currently alive - as soon as the thread terminates, it's
78 // removed from the array
79 wxArrayThread m_threads;
80
81 // semaphore used to wait for the threads to exit, see MyFrame::OnQuit()
82 wxSemaphore m_semAllDone;
83
84 // indicates that we're shutting down and all threads should exit
85 bool m_shuttingDown;
86 };
87
88 // ----------------------------------------------------------------------------
89 // the main application frame
90 // ----------------------------------------------------------------------------
91
92 class MyFrame : public wxFrame,
93 private wxLog
94 {
95 public:
96 // ctor
97 MyFrame(const wxString& title);
98 virtual ~MyFrame();
99
100 // accessors for MyWorkerThread (called in its context!)
101 bool Cancelled();
102
103 protected:
104 virtual void DoLogRecord(wxLogLevel level,
105 const wxString& msg,
106 const wxLogRecordInfo& info);
107
108 private:
109 // event handlers
110 // --------------
111
112 void OnQuit(wxCommandEvent& event);
113 void OnClear(wxCommandEvent& event);
114
115 void OnStartThread(wxCommandEvent& event);
116 void OnStartThreads(wxCommandEvent& event);
117 void OnStopThread(wxCommandEvent& event);
118 void OnPauseThread(wxCommandEvent& event);
119 void OnResumeThread(wxCommandEvent& event);
120
121 void OnStartWorker(wxCommandEvent& event);
122 void OnExecMain(wxCommandEvent& event);
123 void OnStartGUIThread(wxCommandEvent& event);
124
125 void OnShowCPUs(wxCommandEvent& event);
126 void OnAbout(wxCommandEvent& event);
127
128 void OnIdle(wxIdleEvent &event);
129 void OnWorkerEvent(wxThreadEvent& event);
130 void OnUpdateWorker(wxUpdateUIEvent& event);
131
132
133 // logging helper
134 void DoLogLine(wxTextCtrl *text,
135 const wxString& timestr,
136 const wxString& threadstr,
137 const wxString& msg);
138
139
140 // thread helper functions
141 // -----------------------
142
143 // helper function - creates a new thread (but doesn't run it)
144 MyThread *CreateThread();
145
146 // update display in our status bar: called during idle handling
147 void UpdateThreadStatus();
148
149
150 // internal variables
151 // ------------------
152
153 // just some place to put our messages in
154 wxTextCtrl *m_txtctrl;
155
156 // old log target, we replace it with one using m_txtctrl during this
157 // frame life time
158 wxLog *m_oldLogger;
159
160 // the array of pending messages to be displayed and the critical section
161 // protecting it
162 wxArrayString m_messages;
163 wxCriticalSection m_csMessages;
164
165 // remember the number of running threads and total number of threads
166 size_t m_nRunning,
167 m_nCount;
168
169 // the progress dialog which we show while worker thread is running
170 wxProgressDialog *m_dlgProgress;
171
172 // was the worker thread cancelled by user?
173 bool m_cancelled;
174 wxCriticalSection m_csCancelled; // protects m_cancelled
175
176 DECLARE_EVENT_TABLE()
177 };
178
179 // ----------------------------------------------------------------------------
180 // constants
181 // ----------------------------------------------------------------------------
182
183 // ID for the menu commands
184 enum
185 {
186 THREAD_QUIT = wxID_EXIT,
187 THREAD_ABOUT = wxID_ABOUT,
188 THREAD_TEXT = 101,
189 THREAD_CLEAR,
190 THREAD_START_THREAD = 201,
191 THREAD_START_THREADS,
192 THREAD_STOP_THREAD,
193 THREAD_PAUSE_THREAD,
194 THREAD_RESUME_THREAD,
195
196 THREAD_START_WORKER,
197 THREAD_EXEC_MAIN,
198 THREAD_START_GUI_THREAD,
199
200 THREAD_SHOWCPUS,
201
202 WORKER_EVENT = wxID_HIGHEST+1, // this one gets sent from MyWorkerThread
203 GUITHREAD_EVENT // this one gets sent from MyGUIThread
204 };
205
206 // ----------------------------------------------------------------------------
207 // a simple thread
208 // ----------------------------------------------------------------------------
209
210 class MyThread : public wxThread
211 {
212 public:
213 MyThread();
214 virtual ~MyThread();
215
216 // thread execution starts here
217 virtual void *Entry();
218
219 public:
220 unsigned m_count;
221 };
222
223 // ----------------------------------------------------------------------------
224 // a worker thread
225 // ----------------------------------------------------------------------------
226
227 class MyWorkerThread : public wxThread
228 {
229 public:
230 MyWorkerThread(MyFrame *frame);
231
232 // thread execution starts here
233 virtual void *Entry();
234
235 // called when the thread exits - whether it terminates normally or is
236 // stopped with Delete() (but not when it is Kill()ed!)
237 virtual void OnExit();
238
239 public:
240 MyFrame *m_frame;
241 unsigned m_count;
242 };
243
244 // ----------------------------------------------------------------------------
245 // a thread which executes GUI calls using wxMutexGuiEnter/Leave
246 // ----------------------------------------------------------------------------
247
248 #define GUITHREAD_BMP_SIZE 300
249 #define GUITHREAD_NUM_UPDATES 50
250 class MyImageDialog;
251
252 class MyGUIThread : public wxThread
253 {
254 public:
255 MyGUIThread(MyImageDialog *dlg) : wxThread(wxTHREAD_JOINABLE)
256 {
257 m_dlg = dlg;
258 }
259
260 virtual ExitCode Entry();
261
262 private:
263 MyImageDialog *m_dlg;
264 };
265
266 // ----------------------------------------------------------------------------
267 // an helper dialog used by MyFrame::OnStartGUIThread
268 // ----------------------------------------------------------------------------
269
270 class MyImageDialog: public wxDialog
271 {
272 public:
273 // ctor
274 MyImageDialog(wxFrame *frame);
275 ~MyImageDialog();
276
277 // stuff used by MyGUIThread:
278 wxBitmap m_bmp; // the bitmap drawn by MyGUIThread
279 wxCriticalSection m_csBmp; // protects m_bmp
280
281 private:
282 void OnGUIThreadEvent(wxThreadEvent& event);
283 void OnPaint(wxPaintEvent&);
284
285 MyGUIThread m_thread;
286 int m_nCurrentProgress;
287
288 DECLARE_EVENT_TABLE()
289 };
290
291 // ============================================================================
292 // implementation
293 // ============================================================================
294
295 // ----------------------------------------------------------------------------
296 // the application class
297 // ----------------------------------------------------------------------------
298
299 // Create a new application object
300 IMPLEMENT_APP(MyApp)
301
302 MyApp::MyApp()
303 {
304 m_shuttingDown = false;
305 }
306
307 // `Main program' equivalent, creating windows and returning main app frame
308 bool MyApp::OnInit()
309 {
310 if ( !wxApp::OnInit() )
311 return false;
312
313 // uncomment this to get some debugging messages from the trace code
314 // on the console (or just set WXTRACE env variable to include "thread")
315 wxLog::AddTraceMask("thread");
316
317 // Create the main frame window
318 new MyFrame("wxWidgets threads sample");
319
320 return true;
321 }
322
323 // ----------------------------------------------------------------------------
324 // MyFrame
325 // ----------------------------------------------------------------------------
326
327 BEGIN_EVENT_TABLE(MyFrame, wxFrame)
328 EVT_MENU(THREAD_QUIT, MyFrame::OnQuit)
329 EVT_MENU(THREAD_CLEAR, MyFrame::OnClear)
330 EVT_MENU(THREAD_START_THREAD, MyFrame::OnStartThread)
331 EVT_MENU(THREAD_START_THREADS, MyFrame::OnStartThreads)
332 EVT_MENU(THREAD_STOP_THREAD, MyFrame::OnStopThread)
333 EVT_MENU(THREAD_PAUSE_THREAD, MyFrame::OnPauseThread)
334 EVT_MENU(THREAD_RESUME_THREAD, MyFrame::OnResumeThread)
335
336 EVT_MENU(THREAD_START_WORKER, MyFrame::OnStartWorker)
337 EVT_MENU(THREAD_EXEC_MAIN, MyFrame::OnExecMain)
338 EVT_MENU(THREAD_START_GUI_THREAD, MyFrame::OnStartGUIThread)
339
340 EVT_MENU(THREAD_SHOWCPUS, MyFrame::OnShowCPUs)
341 EVT_MENU(THREAD_ABOUT, MyFrame::OnAbout)
342
343 EVT_UPDATE_UI(THREAD_START_WORKER, MyFrame::OnUpdateWorker)
344 EVT_THREAD(WORKER_EVENT, MyFrame::OnWorkerEvent)
345 EVT_IDLE(MyFrame::OnIdle)
346 END_EVENT_TABLE()
347
348 // My frame constructor
349 MyFrame::MyFrame(const wxString& title)
350 : wxFrame(NULL, wxID_ANY, title)
351 {
352 m_oldLogger = wxLog::GetActiveTarget();
353
354 SetIcon(wxICON(sample));
355
356 // Make a menubar
357 wxMenuBar *menuBar = new wxMenuBar;
358
359 wxMenu *menuFile = new wxMenu;
360 menuFile->Append(THREAD_CLEAR, wxT("&Clear log\tCtrl-L"));
361 menuFile->AppendSeparator();
362 menuFile->Append(THREAD_QUIT, wxT("E&xit\tAlt-X"));
363 menuBar->Append(menuFile, wxT("&File"));
364
365 wxMenu *menuThread = new wxMenu;
366 menuThread->Append(THREAD_START_THREAD, wxT("&Start a new thread\tCtrl-N"));
367 menuThread->Append(THREAD_START_THREADS, wxT("Start &many threads at once"));
368 menuThread->Append(THREAD_STOP_THREAD, wxT("S&top the last spawned thread\tCtrl-S"));
369 menuThread->AppendSeparator();
370 menuThread->Append(THREAD_PAUSE_THREAD, wxT("&Pause the last spawned running thread\tCtrl-P"));
371 menuThread->Append(THREAD_RESUME_THREAD, wxT("&Resume the first suspended thread\tCtrl-R"));
372 menuThread->AppendSeparator();
373 menuThread->Append(THREAD_START_WORKER, wxT("Start a &worker thread\tCtrl-W"));
374 menuThread->Append(THREAD_EXEC_MAIN, wxT("&Launch a program from main thread\tF5"));
375 menuThread->Append(THREAD_START_GUI_THREAD, wxT("Launch a &GUI thread\tF6"));
376 menuBar->Append(menuThread, wxT("&Thread"));
377
378 wxMenu *menuHelp = new wxMenu;
379 menuHelp->Append(THREAD_SHOWCPUS, wxT("&Show CPU count"));
380 menuHelp->AppendSeparator();
381 menuHelp->Append(THREAD_ABOUT, wxT("&About"));
382 menuBar->Append(menuHelp, wxT("&Help"));
383
384 SetMenuBar(menuBar);
385
386 m_nRunning = m_nCount = 0;
387
388 m_dlgProgress = NULL;
389
390 #if wxUSE_STATUSBAR
391 CreateStatusBar(2);
392 #endif // wxUSE_STATUSBAR
393
394 // create the logging text control and a header showing the meaning of the
395 // different columns
396 wxTextCtrl *header = new wxTextCtrl(this, wxID_ANY, "",
397 wxDefaultPosition, wxDefaultSize,
398 wxTE_READONLY);
399 DoLogLine(header, " Time", " Thread", "Message");
400 m_txtctrl = new wxTextCtrl(this, wxID_ANY, "",
401 wxDefaultPosition, wxDefaultSize,
402 wxTE_MULTILINE | wxTE_READONLY);
403 wxLog::SetActiveTarget(this);
404
405 // use fixed width font to align output in nice columns
406 wxFont font(wxNORMAL_FONT->GetPointSize(), wxFONTFAMILY_TELETYPE,
407 wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL);
408 header->SetFont(font);
409 m_txtctrl->SetFont(font);
410
411 m_txtctrl->SetFocus();
412
413 // layout and show the frame
414 wxBoxSizer *sizer = new wxBoxSizer(wxVERTICAL);
415 sizer->Add(header, wxSizerFlags().Expand());
416 sizer->Add(m_txtctrl, wxSizerFlags(1).Expand());
417 SetSizer(sizer);
418
419 SetSize(600, 350);
420 Show();
421 }
422
423 MyFrame::~MyFrame()
424 {
425 wxLog::SetActiveTarget(m_oldLogger);
426
427 // NB: although the OS will terminate all the threads anyhow when the main
428 // one exits, it's good practice to do it ourselves -- even if it's not
429 // completely trivial in this example
430
431 // tell all the threads to terminate: note that they can't terminate while
432 // we're deleting them because they will block in their OnExit() -- this is
433 // important as otherwise we might access invalid array elements
434
435 {
436 wxCriticalSectionLocker locker(wxGetApp().m_critsect);
437
438 // check if we have any threads running first
439 const wxArrayThread& threads = wxGetApp().m_threads;
440 size_t count = threads.GetCount();
441
442 if ( !count )
443 return;
444
445 // set the flag indicating that all threads should exit
446 wxGetApp().m_shuttingDown = true;
447 }
448
449 // now wait for them to really terminate
450 wxGetApp().m_semAllDone.Wait();
451 }
452
453 void
454 MyFrame::DoLogLine(wxTextCtrl *text,
455 const wxString& timestr,
456 const wxString& threadstr,
457 const wxString& msg)
458 {
459 text->AppendText(wxString::Format("%9s %10s %s", timestr, threadstr, msg));
460 }
461
462 void
463 MyFrame::DoLogRecord(wxLogLevel level,
464 const wxString& msg,
465 const wxLogRecordInfo& info)
466 {
467 // let the default GUI logger treat warnings and errors as they should be
468 // more noticeable than just another line in the log window and also trace
469 // messages as there may be too many of them
470 if ( level <= wxLOG_Warning || level == wxLOG_Trace )
471 {
472 m_oldLogger->LogRecord(level, msg, info);
473 return;
474 }
475
476 DoLogLine
477 (
478 m_txtctrl,
479 wxDateTime(info.timestamp).FormatISOTime(),
480 info.threadId == wxThread::GetMainId()
481 ? wxString("main")
482 : wxString::Format("%lx", info.threadId),
483 msg + "\n"
484 );
485 }
486
487 MyThread *MyFrame::CreateThread()
488 {
489 MyThread *thread = new MyThread;
490
491 if ( thread->Create() != wxTHREAD_NO_ERROR )
492 {
493 wxLogError(wxT("Can't create thread!"));
494 }
495
496 wxCriticalSectionLocker enter(wxGetApp().m_critsect);
497 wxGetApp().m_threads.Add(thread);
498
499 return thread;
500 }
501
502 void MyFrame::UpdateThreadStatus()
503 {
504 wxCriticalSectionLocker enter(wxGetApp().m_critsect);
505
506 // update the counts of running/total threads
507 size_t nRunning = 0,
508 nCount = wxGetApp().m_threads.Count();
509 for ( size_t n = 0; n < nCount; n++ )
510 {
511 if ( wxGetApp().m_threads[n]->IsRunning() )
512 nRunning++;
513 }
514
515 if ( nCount != m_nCount || nRunning != m_nRunning )
516 {
517 m_nRunning = nRunning;
518 m_nCount = nCount;
519
520 wxLogStatus(this, wxT("%u threads total, %u running."), unsigned(nCount), unsigned(nRunning));
521 }
522 //else: avoid flicker - don't print anything
523 }
524
525 bool MyFrame::Cancelled()
526 {
527 wxCriticalSectionLocker lock(m_csCancelled);
528
529 return m_cancelled;
530 }
531
532 // ----------------------------------------------------------------------------
533 // MyFrame - event handlers
534 // ----------------------------------------------------------------------------
535
536 void MyFrame::OnStartThreads(wxCommandEvent& WXUNUSED(event) )
537 {
538 static long s_num;
539
540 s_num = wxGetNumberFromUser(wxT("How many threads to start: "), wxT(""),
541 wxT("wxThread sample"), s_num, 1, 10000, this);
542 if ( s_num == -1 )
543 {
544 s_num = 10;
545
546 return;
547 }
548
549 unsigned count = unsigned(s_num), n;
550
551 wxArrayThread threads;
552
553 // first create them all...
554 for ( n = 0; n < count; n++ )
555 {
556 wxThread *thr = CreateThread();
557
558 // we want to show the effect of SetPriority(): the first thread will
559 // have the lowest priority, the second - the highest, all the rest
560 // the normal one
561 if ( n == 0 )
562 thr->SetPriority(WXTHREAD_MIN_PRIORITY);
563 else if ( n == 1 )
564 thr->SetPriority(WXTHREAD_MAX_PRIORITY);
565 else
566 thr->SetPriority(WXTHREAD_DEFAULT_PRIORITY);
567
568 threads.Add(thr);
569 }
570
571 #if wxUSE_STATUSBAR
572 wxString msg;
573 msg.Printf(wxT("%d new threads created."), count);
574 SetStatusText(msg, 1);
575 #endif // wxUSE_STATUSBAR
576
577 // ...and then start them
578 for ( n = 0; n < count; n++ )
579 {
580 threads[n]->Run();
581 }
582 }
583
584 void MyFrame::OnStartThread(wxCommandEvent& WXUNUSED(event) )
585 {
586 MyThread *thread = CreateThread();
587
588 if ( thread->Run() != wxTHREAD_NO_ERROR )
589 {
590 wxLogError(wxT("Can't start thread!"));
591 }
592
593 #if wxUSE_STATUSBAR
594 SetStatusText(wxT("New thread started."), 1);
595 #endif // wxUSE_STATUSBAR
596 }
597
598 void MyFrame::OnStopThread(wxCommandEvent& WXUNUSED(event) )
599 {
600 wxCriticalSectionLocker enter(wxGetApp().m_critsect);
601
602 // stop the last thread
603 if ( wxGetApp().m_threads.IsEmpty() )
604 {
605 wxLogError(wxT("No thread to stop!"));
606 }
607 else
608 {
609 wxGetApp().m_threads.Last()->Delete();
610
611 #if wxUSE_STATUSBAR
612 SetStatusText(wxT("Last thread stopped."), 1);
613 #endif // wxUSE_STATUSBAR
614 }
615 }
616
617 void MyFrame::OnResumeThread(wxCommandEvent& WXUNUSED(event) )
618 {
619 wxCriticalSectionLocker enter(wxGetApp().m_critsect);
620
621 // resume first suspended thread
622 size_t n = 0, count = wxGetApp().m_threads.Count();
623 while ( n < count && !wxGetApp().m_threads[n]->IsPaused() )
624 n++;
625
626 if ( n == count )
627 {
628 wxLogError(wxT("No thread to resume!"));
629 }
630 else
631 {
632 wxGetApp().m_threads[n]->Resume();
633
634 #if wxUSE_STATUSBAR
635 SetStatusText(wxT("Thread resumed."), 1);
636 #endif // wxUSE_STATUSBAR
637 }
638 }
639
640 void MyFrame::OnPauseThread(wxCommandEvent& WXUNUSED(event) )
641 {
642 wxCriticalSectionLocker enter(wxGetApp().m_critsect);
643
644 // pause last running thread
645 int n = wxGetApp().m_threads.Count() - 1;
646 while ( n >= 0 && !wxGetApp().m_threads[n]->IsRunning() )
647 n--;
648
649 if ( n < 0 )
650 {
651 wxLogError(wxT("No thread to pause!"));
652 }
653 else
654 {
655 wxGetApp().m_threads[n]->Pause();
656
657 #if wxUSE_STATUSBAR
658 SetStatusText(wxT("Thread paused."), 1);
659 #endif // wxUSE_STATUSBAR
660 }
661 }
662
663 void MyFrame::OnIdle(wxIdleEvent& event)
664 {
665 UpdateThreadStatus();
666
667 event.Skip();
668 }
669
670 void MyFrame::OnQuit(wxCommandEvent& WXUNUSED(event) )
671 {
672 Close(true);
673 }
674
675 void MyFrame::OnExecMain(wxCommandEvent& WXUNUSED(event))
676 {
677 wxString cmd = wxGetTextFromUser("Please enter the command to execute",
678 "Enter command",
679 #ifdef __WXMSW__
680 "notepad",
681 #else
682 "/bin/echo \"Message from another process\"",
683 #endif
684 this);
685 if (cmd.IsEmpty())
686 return; // user clicked cancel
687
688 wxLogMessage(wxT("The exit code from the main program is %ld"),
689 EXEC(cmd));
690 }
691
692 void MyFrame::OnShowCPUs(wxCommandEvent& WXUNUSED(event))
693 {
694 wxString msg;
695
696 int nCPUs = wxThread::GetCPUCount();
697 switch ( nCPUs )
698 {
699 case -1:
700 msg = wxT("Unknown number of CPUs");
701 break;
702
703 case 0:
704 msg = wxT("WARNING: you're running without any CPUs!");
705 break;
706
707 case 1:
708 msg = wxT("This system only has one CPU.");
709 break;
710
711 default:
712 msg.Printf(wxT("This system has %d CPUs"), nCPUs);
713 }
714
715 wxLogMessage(msg);
716 }
717
718 void MyFrame::OnAbout(wxCommandEvent& WXUNUSED(event) )
719 {
720 wxMessageDialog dialog(this,
721 wxT("wxWidgets multithreaded application sample\n")
722 wxT("(c) 1998 Julian Smart, Guilhem Lavaux\n")
723 wxT("(c) 2000 Robert Roebling\n")
724 wxT("(c) 1999,2009 Vadim Zeitlin"),
725 wxT("About wxThread sample"),
726 wxOK | wxICON_INFORMATION);
727
728 dialog.ShowModal();
729 }
730
731 void MyFrame::OnClear(wxCommandEvent& WXUNUSED(event))
732 {
733 m_txtctrl->Clear();
734 }
735
736 void MyFrame::OnUpdateWorker(wxUpdateUIEvent& event)
737 {
738 event.Enable( m_dlgProgress == NULL );
739 }
740
741 void MyFrame::OnStartWorker(wxCommandEvent& WXUNUSED(event))
742 {
743 MyWorkerThread *thread = new MyWorkerThread(this);
744
745 if ( thread->Create() != wxTHREAD_NO_ERROR )
746 {
747 wxLogError(wxT("Can't create thread!"));
748 return;
749 }
750
751 m_dlgProgress = new wxProgressDialog
752 (
753 wxT("Progress dialog"),
754 wxT("Wait until the thread terminates or press [Cancel]"),
755 100,
756 this,
757 wxPD_CAN_ABORT |
758 wxPD_APP_MODAL |
759 wxPD_ELAPSED_TIME |
760 wxPD_ESTIMATED_TIME |
761 wxPD_REMAINING_TIME
762 );
763
764 // thread is not running yet, no need for crit sect
765 m_cancelled = false;
766
767 thread->Run();
768 }
769
770 void MyFrame::OnWorkerEvent(wxThreadEvent& event)
771 {
772 int n = event.GetInt();
773 if ( n == -1 )
774 {
775 m_dlgProgress->Destroy();
776 m_dlgProgress = (wxProgressDialog *)NULL;
777
778 // the dialog is aborted because the event came from another thread, so
779 // we may need to wake up the main event loop for the dialog to be
780 // really closed
781 wxWakeUpIdle();
782 }
783 else
784 {
785 if ( !m_dlgProgress->Update(n) )
786 {
787 wxCriticalSectionLocker lock(m_csCancelled);
788
789 m_cancelled = true;
790 }
791 }
792 }
793
794 void MyFrame::OnStartGUIThread(wxCommandEvent& WXUNUSED(event))
795 {
796 // we use this to check that disabling logging only affects the main thread
797 // but the messages from the worker thread will still be logged
798 wxLogNull noLog;
799 wxLogMessage("You shouldn't see this message because of wxLogNull");
800
801 MyImageDialog dlg(this);
802
803 dlg.ShowModal();
804 }
805
806
807 // ----------------------------------------------------------------------------
808 // MyImageDialog
809 // ----------------------------------------------------------------------------
810
811 BEGIN_EVENT_TABLE(MyImageDialog, wxDialog)
812 EVT_THREAD(GUITHREAD_EVENT, MyImageDialog::OnGUIThreadEvent)
813 EVT_PAINT(MyImageDialog::OnPaint)
814 END_EVENT_TABLE()
815
816 MyImageDialog::MyImageDialog(wxFrame *parent)
817 : wxDialog(parent, wxID_ANY, "Image created by a secondary thread",
818 wxDefaultPosition, wxSize(GUITHREAD_BMP_SIZE,GUITHREAD_BMP_SIZE)*1.5, wxDEFAULT_DIALOG_STYLE),
819 m_thread(this)
820 {
821 m_nCurrentProgress = 0;
822
823 CentreOnScreen();
824
825 // NOTE: no need to lock m_csBmp until the thread isn't started:
826
827 // create the bitmap
828 if (!m_bmp.Create(GUITHREAD_BMP_SIZE,GUITHREAD_BMP_SIZE) || !m_bmp.IsOk())
829 {
830 wxLogError("Couldn't create the bitmap!");
831 return;
832 }
833
834 // clean it
835 wxMemoryDC dc(m_bmp);
836 dc.SetBackground(*wxBLACK_BRUSH);
837 dc.Clear();
838
839 // draw the bitmap from a secondary thread
840 if ( m_thread.Create() != wxTHREAD_NO_ERROR ||
841 m_thread.Run() != wxTHREAD_NO_ERROR )
842 {
843 wxLogError(wxT("Can't create/run thread!"));
844 return;
845 }
846 }
847
848 MyImageDialog::~MyImageDialog()
849 {
850 // in case our thread is still running and for some reason we are destroyed,
851 // do wait for the thread to complete as it assumes that its MyImageDialog
852 // pointer is always valid
853 m_thread.Delete();
854 }
855
856 void MyImageDialog::OnGUIThreadEvent(wxThreadEvent& event)
857 {
858 m_nCurrentProgress = int(((float)event.GetInt()*100)/GUITHREAD_NUM_UPDATES);
859
860 Refresh();
861 }
862
863 void MyImageDialog::OnPaint(wxPaintEvent& WXUNUSED(evt))
864 {
865 wxPaintDC dc(this);
866
867 const wxSize& sz = dc.GetSize();
868
869 {
870 // paint the bitmap
871 wxCriticalSectionLocker locker(m_csBmp);
872 dc.DrawBitmap(m_bmp, (sz.GetWidth()-GUITHREAD_BMP_SIZE)/2,
873 (sz.GetHeight()-GUITHREAD_BMP_SIZE)/2);
874 }
875
876 // paint a sort of progress bar with a 10px border:
877 dc.SetBrush(*wxRED_BRUSH);
878 dc.DrawRectangle(10,10, m_nCurrentProgress*(sz.GetWidth()-20)/100,30);
879 dc.SetTextForeground(*wxBLUE);
880 dc.DrawText(wxString::Format("%d%%", m_nCurrentProgress),
881 (sz.GetWidth()-dc.GetCharWidth()*2)/2,
882 25-dc.GetCharHeight()/2);
883 }
884
885 // ----------------------------------------------------------------------------
886 // MyThread
887 // ----------------------------------------------------------------------------
888
889 MyThread::MyThread()
890 : wxThread()
891 {
892 m_count = 0;
893 }
894
895 MyThread::~MyThread()
896 {
897 wxCriticalSectionLocker locker(wxGetApp().m_critsect);
898
899 wxArrayThread& threads = wxGetApp().m_threads;
900 threads.Remove(this);
901
902 if ( threads.IsEmpty() )
903 {
904 // signal the main thread that there are no more threads left if it is
905 // waiting for us
906 if ( wxGetApp().m_shuttingDown )
907 {
908 wxGetApp().m_shuttingDown = false;
909
910 wxGetApp().m_semAllDone.Post();
911 }
912 }
913 }
914
915 wxThread::ExitCode MyThread::Entry()
916 {
917 wxLogMessage("Thread started (priority = %u).", GetPriority());
918
919 for ( m_count = 0; m_count < 10; m_count++ )
920 {
921 // check if the application is shutting down: in this case all threads
922 // should stop a.s.a.p.
923 {
924 wxCriticalSectionLocker locker(wxGetApp().m_critsect);
925 if ( wxGetApp().m_shuttingDown )
926 return NULL;
927 }
928
929 // check if just this thread was asked to exit
930 if ( TestDestroy() )
931 break;
932
933 wxLogMessage("Thread progress: %u", m_count);
934
935 // wxSleep() can't be called from non-GUI thread!
936 wxThread::Sleep(1000);
937 }
938
939 wxLogMessage("Thread finished.");
940
941 return NULL;
942 }
943
944
945 // ----------------------------------------------------------------------------
946 // MyWorkerThread
947 // ----------------------------------------------------------------------------
948
949 // define this symbol to 1 to test if the YieldFor() call in the wxProgressDialog::Update
950 // function provokes a race condition in which the second wxThreadEvent posted by
951 // MyWorkerThread::Entry is processed by the YieldFor() call of wxProgressDialog::Update
952 // and results in the destruction of the progress dialog itself, resulting in a crash later.
953 #define TEST_YIELD_RACE_CONDITION 0
954
955 MyWorkerThread::MyWorkerThread(MyFrame *frame)
956 : wxThread()
957 {
958 m_frame = frame;
959 m_count = 0;
960 }
961
962 void MyWorkerThread::OnExit()
963 {
964 }
965
966 wxThread::ExitCode MyWorkerThread::Entry()
967 {
968 #if TEST_YIELD_RACE_CONDITION
969 if ( TestDestroy() )
970 return NULL;
971
972 wxThreadEvent event( wxEVT_THREAD, WORKER_EVENT );
973
974 event.SetInt( 50 );
975 wxQueueEvent( m_frame, event.Clone() );
976
977 event.SetInt(-1);
978 wxQueueEvent( m_frame, event.Clone() );
979 #else
980 for ( m_count = 0; !m_frame->Cancelled() && (m_count < 100); m_count++ )
981 {
982 // check if we were asked to exit
983 if ( TestDestroy() )
984 break;
985
986 // create any type of command event here
987 wxThreadEvent event( wxEVT_THREAD, WORKER_EVENT );
988 event.SetInt( m_count );
989
990 // send in a thread-safe way
991 wxQueueEvent( m_frame, event.Clone() );
992
993 wxMilliSleep(200);
994 }
995
996 wxThreadEvent event( wxEVT_THREAD, WORKER_EVENT );
997 event.SetInt(-1); // that's all
998 wxQueueEvent( m_frame, event.Clone() );
999 #endif
1000
1001 return NULL;
1002 }
1003
1004
1005 // ----------------------------------------------------------------------------
1006 // MyGUIThread
1007 // ----------------------------------------------------------------------------
1008
1009 wxThread::ExitCode MyGUIThread::Entry()
1010 {
1011 // uncomment this to check that disabling logging here does disable it for
1012 // this thread -- but not the main one if you also comment out wxLogNull
1013 // line in MyFrame::OnStartGUIThread()
1014 //wxLogNull noLog;
1015
1016 // this goes to the main window
1017 wxLogMessage("GUI thread starting");
1018
1019 // use a thread-specific log target for this thread to show that its
1020 // messages don't appear in the main window while it runs
1021 wxLogBuffer logBuf;
1022 wxLog::SetThreadActiveTarget(&logBuf);
1023
1024 for (int i=0; i<GUITHREAD_NUM_UPDATES && !TestDestroy(); i++)
1025 {
1026 // inform the GUI toolkit that we're going to use GUI functions
1027 // from a secondary thread:
1028 wxMutexGuiEnter();
1029
1030 {
1031 wxCriticalSectionLocker lock(m_dlg->m_csBmp);
1032
1033 // draw some more stuff on the bitmap
1034 wxMemoryDC dc(m_dlg->m_bmp);
1035 dc.SetBrush((i%2)==0 ? *wxBLUE_BRUSH : *wxGREEN_BRUSH);
1036 dc.DrawRectangle(rand()%GUITHREAD_BMP_SIZE, rand()%GUITHREAD_BMP_SIZE, 30, 30);
1037
1038 // simulate long drawing time:
1039 wxMilliSleep(200);
1040 }
1041
1042 // if we don't release the GUI mutex the MyImageDialog won't be able to refresh
1043 wxMutexGuiLeave();
1044
1045 // notify the dialog that another piece of our masterpiece is complete:
1046 wxThreadEvent event( wxEVT_THREAD, GUITHREAD_EVENT );
1047 event.SetInt(i+1);
1048 wxQueueEvent( m_dlg, event.Clone() );
1049
1050 if ( !((i + 1) % 10) )
1051 {
1052 // this message will go to the buffer
1053 wxLogMessage("Step #%d.", i + 1);
1054 }
1055
1056 // give the main thread the time to refresh before we lock the GUI mutex again
1057 // FIXME: find a better way to do this!
1058 wxMilliSleep(100);
1059 }
1060
1061 // now remove the thread-specific thread target
1062 wxLog::SetThreadActiveTarget(NULL);
1063
1064 // so that this goes to the main window again
1065 wxLogMessage("GUI thread finished.");
1066
1067 return (ExitCode)0;
1068 }