Move wxCocoa's wxFontRefData from the header to the implementation file.

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

diff --git a/include/wx/thread.h b/include/wx/thread.h
index e25c3d06474ce16760b3e7134e6e52fe6d27b967..10c30ead59761702df4657804d6ef3b146cc4fa5 100644 (file)
--- a/include/wx/thread.h
+++ b/include/wx/thread.h
@@ -38,6 +38,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
 };
 


@@ -109,11 +110,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


@@ -149,6 +150,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();


@@ -324,19 +329,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();
 


@@ -344,14 +349,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;


@@ -359,6 +365,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


@@ -387,7 +398,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


@@ -436,7 +447,7 @@ 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


@@ -502,9 +513,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


@@ -682,8 +693,8 @@ 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"


@@ -733,7 +744,7 @@ public:
 
 #if wxUSE_THREADS
 
 
 #if wxUSE_THREADS
 

-#if defined(__WXMSW__) || defined(__WXMAC__) || defined(__WXPM__) || defined(__EMX__)
+#if defined(__WXMSW__) || defined(__WXMAC__) || 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


@@ -742,10 +753,8 @@ 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
 
     // return true if the main thread is waiting for some other to terminate:
     // wxApp then should block all "dangerous" messages


@@ -755,4 +764,3 @@ public:
 #endif // wxUSE_THREADS
 
 #endif // _WX_THREAD_H_
 #endif // wxUSE_THREADS
 
 #endif // _WX_THREAD_H_

-