unicode fixes, enabling notebook images again

[wxWidgets.git] / src / mac / carbon / thread.cpp

diff --git a/src/mac/carbon/thread.cpp b/src/mac/carbon/thread.cpp
index dce44db526d5d97d838ab704b8e4b6920ce6a1e7..8c64c8818ae3f9b2aa2b261aea86bdfd96da4562 100644 (file)
--- a/src/mac/carbon/thread.cpp
+++ b/src/mac/carbon/thread.cpp
@@ -35,12 +35,12 @@
 #include "wx/thread.h"
 
 #ifdef __WXMAC__
 #include "wx/thread.h"
 
 #ifdef __WXMAC__

-#ifndef __DARWIN__

 #include <Threads.h>
 #include <Threads.h>

-#endif

 #include "wx/mac/uma.h"
 #endif
 
 #include "wx/mac/uma.h"
 #endif
 

+#define INFINITE 0xFFFFFFFF
+

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


@@ -70,7 +70,7 @@ static bool gs_waitingForThread = FALSE ;
 class wxMacStCritical
 {
 public :
 class wxMacStCritical
 {
 public :

-    wxMacStCritical() 
+    wxMacStCritical()

     {
         if ( UMASystemIsInitialized() )
             ThreadBeginCritical() ;
     {
         if ( UMASystemIsInitialized() )
             ThreadBeginCritical() ;


@@ -89,38 +89,32 @@ public :
 class wxMutexInternal
 {
 public:
 class wxMutexInternal
 {
 public:

-    wxMutexInternal()
+    wxMutexInternal(wxMutexType WXUNUSED(mutexType))

     {
         m_owner = kNoThreadID ;
     {
         m_owner = kNoThreadID ;

+        m_locked = 0;

     }
 
     }
 

-    ~wxMutexInternal() 
+    ~wxMutexInternal()

     {
     {

+        if ( m_locked > 0 )
+        {
+            wxLogDebug(_T("Warning: freeing a locked mutex (%ld locks)."), m_locked);
+        }

     }
 
     }
 

+    bool IsOk() const { return true; }
+
+    wxMutexError Lock() ;
+    wxMutexError TryLock() ;
+    wxMutexError Unlock();

 public:
     ThreadID m_owner ;
     wxArrayLong m_waiters ;
 public:
     ThreadID m_owner ;
     wxArrayLong m_waiters ;

+    long m_locked ;

 };
 
 };
 

-wxMutex::wxMutex()
-{
-    m_internal = new wxMutexInternal;
-
-    m_locked = 0;
-}
-
-wxMutex::~wxMutex()
-{
-    if ( m_locked > 0 )
-    {
-        wxLogDebug(_T("Warning: freeing a locked mutex (%d locks)."), m_locked);
-    }
-
-    delete m_internal;
-}
-
-wxMutexError wxMutex::Lock()
+wxMutexError wxMutexInternal::Lock()

 {
     wxMacStCritical critical ;
     if ( UMASystemIsInitialized() )
 {
     wxMacStCritical critical ;
     if ( UMASystemIsInitialized() )


@@ -130,63 +124,62 @@ wxMutexError wxMutex::Lock()
         err = ::MacGetCurrentThread(&current);
         // if we are not the owner, add this thread to the list of waiting threads, stop this thread
         // and invoke the scheduler to continue executing the owner's thread
         err = ::MacGetCurrentThread(&current);
         // if we are not the owner, add this thread to the list of waiting threads, stop this thread
         // and invoke the scheduler to continue executing the owner's thread

-        while ( m_internal->m_owner != kNoThreadID && m_internal->m_owner != current) 
+        while ( m_owner != kNoThreadID && m_owner != current)

         {
         {

-            m_internal->m_waiters.Add(current);
-            err = ::SetThreadStateEndCritical(kCurrentThreadID, kStoppedThreadState, m_internal->m_owner);
+            m_waiters.Add(current);
+            err = ::SetThreadStateEndCritical(kCurrentThreadID, kStoppedThreadState, m_owner);

             err = ::ThreadBeginCritical();
         }
             err = ::ThreadBeginCritical();
         }

-        m_internal->m_owner = current;
+        m_owner = current;

     }
     m_locked++;
 
     return wxMUTEX_NO_ERROR;
 }
 
     }
     m_locked++;
 
     return wxMUTEX_NO_ERROR;
 }
 

-wxMutexError wxMutex::TryLock()
+wxMutexError wxMutexInternal::TryLock()

 {
     wxMacStCritical critical ;
     if ( UMASystemIsInitialized() )
 {
     wxMacStCritical critical ;
     if ( UMASystemIsInitialized() )

-    {    
-        OSErr err ;
+    {

         ThreadID current = kNoThreadID;
         ::MacGetCurrentThread(&current);
         // if we are not the owner, give an error back
         ThreadID current = kNoThreadID;
         ::MacGetCurrentThread(&current);
         // if we are not the owner, give an error back

-        if ( m_internal->m_owner != kNoThreadID && m_internal->m_owner != current ) 
+        if ( m_owner != kNoThreadID && m_owner != current )

             return wxMUTEX_BUSY;
             return wxMUTEX_BUSY;

-            
-        m_internal->m_owner = current;
+
+        m_owner = current;

     }
     m_locked++;
 
    return wxMUTEX_NO_ERROR;
 }
 
     }
     m_locked++;
 
    return wxMUTEX_NO_ERROR;
 }
 

-wxMutexError wxMutex::Unlock()
+wxMutexError wxMutexInternal::Unlock()

 {
     if ( UMASystemIsInitialized() )
 {
     if ( UMASystemIsInitialized() )

-    {    
+    {

         OSErr err;
         err = ::ThreadBeginCritical();
         OSErr err;
         err = ::ThreadBeginCritical();

-        
+

         if (m_locked > 0)
             m_locked--;
 
         // this mutex is not owned by anybody anmore
         if (m_locked > 0)
             m_locked--;
 
         // this mutex is not owned by anybody anmore

-        m_internal->m_owner = kNoThreadID;
+        m_owner = kNoThreadID;

 
         // now pass on to the first waiting thread
         ThreadID firstWaiting = kNoThreadID;
         bool found = false;
 
         // now pass on to the first waiting thread
         ThreadID firstWaiting = kNoThreadID;
         bool found = false;

-        while (!m_internal->m_waiters.IsEmpty() && !found) 
+        while (!m_waiters.IsEmpty() && !found)

         {
         {

-            firstWaiting = m_internal->m_waiters[0];
+            firstWaiting = m_waiters[0];

             err = ::SetThreadState(firstWaiting, kReadyThreadState, kNoThreadID);
             // in case this was not successful (dead thread), we just loop on and reset the id
             err = ::SetThreadState(firstWaiting, kReadyThreadState, kNoThreadID);
             // in case this was not successful (dead thread), we just loop on and reset the id

-            found = (err != threadNotFoundErr);    
+            found = (err != threadNotFoundErr);

             if ( !found )
                 firstWaiting = kNoThreadID ;
             if ( !found )
                 firstWaiting = kNoThreadID ;

-            m_internal->m_waiters.RemoveAt(0) ;
+            m_waiters.RemoveAt(0) ;

         }
         // now we have a valid firstWaiting thread, which has been scheduled to run next, just end the
         // critical section and invoke the scheduler
         }
         // now we have a valid firstWaiting thread, which has been scheduled to run next, just end the
         // critical section and invoke the scheduler


@@ -200,14 +193,62 @@ wxMutexError wxMutex::Unlock()
     return wxMUTEX_NO_ERROR;
 }
 
     return wxMUTEX_NO_ERROR;
 }
 

+// --------------------------------------------------------------------------
+// wxSemaphore
+// --------------------------------------------------------------------------
+
+// TODO not yet implemented
+
+class wxSemaphoreInternal
+{
+public:
+    wxSemaphoreInternal(int initialcount, int maxcount);
+    ~wxSemaphoreInternal();
+
+    bool IsOk() const { return true ; }
+
+    wxSemaError Wait() { return WaitTimeout(INFINITE); }
+    wxSemaError TryWait() { return WaitTimeout(0); }
+    wxSemaError WaitTimeout(unsigned long milliseconds);
+
+    wxSemaError Post();
+
+private:
+};
+
+wxSemaphoreInternal::wxSemaphoreInternal(int initialcount, int maxcount)
+{
+    if ( maxcount == 0 )
+    {
+        // make it practically infinite
+        maxcount = INT_MAX;
+    }
+}
+
+wxSemaphoreInternal::~wxSemaphoreInternal()
+{
+}
+
+wxSemaError wxSemaphoreInternal::WaitTimeout(unsigned long milliseconds)
+{
+    return wxSEMA_MISC_ERROR;
+}
+
+wxSemaError wxSemaphoreInternal::Post()
+{
+    return wxSEMA_MISC_ERROR;
+}
+

 // ----------------------------------------------------------------------------
 // wxCondition implementation
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 // wxCondition implementation
 // ----------------------------------------------------------------------------
 

+// TODO this is not yet completed
+

 class wxConditionInternal
 {
 public:
 class wxConditionInternal
 {
 public:

-    wxConditionInternal()
+    wxConditionInternal(wxMutex& mutex) : m_mutex(mutex)

     {
         m_excessSignals = 0 ;
     }
     {
         m_excessSignals = 0 ;
     }


@@ -215,17 +256,24 @@ public:
     {
     }
 
     {
     }
 

-    bool Wait(unsigned long msectimeout)
+    bool IsOk() const { return m_mutex.IsOk() ; }
+    
+    wxCondError Wait()
+    {
+        return WaitTimeout(0xFFFFFFFF );
+    }
+    
+    wxCondError WaitTimeout(unsigned long msectimeout)

     {
         wxMacStCritical critical ;
         if ( m_excessSignals > 0 )
         {
             --m_excessSignals ;
     {
         wxMacStCritical critical ;
         if ( m_excessSignals > 0 )
         {
             --m_excessSignals ;

-            return TRUE ;
+            return wxCOND_NO_ERROR ;

         }
         else if ( msectimeout == 0 )
         {
         }
         else if ( msectimeout == 0 )
         {

-            return FALSE ;
+            return wxCOND_MISC_ERROR ;

         }
         else
         {
         }
         else
         {


@@ -240,59 +288,25 @@ public:
 
         return rc != WAIT_TIMEOUT;
         */
 
         return rc != WAIT_TIMEOUT;
         */

-        return TRUE ;
+        return wxCOND_NO_ERROR ;

     }
     }

-    void Signal()
+    wxCondError Signal()

     {
         wxMacStCritical critical ;
     {
         wxMacStCritical critical ;

+        return wxCOND_NO_ERROR;

     }
 
     }
 

+    wxCondError Broadcast()
+    {
+        wxMacStCritical critical ;
+        return wxCOND_NO_ERROR;
+    }    
+

     wxArrayLong m_waiters ;
     wxInt32     m_excessSignals ;
     wxArrayLong m_waiters ;
     wxInt32     m_excessSignals ;

+    wxMutex&    m_mutex;

 };
 
 };
 

-wxCondition::wxCondition()
-{
-    m_internal = new wxConditionInternal;
-}
-
-wxCondition::~wxCondition()
-{
-    delete m_internal;
-}
-
-void wxCondition::Wait()
-{
-    (void)m_internal->Wait(0xFFFFFFFFL);
-}
-
-bool wxCondition::Wait(unsigned long sec,
-                       unsigned long nsec)
-{
-    return m_internal->Wait(sec*1000 + nsec/1000000);
-}
-
-void wxCondition::Signal()
-{
-    // set the event to signaled: if a thread is already waiting on it, it will
-    // be woken up, otherwise the event will remain in the signaled state until
-    // someone waits on it. In any case, the system will return it to a non
-    // signalled state afterwards. If multiple threads are waiting, only one
-    // will be woken up.
-    m_internal->Signal() ;
-}
-
-void wxCondition::Broadcast()
-{
-    // this works because all these threads are already waiting and so each
-    // SetEvent() inside Signal() is really a PulseEvent() because the event
-    // state is immediately returned to non-signaled
-    for ( int i = 0; i < m_internal->m_waiters.Count(); i++ )
-    {
-        Signal();
-    }
-}
-

 // ----------------------------------------------------------------------------
 // wxCriticalSection implementation
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxCriticalSection implementation
 // ----------------------------------------------------------------------------


@@ -339,7 +353,7 @@ public:
     // thread priority
     void SetPriority(unsigned int priority);
     unsigned int GetPriority() const { return m_priority; }
     // thread priority
     void SetPriority(unsigned int priority);
     unsigned int GetPriority() const { return m_priority; }

-    
+

     void SetResult( void *res ) { m_result = res ; }
     void *GetResult() { return m_result ; }
 
     void SetResult( void *res ) { m_result = res ; }
     void *GetResult() { return m_result ; }
 


@@ -419,13 +433,15 @@ bool wxThreadInternal::Create(wxThread *thread, unsigned int stackSize)
         SetPriority(m_priority);
     }
 
         SetPriority(m_priority);
     }
 

+    m_state = STATE_NEW;
+

     return TRUE;
 }
 
 bool wxThreadInternal::Suspend()
 {
     OSErr err ;
     return TRUE;
 }
 
 bool wxThreadInternal::Suspend()
 {
     OSErr err ;

-    
+

     ::ThreadBeginCritical();
 
     if ( m_state != STATE_RUNNING )
     ::ThreadBeginCritical();
 
     if ( m_state != STATE_RUNNING )


@@ -450,18 +466,18 @@ bool wxThreadInternal::Resume()
 
     wxASSERT( err == noErr ) ;
     wxASSERT( current != m_tid ) ;
 
     wxASSERT( err == noErr ) ;
     wxASSERT( current != m_tid ) ;

-        
+

     ::ThreadBeginCritical();
     if ( m_state != STATE_PAUSED && m_state != STATE_NEW )
     {
         ::ThreadEndCritical() ;
         wxLogSysError(_("Can not resume thread %x"), m_tid);
         return FALSE;
     ::ThreadBeginCritical();
     if ( m_state != STATE_PAUSED && m_state != STATE_NEW )
     {
         ::ThreadEndCritical() ;
         wxLogSysError(_("Can not resume thread %x"), m_tid);
         return FALSE;

-        
+

     }
     err = ::SetThreadStateEndCritical(m_tid, kReadyThreadState, kNoThreadID);
     wxASSERT( err == noErr ) ;
     }
     err = ::SetThreadStateEndCritical(m_tid, kReadyThreadState, kNoThreadID);
     wxASSERT( err == noErr ) ;

-    
+

     m_state = STATE_RUNNING;
     ::ThreadEndCritical() ;
     ::YieldToAnyThread() ;
     m_state = STATE_RUNNING;
     ::ThreadEndCritical() ;
     ::YieldToAnyThread() ;


@@ -473,13 +489,13 @@ bool wxThreadInternal::Resume()
 wxThread *wxThread::This()
 {
     wxMacStCritical critical ;
 wxThread *wxThread::This()
 {
     wxMacStCritical critical ;

-    
+

     ThreadID current ;
     OSErr err ;
     ThreadID current ;
     OSErr err ;

-    
+

     err = MacGetCurrentThread( &current ) ;
     err = MacGetCurrentThread( &current ) ;

-    
-    for ( int i = 0 ; i < s_threads.Count() ; ++i )
+
+    for ( size_t i = 0 ; i < s_threads.Count() ; ++i )

     {
         if ( ( (wxThread*) s_threads[i] )->GetId() == current )
             return (wxThread*) s_threads[i] ;
     {
         if ( ( (wxThread*) s_threads[i] )->GetId() == current )
             return (wxThread*) s_threads[i] ;


@@ -493,7 +509,7 @@ bool wxThread::IsMain()
 {
     ThreadID current ;
     OSErr err ;
 {
     ThreadID current ;
     OSErr err ;

-    
+

     err = MacGetCurrentThread( &current ) ;
     return current == gs_idMainThread;
 }
     err = MacGetCurrentThread( &current ) ;
     return current == gs_idMainThread;
 }


@@ -509,11 +525,11 @@ void wxThread::Yield()
 
 void wxThread::Sleep(unsigned long milliseconds)
 {
 
 void wxThread::Sleep(unsigned long milliseconds)
 {

-        clock_t start = clock() ;
-        do 
-        {
-            YieldToAnyThread() ;
-        } while( clock() - start < milliseconds / CLOCKS_PER_SEC ) ;
+    clock_t start = clock();
+    do
+    {
+        YieldToAnyThread();
+    } while( clock() - start < milliseconds /  1000.0 * CLOCKS_PER_SEC ) ;

 }
 
 int wxThread::GetCPUCount()
 }
 
 int wxThread::GetCPUCount()


@@ -522,6 +538,13 @@ int wxThread::GetCPUCount()
     return 1;
 }
 
     return 1;
 }
 

+unsigned long wxThread::GetCurrentId()
+{
+    ThreadID current ;
+    MacGetCurrentThread( &current ) ;
+    return (unsigned long)current;
+}
+

 bool wxThread::SetConcurrency(size_t level)
 {
     wxASSERT_MSG( IsMain(), _T("should only be called from the main thread") );
 bool wxThread::SetConcurrency(size_t level)
 {
     wxASSERT_MSG( IsMain(), _T("should only be called from the main thread") );


@@ -537,7 +560,7 @@ bool wxThread::SetConcurrency(size_t level)
         // processor system it doesn't make much sense anyhow
         return level == 1;
     }
         // processor system it doesn't make much sense anyhow
         return level == 1;
     }

-    
+

     return TRUE ;
 }
 
     return TRUE ;
 }
 


@@ -555,7 +578,10 @@ wxThread::wxThread(wxThreadKind kind)
 wxThread::~wxThread()
 {
     s_threads.Remove( (void*) this ) ;
 wxThread::~wxThread()
 {
     s_threads.Remove( (void*) this ) ;

-    delete m_internal;
+    if (m_internal != NULL) {
+        delete m_internal;
+        m_internal = NULL;
+    }

 }
 
 // create/start thread
 }
 
 // create/start thread


@@ -690,13 +716,6 @@ wxThreadError wxThread::Delete(ExitCode *pRc)
         }
     }
 
         }
     }
 

