]> git.saurik.com Git - wxWidgets.git/blobdiff - include/wx/thread.h
support SDK < 10.6, fixes #14902
[wxWidgets.git] / include / wx / thread.h
index a8346d20e096842ca2d420e9504d3b317e9fb688..1cc9857b6556d5dcb62646356fa31bb8e3bb325e 100644 (file)
@@ -71,6 +71,21 @@ enum wxThreadKind
     wxTHREAD_JOINABLE
 };
 
     wxTHREAD_JOINABLE
 };
 
+enum wxThreadWait
+{
+    wxTHREAD_WAIT_BLOCK,
+    wxTHREAD_WAIT_YIELD,       // process events while waiting; MSW only
+
+    // For compatibility reasons we use wxTHREAD_WAIT_YIELD by default as this
+    // was the default behaviour of wxMSW 2.8 but it should be avoided as it's
+    // dangerous and not portable.
+#if WXWIN_COMPATIBILITY_2_8
+    wxTHREAD_WAIT_DEFAULT = wxTHREAD_WAIT_YIELD
+#else
+    wxTHREAD_WAIT_DEFAULT = wxTHREAD_WAIT_BLOCK
+#endif
+};
+
 // defines the interval of priority
 enum
 {
 // defines the interval of priority
 enum
 {
@@ -161,7 +176,7 @@ protected:
 
     friend class wxConditionInternal;
 
 
     friend class wxConditionInternal;
 
-    DECLARE_NO_COPY_CLASS(wxMutex)
+    wxDECLARE_NO_COPY_CLASS(wxMutex);
 };
 
 // a helper class which locks the mutex in the ctor and unlocks it in the dtor:
 };
 
 // a helper class which locks the mutex in the ctor and unlocks it in the dtor:
@@ -204,7 +219,7 @@ private:
 
 // in order to avoid any overhead under platforms where critical sections are
 // just mutexes make all wxCriticalSection class functions inline
 
 // in order to avoid any overhead under platforms where critical sections are
 // just mutexes make all wxCriticalSection class functions inline
-#if !defined(__WXMSW__)
+#if !defined(__WINDOWS__)
     #define wxCRITSECT_IS_MUTEX 1
 
     #define wxCRITSECT_INLINE WXEXPORT inline
     #define wxCRITSECT_IS_MUTEX 1
 
     #define wxCRITSECT_INLINE WXEXPORT inline
@@ -234,13 +249,16 @@ public:
     // enter the section (the same as locking a mutex)
     wxCRITSECT_INLINE void Enter();
 
     // enter the section (the same as locking a mutex)
     wxCRITSECT_INLINE void Enter();
 
+    // try to enter the section (the same as trying to lock a mutex)
+    wxCRITSECT_INLINE bool TryEnter();
+
     // leave the critical section (same as unlocking a mutex)
     wxCRITSECT_INLINE void Leave();
 
 private:
 #if wxCRITSECT_IS_MUTEX
     wxMutex m_mutex;
     // leave the critical section (same as unlocking a mutex)
     wxCRITSECT_INLINE void Leave();
 
 private:
 #if wxCRITSECT_IS_MUTEX
     wxMutex m_mutex;
-#elif defined(__WXMSW__)
+#elif defined(__WINDOWS__)
     // we can't allocate any memory in the ctor, so use placement new -
     // unfortunately, we have to hardcode the sizeof() here because we can't
     // include windows.h from this public header and we also have to use the
     // we can't allocate any memory in the ctor, so use placement new -
     // unfortunately, we have to hardcode the sizeof() here because we can't
     // include windows.h from this public header and we also have to use the
@@ -248,10 +266,6 @@ private:
     //
     // if CRITICAL_SECTION size changes in Windows, you'll get an assert from
     // thread.cpp and will need to increase the buffer size
     //
     // if CRITICAL_SECTION size changes in Windows, you'll get an assert from
     // thread.cpp and will need to increase the buffer size
