Better support for unspecified property value in wxDateProperty and DatePickerCtrl...

[wxWidgets.git] / include / wx / thread.h

diff --git a/include/wx/thread.h b/include/wx/thread.h
index 07f886e973f17968c752b828785bfd3ee2d07fc1..0b237cb4f2a787ee34c2f1498284249c1dfd0643 100644 (file)
--- a/include/wx/thread.h
+++ b/include/wx/thread.h
@@ -22,20 +22,6 @@
 
 #if wxUSE_THREADS
 
 
 #if wxUSE_THREADS
 

-// only for wxUSE_THREADS - otherwise we'd get undefined symbols
-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
-    #pragma interface "thread.h"
-#endif
-
-// Windows headers define it
-#ifdef Yield
-    #undef Yield
-#endif
-
-#ifdef __WXMSW__
-    #include "wx/msw/wrapwin.h"
-#endif
-

 // ----------------------------------------------------------------------------
 // constants
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // constants
 // ----------------------------------------------------------------------------


@@ -47,6 +33,7 @@ enum wxMutexError
     wxMUTEX_DEAD_LOCK,      // mutex is already locked by the calling thread
     wxMUTEX_BUSY,           // mutex is already locked by another thread
     wxMUTEX_UNLOCKED,       // attempt to unlock a mutex which is not locked
     wxMUTEX_DEAD_LOCK,      // mutex is already locked by the calling thread
     wxMUTEX_BUSY,           // mutex is already locked by another thread
     wxMUTEX_UNLOCKED,       // attempt to unlock a mutex which is not locked

+    wxMUTEX_TIMEOUT,        // LockTimeout() has timed out

     wxMUTEX_MISC_ERROR      // any other error
 };
 
     wxMUTEX_MISC_ERROR      // any other error
 };
 


@@ -118,11 +105,11 @@ enum wxMutexType
 };
 
 // forward declarations
 };
 
 // forward declarations

-class WXDLLIMPEXP_BASE wxThreadHelper;
-class WXDLLIMPEXP_BASE wxConditionInternal;
-class WXDLLIMPEXP_BASE wxMutexInternal;
-class WXDLLIMPEXP_BASE wxSemaphoreInternal;
-class WXDLLIMPEXP_BASE wxThreadInternal;
+class WXDLLIMPEXP_FWD_BASE wxThreadHelper;
+class WXDLLIMPEXP_FWD_BASE wxConditionInternal;
+class WXDLLIMPEXP_FWD_BASE wxMutexInternal;
+class WXDLLIMPEXP_FWD_BASE wxSemaphoreInternal;
+class WXDLLIMPEXP_FWD_BASE wxThreadInternal;

 
 // ----------------------------------------------------------------------------
 // A mutex object is a synchronization object whose state is set to signaled
 
 // ----------------------------------------------------------------------------
 // A mutex object is a synchronization object whose state is set to signaled


@@ -158,6 +145,10 @@ public:
     // The caller must call Unlock() later if Lock() returned wxMUTEX_NO_ERROR.
     wxMutexError Lock();
 
     // The caller must call Unlock() later if Lock() returned wxMUTEX_NO_ERROR.
     wxMutexError Lock();
 

+    // Same as Lock() but return wxMUTEX_TIMEOUT if the mutex can't be locked
+    // during the given number of milliseconds
+    wxMutexError LockTimeout(unsigned long ms);
+

     // Try to lock the mutex: if it is currently locked, return immediately
     // with an error. Otherwise the caller must call Unlock().
     wxMutexError TryLock();
     // Try to lock the mutex: if it is currently locked, return immediately
     // with an error. Otherwise the caller must call Unlock().
     wxMutexError TryLock();


@@ -213,25 +204,33 @@ 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__) && !defined(__WXMAC__)
+#if !defined(__WXMSW__)

     #define wxCRITSECT_IS_MUTEX 1
 
     #define wxCRITSECT_IS_MUTEX 1
 

-    #define wxCRITSECT_INLINE inline
+    #define wxCRITSECT_INLINE WXEXPORT inline

 #else // MSW
     #define wxCRITSECT_IS_MUTEX 0
 
     #define wxCRITSECT_INLINE
 #endif // MSW/!MSW
 
 #else // MSW
     #define wxCRITSECT_IS_MUTEX 0
 
     #define wxCRITSECT_INLINE
 #endif // MSW/!MSW
 