- //   if ( !::GetExitCodeThread(hThread, (LPDWORD)&rc) )
-    {
-        wxLogLastError("GetExitCodeThread");
-
-        rc = (ExitCode)-1;
-    }
-

     if ( IsDetached() )
     {
         // if the thread exits normally, this is done in WinThreadStart, but in
     if ( IsDetached() )
     {
         // if the thread exits normally, this is done in WinThreadStart, but in


@@ -706,9 +725,6 @@ wxThreadError wxThread::Delete(ExitCode *pRc)
         delete this;
     }
 
         delete this;
     }
 

- //   wxASSERT_MSG( (DWORD)rc != STILL_ACTIVE,
- //                 wxT("thread must be already terminated.") );
-

     if ( pRc )
         *pRc = rc;
 
     if ( pRc )
         *pRc = rc;
 


@@ -748,7 +764,7 @@ void wxThread::Exit(ExitCode status)
 
     m_internal->SetResult( status ) ;
 
 
     m_internal->SetResult( status ) ;
 

-/*    
+/*

 #if defined(__VISUALC__) || (defined(__BORLANDC__) && (__BORLANDC__ >= 0x500))
     _endthreadex((unsigned)status);
 #else // !VC++
 #if defined(__VISUALC__) || (defined(__BORLANDC__) && (__BORLANDC__ >= 0x500))
     _endthreadex((unsigned)status);
 #else // !VC++


@@ -828,7 +844,7 @@ bool wxThreadModule::OnInit()
 #endif
     if ( !hasThreadManager )
     {
 #endif
     if ( !hasThreadManager )
     {

-        wxMessageBox( "Error" , "Thread Support is not available on this System" , wxOK ) ;
+        wxMessageBox( wxT("Error") , wxT("Thread Support is not available on this System") , wxOK ) ;

         return FALSE ;
     }
 
         return FALSE ;
     }
 


@@ -864,7 +880,7 @@ bool WXDLLEXPORT wxGuiOwnedByMainThread()
     return false ;
 }
 
     return false ;
 }
 

-// wake up the main thread 
+// wake up the main thread

 void WXDLLEXPORT wxWakeUpMainThread()
 {
     wxMacWakeUp() ;
 void WXDLLEXPORT wxWakeUpMainThread()
 {
     wxMacWakeUp() ;


@@ -875,6 +891,6 @@ bool WXDLLEXPORT wxIsWaitingForThread()
     return false ;
 }
 
     return false ;
 }
 

-#endif // wxUSE_THREADS
+#include "wx/thrimpl.cpp"

 
 

-// vi:sts=4:sw=4:et
+#endif // wxUSE_THREADS