-    //
-    // finally, we need this typedef instead of declaring m_buffer directly
-    // because otherwise the assert mentioned above wouldn't compile with some
-    // compilers (notably CodeWarrior 8)
 #ifdef __WIN64__
     typedef char wxCritSectBuffer[40];
 #else // __WIN32__
 #ifdef __WIN64__
     typedef char wxCritSectBuffer[40];
 #else // __WIN32__
@@ -266,16 +280,17 @@ private:
     };
 #endif // Unix&OS2/Win32
 
     };
 #endif // Unix&OS2/Win32
 
-    DECLARE_NO_COPY_CLASS(wxCriticalSection)
+    wxDECLARE_NO_COPY_CLASS(wxCriticalSection);
 };
 
 #if wxCRITSECT_IS_MUTEX
     // implement wxCriticalSection using mutexes
 };
 
 #if wxCRITSECT_IS_MUTEX
     // implement wxCriticalSection using mutexes
-    inline wxCriticalSection::wxCriticalSection( wxCriticalSectionType critSecType ) 
+    inline wxCriticalSection::wxCriticalSection( wxCriticalSectionType critSecType )
        : m_mutex( critSecType == wxCRITSEC_DEFAULT ? wxMUTEX_RECURSIVE : wxMUTEX_DEFAULT )  { }
     inline wxCriticalSection::~wxCriticalSection() { }
 
     inline void wxCriticalSection::Enter() { (void)m_mutex.Lock(); }
        : m_mutex( critSecType == wxCRITSEC_DEFAULT ? wxMUTEX_RECURSIVE : wxMUTEX_DEFAULT )  { }
     inline wxCriticalSection::~wxCriticalSection() { }
 
     inline void wxCriticalSection::Enter() { (void)m_mutex.Lock(); }
+    inline bool wxCriticalSection::TryEnter() { return m_mutex.TryLock() == wxMUTEX_NO_ERROR; }
     inline void wxCriticalSection::Leave() { (void)m_mutex.Unlock(); }
 #endif // wxCRITSECT_IS_MUTEX
 
     inline void wxCriticalSection::Leave() { (void)m_mutex.Unlock(); }
 #endif // wxCRITSECT_IS_MUTEX
 
@@ -301,7 +316,7 @@ public:
 private:
     wxCriticalSection& m_critsect;
 
 private:
     wxCriticalSection& m_critsect;
 
-    DECLARE_NO_COPY_CLASS(wxCriticalSectionLocker)
+    wxDECLARE_NO_COPY_CLASS(wxCriticalSectionLocker);
 };
 
 // ----------------------------------------------------------------------------
 };
 
 // ----------------------------------------------------------------------------
@@ -364,7 +379,7 @@ public:
 private:
     wxConditionInternal *m_internal;
 
 private:
     wxConditionInternal *m_internal;
 
-    DECLARE_NO_COPY_CLASS(wxCondition)
+    wxDECLARE_NO_COPY_CLASS(wxCondition);
 };
 
 #if WXWIN_COMPATIBILITY_2_6
 };
 
 #if WXWIN_COMPATIBILITY_2_6
@@ -409,7 +424,7 @@ public:
 private:
     wxSemaphoreInternal *m_internal;
 
 private:
     wxSemaphoreInternal *m_internal;
 
-    DECLARE_NO_COPY_CLASS(wxSemaphore)
+    wxDECLARE_NO_COPY_CLASS(wxSemaphore);
 };
 
 // ----------------------------------------------------------------------------
 };
 
 // ----------------------------------------------------------------------------
@@ -447,7 +462,17 @@ public:
     static wxThread *This();
 
         // Returns true if current thread is the main thread.
     static wxThread *This();
 
         // Returns true if current thread is the main thread.
-    static bool IsMain();
+        //
+        // Notice that it also returns true if main thread id hadn't been
+        // initialized yet on the assumption that it's too early in wx startup
+        // process for any other threads to have been created in this case.
+    static bool IsMain()
+    {
+        return !ms_idMainThread || GetCurrentId() == ms_idMainThread;
+    }
+
+        // Return the main thread id
+    static wxThreadIdType GetMainId() { return ms_idMainThread; }
 
         // Release the rest of our time slice letting the other threads run
     static void Yield();
 
         // Release the rest of our time slice letting the other threads run
     static void Yield();