+enum wxCriticalSectionType
+{
+    // recursive critical section
+    wxCRITSEC_DEFAULT,
+
+    // non-recursive critical section
+    wxCRITSEC_NON_RECURSIVE
+};
+

 // you should consider wxCriticalSectionLocker whenever possible instead of
 // directly working with wxCriticalSection class - it is safer
 class WXDLLIMPEXP_BASE wxCriticalSection
 {
 public:
     // ctor & dtor
 // you should consider wxCriticalSectionLocker whenever possible instead of
 // directly working with wxCriticalSection class - it is safer
 class WXDLLIMPEXP_BASE wxCriticalSection
 {
 public:
     // ctor & dtor

-    wxCRITSECT_INLINE wxCriticalSection();
+    wxCRITSECT_INLINE wxCriticalSection( wxCriticalSectionType critSecType = wxCRITSEC_DEFAULT );

     wxCRITSECT_INLINE ~wxCriticalSection();
     wxCRITSECT_INLINE ~wxCriticalSection();

-

     // 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();
 


@@ -247,7 +246,8 @@ private:
     // include windows.h from this public header and we also have to use the
     // union to force the correct (i.e. maximal) alignment
     //
     // include windows.h from this public header and we also have to use the
     // union to force the correct (i.e. maximal) alignment
     //

-    // if CRITICAL_SECTION size changes in Windows, you'll get an assert below
+    // 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
     //
     // finally, we need this typedef instead of declaring m_buffer directly
     // because otherwise the assert mentioned above wouldn't compile with some


@@ -257,10 +257,6 @@ private:
 #else // __WIN32__
     typedef char wxCritSectBuffer[24];
 #endif
 #else // __WIN32__
     typedef char wxCritSectBuffer[24];
 #endif

-
-wxCOMPILE_TIME_ASSERT( sizeof(CRITICAL_SECTION) <= sizeof(wxCritSectBuffer),
-                       wxCriticalSectionBufferTooSmall );
-

     union
     {
         unsigned long m_dummy1;
     union
     {
         unsigned long m_dummy1;


@@ -268,8 +264,6 @@ wxCOMPILE_TIME_ASSERT( sizeof(CRITICAL_SECTION) <= sizeof(wxCritSectBuffer),
 
         wxCritSectBuffer m_buffer;
     };
 
         wxCritSectBuffer m_buffer;
     };

-#elif defined(__WXMAC__)
-    void *m_critRegion ;

 #endif // Unix&OS2/Win32
 
     DECLARE_NO_COPY_CLASS(wxCriticalSection)
 #endif // Unix&OS2/Win32
 
     DECLARE_NO_COPY_CLASS(wxCriticalSection)


@@ -277,7 +271,8 @@ wxCOMPILE_TIME_ASSERT( sizeof(CRITICAL_SECTION) <= sizeof(wxCritSectBuffer),
 
 #if wxCRITSECT_IS_MUTEX
     // implement wxCriticalSection using mutexes
 
 #if wxCRITSECT_IS_MUTEX
     // implement wxCriticalSection using mutexes

-    inline wxCriticalSection::wxCriticalSection() { }
+    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(); }
     inline wxCriticalSection::~wxCriticalSection() { }
 
     inline void wxCriticalSection::Enter() { (void)m_mutex.Lock(); }


@@ -336,19 +331,19 @@ public:
     wxCondError Wait();
 
     // exactly as Wait() except that it may also return if the specified
     wxCondError Wait();
 
     // exactly as Wait() except that it may also return if the specified

-    // timeout ellapses even if the condition hasn't been signalled: in this
+    // timeout elapses even if the condition hasn't been signalled: in this

     // case, the return value is false, otherwise (i.e. in case of a normal
     // return) it is true
     //
     // case, the return value is false, otherwise (i.e. in case of a normal
     // return) it is true
     //

-    // the timeeout parameter specifies a interval that needs to be waited in
-    // milliseconds
+    // the timeout parameter specifies an interval that needs to be waited for
+    // in milliseconds

     wxCondError WaitTimeout(unsigned long milliseconds);
 
     // NB: the associated mutex may or may not be locked by the calling thread
     //
     // this method unblocks one thread if any are blocking on the condition.
     // if no thread is blocking in Wait(), then the signal is NOT remembered
     wxCondError WaitTimeout(unsigned long milliseconds);
 
     // NB: the associated mutex may or may not be locked by the calling thread
     //
     // this method unblocks one thread if any are blocking on the condition.
     // if no thread is blocking in Wait(), then the signal is NOT remembered

-    // The thread which was blocking on Wait(), will then reacquire the lock
+    // The thread which was blocking on Wait() will then reacquire the lock

     // on the associated mutex object before returning
     wxCondError Signal();
 
     // on the associated mutex object before returning
     wxCondError Signal();
 


@@ -356,14 +351,15 @@ public:
     //
     // this method unblocks all threads if any are blocking on the condition.
     // if no thread is blocking in Wait(), then the signal is NOT remembered
     //
     // this method unblocks all threads if any are blocking on the condition.
     // if no thread is blocking in Wait(), then the signal is NOT remembered

-    // The threads which were blocking on Wait(), will then reacquire the lock
+    // The threads which were blocking on Wait() will then reacquire the lock

     // on the associated mutex object before returning.
     wxCondError Broadcast();
 
 
     // on the associated mutex object before returning.
     wxCondError Broadcast();
 
 

+#if WXWIN_COMPATIBILITY_2_6

     // deprecated version, don't use
     // deprecated version, don't use

-    bool Wait(unsigned long milliseconds)
-        { return WaitTimeout(milliseconds) == wxCOND_NO_ERROR; }
+    wxDEPRECATED( bool Wait(unsigned long milliseconds) );
+#endif // WXWIN_COMPATIBILITY_2_6

 
 private:
     wxConditionInternal *m_internal;
 
 private:
     wxConditionInternal *m_internal;


@@ -371,6 +367,11 @@ private:
     DECLARE_NO_COPY_CLASS(wxCondition)
 };
 
     DECLARE_NO_COPY_CLASS(wxCondition)
 };
 

+#if WXWIN_COMPATIBILITY_2_6
+    inline bool wxCondition::Wait(unsigned long milliseconds)
+        { return WaitTimeout(milliseconds) == wxCOND_NO_ERROR; }
+#endif // WXWIN_COMPATIBILITY_2_6
+

 // ----------------------------------------------------------------------------
 // wxSemaphore: a counter limiting the number of threads concurrently accessing
 //              a shared resource
 // ----------------------------------------------------------------------------
 // wxSemaphore: a counter limiting the number of threads concurrently accessing
 //              a shared resource


@@ -399,7 +400,7 @@ public:
     wxSemaError TryWait();
 
     // same as Wait(), but as a timeout limit, returns wxSEMA_NO_ERROR if the
     wxSemaError TryWait();
 
     // same as Wait(), but as a timeout limit, returns wxSEMA_NO_ERROR if the

-    // semaphore was acquired and wxSEMA_TIMEOUT if the timeout has ellapsed
+    // semaphore was acquired and wxSEMA_TIMEOUT if the timeout has elapsed

     wxSemaError WaitTimeout(unsigned long milliseconds);
 
     // increments the semaphore count and signals one of the waiting threads
     wxSemaError WaitTimeout(unsigned long milliseconds);
 
     // increments the semaphore count and signals one of the waiting threads


@@ -448,12 +449,12 @@ public:
         // Returns true if current thread is the main thread.
     static bool IsMain();
 
         // Returns true if current thread is the main thread.
     static bool IsMain();
 

-        // Release the rest of our time slice leting the other threads run
+        // Release the rest of our time slice letting the other threads run

     static void Yield();
 
         // Sleep during the specified period of time in milliseconds
         //
     static void Yield();
 
         // Sleep during the specified period of time in milliseconds
         //

-        // NB: at least under MSW worker threads can not call ::wxSleep()!
+        // This is the same as wxMilliSleep().

     static void Sleep(unsigned long milliseconds);
 
         // get the number of system CPUs - useful with SetConcurrency()
     static void Sleep(unsigned long milliseconds);
 
         // get the number of system CPUs - useful with SetConcurrency()


@@ -514,9 +515,9 @@ public:
     ExitCode Wait();
 
         // kills the thread without giving it any chance to clean up - should
     ExitCode Wait();
 
         // kills the thread without giving it any chance to clean up - should

-        // not be used in normal circumstances, use Delete() instead. It is a
-        // dangerous function that should only be used in the most extreme
-        // cases!
+        // not be used under normal circumstances, use Delete() instead.
+        // It is a dangerous function that should only be used in the most
+        // extreme cases!

         //
         // The wxThread object is deleted by Kill() if the thread is
         // detachable, but you still have to delete it manually for joinable
         //
         // The wxThread object is deleted by Kill() if the thread is
         // detachable, but you still have to delete it manually for joinable


@@ -554,10 +555,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


@@ -581,6 +580,11 @@ private:
     wxThread(const wxThread&);
     wxThread& operator=(const wxThread&);
 
     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;
 
     // the (platform-dependent) thread class implementation
     friend class wxThreadInternal;
 
     // the (platform-dependent) thread class implementation


@@ -601,8 +605,8 @@ class WXDLLIMPEXP_BASE wxThreadHelperThread : public wxThread
 public:
     // constructor only creates the C++ thread object and doesn't create (or
     // start) the real thread
 public:
     // constructor only creates the C++ thread object and doesn't create (or
     // start) the real thread

-    wxThreadHelperThread(wxThreadHelper& owner)
-        : wxThread(wxTHREAD_JOINABLE), m_owner(owner)
+    wxThreadHelperThread(wxThreadHelper& owner, wxThreadKind kind)
+        : wxThread(kind), m_owner(owner)

         { }
 
 protected:
         { }
 
 protected:


@@ -629,27 +633,44 @@ class WXDLLIMPEXP_BASE wxThreadHelper
 private:
     void KillThread()
     {
 private:
     void KillThread()
     {

+        // 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);
+

         if ( m_thread )
         {
             m_thread->Kill();
         if ( m_thread )
         {
             m_thread->Kill();

-            delete m_thread;
+
+            if ( m_kind == wxTHREAD_JOINABLE )
+              delete m_thread;
+
+            m_thread = NULL;

         }
     }
 
 public:
     // constructor only initializes m_thread to NULL
         }
     }
 
 public:
     // constructor only initializes m_thread to NULL

-    wxThreadHelper() : m_thread(NULL) { }
+    wxThreadHelper(wxThreadKind kind = wxTHREAD_JOINABLE)
+        : m_thread(NULL), m_kind(kind) { }

 
     // 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_thread = new wxThreadHelperThread(*this);
+        m_kind = kind;
+        m_thread = new wxThreadHelperThread(*this, m_kind);

 
         return m_thread->Create(stackSize);
     }
 
         return m_thread->Create(stackSize);
     }


