warning suppressed for MSVC++

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

diff --git a/include/wx/thread.h b/include/wx/thread.h
index d5cd919400a81e900e887161f6bf9c2c900e4fbf..909608c60620a094ee0eae6199bbeca97a69da52 100644 (file)
--- a/include/wx/thread.h
+++ b/include/wx/thread.h
@@ -64,25 +64,29 @@ class WXDLLEXPORT wxMutexInternal;
 class WXDLLEXPORT wxMutex 
 {
 public:
 class WXDLLEXPORT wxMutex 
 {
 public:

-  // constructor & destructor 
-  wxMutex();
-  ~wxMutex();
+    // constructor & destructor 
+    wxMutex();
+    ~wxMutex();

 
 

-  // Lock the mutex.
-  wxMutexError Lock();
-  // Try to lock the mutex: if it can't, returns immediately with an error.
-  wxMutexError TryLock();
-  // Unlock the mutex.
-  wxMutexError Unlock();
+    // Lock the mutex.
+    wxMutexError Lock();
+    // Try to lock the mutex: if it can't, returns immediately with an error.
+    wxMutexError TryLock();
+    // Unlock the mutex.
+    wxMutexError Unlock();

 
 

-  // Returns true if the mutex is locked.
-  bool IsLocked() const { return (m_locked > 0); }
+    // Returns true if the mutex is locked.
+    bool IsLocked() const { return (m_locked > 0); }

 
 protected:
 
 protected:

-  friend class wxCondition;
+    friend class wxCondition;

 
 

-  int m_locked;
-  wxMutexInternal *p_internal;
+    // no assignment operator nor copy ctor
+    wxMutex(const wxMutex&);
+    wxMutex& operator=(const wxMutex&);
+
+    int m_locked;
+    wxMutexInternal *p_internal;

 };
 
 // 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:


@@ -102,12 +106,14 @@ public:
     ~wxMutexLocker() { if ( IsOk() ) m_mutex->Unlock(); }
 
 private:
     ~wxMutexLocker() { if ( IsOk() ) m_mutex->Unlock(); }
 
 private:

+    // no assignment operator nor copy ctor
+    wxMutexLocker(const wxMutexLocker&);
+    wxMutexLocker& operator=(const wxMutexLocker&);
+

     bool     m_isOk;
     wxMutex *m_mutex;
 };
 
     bool     m_isOk;
     wxMutex *m_mutex;
 };
 

-#ifdef __WXMSW__
-

 // ----------------------------------------------------------------------------
 // Critical section: this is the same as mutex but is only visible to the
 // threads of the same process. For the platforms which don't have native
 // ----------------------------------------------------------------------------
 // Critical section: this is the same as mutex but is only visible to the
 // threads of the same process. For the platforms which don't have native


@@ -117,21 +123,34 @@ private:
 
 // you should consider wxCriticalSectionLocker whenever possible instead of
 // directly working with wxCriticalSection class - it is safer
 
 // you should consider wxCriticalSectionLocker whenever possible instead of
 // directly working with wxCriticalSection class - it is safer

-class WXDLLEXPORT wxCriticalSectionInternal;
+#ifdef __WXMSW__
+    class WXDLLEXPORT wxCriticalSectionInternal;
+    #define WXCRITICAL_INLINE
+#else // !MSW
+    #define WXCRITICAL_INLINE   inline
+#endif // MSW/!MSW

 class WXDLLEXPORT wxCriticalSection
 {
 public:
     // ctor & dtor
 class WXDLLEXPORT wxCriticalSection
 {
 public:
     // ctor & dtor

-    wxCriticalSection();
-    ~wxCriticalSection();
+    WXCRITICAL_INLINE wxCriticalSection();
+    WXCRITICAL_INLINE ~wxCriticalSection();

 
     // enter the section (the same as locking a mutex)
 
     // enter the section (the same as locking a mutex)

-    void Enter();
+    void WXCRITICAL_INLINE Enter();

     // leave the critical section (same as unlocking a mutex)
     // leave the critical section (same as unlocking a mutex)

-    void Leave();
+    void WXCRITICAL_INLINE Leave();

 
 private:
 
 private:

+    // no assignment operator nor copy ctor
+    wxCriticalSection(const wxCriticalSection&);
+    wxCriticalSection& operator=(const wxCriticalSection&);
+
+#ifdef __WXMSW__

     wxCriticalSectionInternal *m_critsect;
     wxCriticalSectionInternal *m_critsect;

+#else // !MSW
+    wxMutex m_mutex;
+#endif // MSW/!MSW

 };
 
 // wxCriticalSectionLocker is the same to critical sections as wxMutexLocker is
 };
 
 // wxCriticalSectionLocker is the same to critical sections as wxMutexLocker is


@@ -139,16 +158,18 @@ private:
 class WXDLLEXPORT wxCriticalSectionLocker
 {
 public:
 class WXDLLEXPORT wxCriticalSectionLocker
 {
 public:

-    wxCriticalSectionLocker(wxCriticalSection *critsect)
-        { (m_critsect = critsect)->Enter(); }
+    wxCriticalSectionLocker(wxCriticalSection& critsect) : m_critsect(critsect)
+        { m_critsect.Enter(); }

     ~wxCriticalSectionLocker()
     ~wxCriticalSectionLocker()

-        { m_critsect->Leave(); }
+        { m_critsect.Leave(); }

 
 private:
 
 private:

-    wxCriticalSection *m_critsect;
-};
+    // no assignment operator nor copy ctor
+    wxCriticalSectionLocker(const wxCriticalSectionLocker&);
+    wxCriticalSectionLocker& operator=(const wxCriticalSectionLocker&);

 
 

-#endif
+    wxCriticalSection& m_critsect;
+};

 
 // ----------------------------------------------------------------------------
 // Condition handler.
 
 // ----------------------------------------------------------------------------
 // Condition handler.


@@ -261,4 +282,37 @@ inline void WXDLLEXPORT wxMutexGuiLeave() { }
 
 #endif // wxUSE_THREADS
 
 
 #endif // wxUSE_THREADS
 

+// automatically unlock GUI mutex in dtor
+class WXDLLEXPORT wxMutexGuiLocker
+{
+public:
+    wxMutexGuiLocker() { wxMutexGuiEnter(); }
+   ~wxMutexGuiLocker() { wxMutexGuiLeave(); }
+};
+
+// -----------------------------------------------------------------------------
+// implementation only until the end of file
+// -----------------------------------------------------------------------------
+#ifdef wxUSE_THREADS
+#ifdef __WXMSW__
+    // 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
+    extern void WXDLLEXPORT wxMutexGuiLeaveOrEnter();
+
+    // returns TRUE if the main thread has GUI lock
+    extern bool WXDLLEXPORT wxGuiOwnedByMainThread();
+
+    // wakes up the main thread if it's sleeping inside ::GetMessage()
+    extern void WXDLLEXPORT wxWakeUpMainThread();
+#else // !MSW
+    // implement wxCriticalSection using mutexes
+    inline wxCriticalSection::wxCriticalSection() { }
+    inline wxCriticalSection::~wxCriticalSection() { }
+
+    inline void wxCriticalSection::Enter() { (void)m_mutex.Lock(); }
+    inline void wxCriticalSection::Leave() { (void)m_mutex.Unlock(); }
+#endif // MSW/!MSW
+#endif // wxUSE_THREADS
+

 #endif // __THREADH__
 #endif // __THREADH__