@@ -466,7 +491,7 @@ public:
         // Get the platform specific thread ID and return as a long.  This
         // can be used to uniquely identify threads, even if they are not
         // wxThreads.  This is used by wxPython.
         // Get the platform specific thread ID and return as a long.  This
         // can be used to uniquely identify threads, even if they are not
         // wxThreads.  This is used by wxPython.
-   static wxThreadIdType GetCurrentId();
+    static wxThreadIdType GetCurrentId();
 
         // sets the concurrency level: this is, roughly, the number of threads
         // the system tries to schedule to run in parallel. 0 means the
 
         // sets the concurrency level: this is, roughly, the number of threads
         // the system tries to schedule to run in parallel. 0 means the
@@ -506,13 +531,14 @@ public:
         // does it!
         //
         // will fill the rc pointer with the thread exit code if it's !NULL
         // does it!
         //
         // will fill the rc pointer with the thread exit code if it's !NULL
-    wxThreadError Delete(ExitCode *rc = (ExitCode *)NULL);
+    wxThreadError Delete(ExitCode *rc = NULL,
+                         wxThreadWait waitMode = wxTHREAD_WAIT_DEFAULT);
 
         // waits for a joinable thread to finish and returns its exit code
         //
         // Returns (ExitCode)-1 on error (for example, if the thread is not
         // joinable)
 
         // waits for a joinable thread to finish and returns its exit code
         //
         // Returns (ExitCode)-1 on error (for example, if the thread is not
         // joinable)
-    ExitCode Wait();
+    ExitCode Wait(wxThreadWait waitMode = wxTHREAD_WAIT_DEFAULT);
 
         // kills the thread without giving it any chance to clean up - should
         // not be used under normal circumstances, use Delete() instead.
 
         // kills the thread without giving it any chance to clean up - should
         // not be used under normal circumstances, use Delete() instead.
@@ -555,10 +581,8 @@ public:
     // identifies a thread inside a process
     wxThreadIdType GetId() const;
 
     // identifies a thread inside a process
     wxThreadIdType GetId() const;
 
-    // called when the thread exits - in the context of this thread
-    //
-    // NB: this function will not be called if the thread is Kill()ed
-    virtual void OnExit() { }
+    wxThreadKind GetKind() const
+        { return m_isDetached ? wxTHREAD_DETACHED : wxTHREAD_JOINABLE; }
 
     // Returns true if the thread was asked to terminate: this function should
     // be called by the thread from time to time, otherwise the main thread
 
     // Returns true if the thread was asked to terminate: this function should
     // be called by the thread from time to time, otherwise the main thread
@@ -577,12 +601,35 @@ protected:
     // of this thread.
     virtual void *Entry() = 0;
 
     // of this thread.
     virtual void *Entry() = 0;
 
+
+    // Callbacks which may be overridden by the derived class to perform some
+    // specific actions when the thread is deleted or killed. By default they
+    // do nothing.
+
+    // This one is called by Delete() before actually deleting the thread and
+    // is executed in the context of the thread that called Delete().
+    virtual void OnDelete() {}
+
+    // This one is called by Kill() before killing the thread and is executed
+    // in the context of the thread that called Kill().
+    virtual void OnKill() {}
+
 private:
     // no copy ctor/assignment operator
     wxThread(const wxThread&);
     wxThread& operator=(const wxThread&);
 
 private:
     // no copy ctor/assignment operator
     wxThread(const wxThread&);
     wxThread& operator=(const wxThread&);
 
+    // called when the thread exits - in the context of this thread
+    //
+    // NB: this function will not be called if the thread is Kill()ed
+    virtual void OnExit() { }
+
     friend class wxThreadInternal;
     friend class wxThreadInternal;