@@ -659,16 +680,43 @@ public:
     virtual void *Entry() = 0;
 
     // returns a pointer to the thread which can be used to call Run()
     virtual void *Entry() = 0;
 
     // returns a pointer to the thread which can be used to call Run()

-    wxThread *GetThread() const { return m_thread; }
+    wxThread *GetThread() const
+    {
+        wxCriticalSectionLocker locker((wxCriticalSection&)m_critSection);
+
+        wxThread* thread = m_thread;
+
+        return thread;
+    }

 
 protected:
     wxThread *m_thread;
 
 protected:
     wxThread *m_thread;

+    wxThreadKind m_kind;
+    wxCriticalSection m_critSection; // To guard the m_thread variable
+
+    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()
 {
 // call Entry() in owner, put it down here to avoid circular declarations
 inline void *wxThreadHelperThread::Entry()
 {

-    return m_owner.Entry();
+    void * const result = m_owner.Entry();
+
+    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;
+
+    return result;

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------


@@ -694,16 +742,17 @@ inline bool wxIsMainThread() { return wxThread::IsMain(); }
 #else // !wxUSE_THREADS
 
 // no thread support
 #else // !wxUSE_THREADS
 
 // no thread support

-inline void WXDLLIMPEXP_BASE wxMutexGuiEnter() { }
-inline void WXDLLIMPEXP_BASE wxMutexGuiLeave() { }
+inline void wxMutexGuiEnter() { }
+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"

-#define wxENTER_CRIT_SECT(cs)
-#define wxLEAVE_CRIT_SECT(cs)
-#define wxCRIT_SECT_DECLARE(cs)
-#define wxCRIT_SECT_DECLARE_MEMBER(cs)
-#define wxCRIT_SECT_LOCKER(name, cs)
+// (the implementation uses dummy structs to force semicolon after the macro)
+#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_LOCKER(name, cs)     struct wxDummyCSLocker##name

 
 // if there is only one thread, it is always the main one
 inline bool wxIsMainThread() { return true; }
 
 // if there is only one thread, it is always the main one
 inline bool wxIsMainThread() { return true; }


@@ -745,7 +794,7 @@ public:
 
 #if wxUSE_THREADS
 
 
 #if wxUSE_THREADS
 

-#if defined(__WXMSW__) || defined(__WXMAC__) || defined(__WXPM__) || defined(__EMX__)
+#if defined(__WXMSW__) || defined(__OS2__) || defined(__EMX__)

     // 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


@@ -754,17 +803,14 @@ public:
     // returns true if the main thread has GUI lock
     extern bool WXDLLIMPEXP_BASE wxGuiOwnedByMainThread();
 
     // returns true if the main thread has GUI lock
     extern bool WXDLLIMPEXP_BASE wxGuiOwnedByMainThread();
 

-#ifndef __WXPM__

     // 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();

-#endif // !OS/2

 
     // 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 // MSW, Mac, OS/2
+#endif // MSW, OS/2

 
 #endif // wxUSE_THREADS
 
 #endif // _WX_THREAD_H_
 
 #endif // wxUSE_THREADS
 
 #endif // _WX_THREAD_H_

-