+    friend class wxThreadModule;
+
+
+    // the main thread identifier, should be set on startup
+    static wxThreadIdType ms_idMainThread;
 
     // the (platform-dependent) thread class implementation
     wxThreadInternal *m_internal;
 
     // the (platform-dependent) thread class implementation
     wxThreadInternal *m_internal;
@@ -630,20 +677,19 @@ class WXDLLIMPEXP_BASE wxThreadHelper
 private:
     void KillThread()
     {
 private:
     void KillThread()
     {
-        // If detached thread is about to finish, it will set
-        // m_thread to NULL so don't delete it then
-        // But if KillThread is called before detached thread
-        // sets it to NULL, then the thread object still
-        // exists and can be killed
+        // If wxThreadHelperThread is detached and is about to finish, it will
+        // set m_thread to NULL so don't delete it then.
+        // But if KillThread is called before wxThreadHelperThread (in detached mode)
+        // sets it to NULL, then the thread object still exists and can be killed
         wxCriticalSectionLocker locker(m_critSection);
         wxCriticalSectionLocker locker(m_critSection);
-    
+
         if ( m_thread )
         {
             m_thread->Kill();
         if ( m_thread )
         {
             m_thread->Kill();
-            
+
             if ( m_kind == wxTHREAD_JOINABLE )
               delete m_thread;
             if ( m_kind == wxTHREAD_JOINABLE )
               delete m_thread;
-            
+
             m_thread = NULL;
         }
     }
             m_thread = NULL;
         }
     }
@@ -656,12 +702,18 @@ public:
     // destructor deletes m_thread
     virtual ~wxThreadHelper() { KillThread(); }
 
     // destructor deletes m_thread
     virtual ~wxThreadHelper() { KillThread(); }
 
+#if WXWIN_COMPATIBILITY_2_8
+    wxDEPRECATED( wxThreadError Create(unsigned int stackSize = 0) );
+#endif
+
     // create a new thread (and optionally set the stack size on platforms that
     // support/need that), call Run() to start it
     // create a new thread (and optionally set the stack size on platforms that
     // support/need that), call Run() to start it
-    wxThreadError Create(unsigned int stackSize = 0)
+    wxThreadError CreateThread(wxThreadKind kind = wxTHREAD_JOINABLE,
+                               unsigned int stackSize = 0)
     {
         KillThread();
 
     {
         KillThread();
 
+        m_kind = kind;
         m_thread = new wxThreadHelperThread(*this, m_kind);
 
         return m_thread->Create(stackSize);
         m_thread = new wxThreadHelperThread(*this, m_kind);
 
         return m_thread->Create(stackSize);
@@ -675,9 +727,9 @@ public:
     wxThread *GetThread() const
     {
         wxCriticalSectionLocker locker((wxCriticalSection&)m_critSection);
     wxThread *GetThread() const
     {
         wxCriticalSectionLocker locker((wxCriticalSection&)m_critSection);
-        
+
         wxThread* thread = m_thread;
         wxThread* thread = m_thread;
-        
+
         return thread;
     }
 
         return thread;
     }
 
@@ -685,24 +737,29 @@ protected:
     wxThread *m_thread;
     wxThreadKind m_kind;
     wxCriticalSection m_critSection; // To guard the m_thread variable
     wxThread *m_thread;
     wxThreadKind m_kind;
     wxCriticalSection m_critSection; // To guard the m_thread variable
-    
+
     friend class wxThreadHelperThread;
 };
 
     friend class wxThreadHelperThread;
 };
 
+#if WXWIN_COMPATIBILITY_2_8
+inline wxThreadError wxThreadHelper::Create(unsigned int stackSize)
+{ return CreateThread(m_kind, stackSize); }
+#endif
+
 // call Entry() in owner, put it down here to avoid circular declarations
 inline void *wxThreadHelperThread::Entry()
 {
     void * const result = m_owner.Entry();
 // call Entry() in owner, put it down here to avoid circular declarations
 inline void *wxThreadHelperThread::Entry()
 {
     void * const result = m_owner.Entry();
-    
+
     wxCriticalSectionLocker locker(m_owner.m_critSection);
     wxCriticalSectionLocker locker(m_owner.m_critSection);
-    
+
     // Detached thread will be deleted after returning, so make sure
     // wxThreadHelper::GetThread will not return an invalid pointer.
     // And that wxThreadHelper::KillThread will not try to kill
     // an already deleted thread
     if ( m_owner.m_kind == wxTHREAD_DETACHED )
         m_owner.m_thread = NULL;
     // Detached thread will be deleted after returning, so make sure
     // wxThreadHelper::GetThread will not return an invalid pointer.
     // And that wxThreadHelper::KillThread will not try to kill
     // an already deleted thread
     if ( m_owner.m_kind == wxTHREAD_DETACHED )
         m_owner.m_thread = NULL;
-        
+
     return result;
 }
 
     return result;
 }
 
@@ -734,11 +791,13 @@ inline void wxMutexGuiLeave() { }
 
 // macros for entering/leaving critical sections which may be used without
 // having to take them inside "#if wxUSE_THREADS"
 
 // macros for entering/leaving critical sections which may be used without
 // having to take them inside "#if wxUSE_THREADS"
-// (the implementation uses dummy structs to force semicolon after the macro)
+// (the implementation uses dummy structs to force semicolon after the macro;
+// also notice that Watcom doesn't like declaring a struct as a member so we
+// need to actually define it in wxCRIT_SECT_DECLARE_MEMBER)
 #define wxENTER_CRIT_SECT(cs)            do {} while (0)
 #define wxLEAVE_CRIT_SECT(cs)            do {} while (0)
 #define wxCRIT_SECT_DECLARE(cs)          struct wxDummyCS##cs
 #define wxENTER_CRIT_SECT(cs)            do {} while (0)
 #define wxLEAVE_CRIT_SECT(cs)            do {} while (0)
 #define wxCRIT_SECT_DECLARE(cs)          struct wxDummyCS##cs
-#define wxCRIT_SECT_DECLARE_MEMBER(cs)   struct wxDummyCSMember##cs
+#define wxCRIT_SECT_DECLARE_MEMBER(cs)   struct wxDummyCSMember##cs { }
 #define wxCRIT_SECT_LOCKER(name, cs)     struct wxDummyCSLocker##name
 
 // if there is only one thread, it is always the main one
 #define wxCRIT_SECT_LOCKER(name, cs)     struct wxDummyCSLocker##name
 
 // if there is only one thread, it is always the main one
@@ -781,7 +840,7 @@ public:
 
 #if wxUSE_THREADS
 
 
 #if wxUSE_THREADS
 
-#if defined(__WXMSW__) || defined(__OS2__) || defined(__EMX__)
+#if defined(__WINDOWS__) || defined(__OS2__) || defined(__EMX__) || defined(__DARWIN__)
     // unlock GUI if there are threads waiting for and lock it back when
     // there are no more of them - should be called periodically by the main
     // thread
     // unlock GUI if there are threads waiting for and lock it back when
     // there are no more of them - should be called periodically by the main
     // thread
@@ -793,9 +852,11 @@ public:
     // wakes up the main thread if it's sleeping inside ::GetMessage()
     extern void WXDLLIMPEXP_BASE wxWakeUpMainThread();
 
     // wakes up the main thread if it's sleeping inside ::GetMessage()
     extern void WXDLLIMPEXP_BASE wxWakeUpMainThread();
 
+#ifndef __DARWIN__
     // return true if the main thread is waiting for some other to terminate:
     // wxApp then should block all "dangerous" messages
     extern bool WXDLLIMPEXP_BASE wxIsWaitingForThread();
     // return true if the main thread is waiting for some other to terminate:
     // wxApp then should block all "dangerous" messages
     extern bool WXDLLIMPEXP_BASE wxIsWaitingForThread();
+#endif
 #endif // MSW, OS/2
 
 #endif // wxUSE_THREADS
 #endif // MSW, OS/2
 
 #endif // wxUSE_THREADS