fix evaluation order bug (patch 1158099)

[wxWidgets.git] / contrib / src / mmedia / sndwin.cpp

diff --git a/contrib/src/mmedia/sndwin.cpp b/contrib/src/mmedia/sndwin.cpp
index 7e0795e89500bc8059c445b614e045c026390acc..86f9339a34d68a9cacb97c28873d0cf7cf310350 100644 (file)
--- a/contrib/src/mmedia/sndwin.cpp
+++ b/contrib/src/mmedia/sndwin.cpp
@@ -4,6 +4,7 @@
 // Date: 08/11/1999
 // Author: Guilhem Lavaux <lavaux@easynet.fr> (C) 1999, 2000
 // CVSID: $Id$
 // Date: 08/11/1999
 // Author: Guilhem Lavaux <lavaux@easynet.fr> (C) 1999, 2000
 // CVSID: $Id$

+// wxWindows licence

 // --------------------------------------------------------------------------
 #ifdef __GNUG__
 #pragma implementation "sndwin.cpp"
 // --------------------------------------------------------------------------
 #ifdef __GNUG__
 #pragma implementation "sndwin.cpp"


@@ -50,10 +51,10 @@ wxList *wxSoundHandleList = NULL;
 
 static inline wxSoundStreamWin *wxFindSoundFromHandle(WXHWND hWnd)
 {
 
 static inline wxSoundStreamWin *wxFindSoundFromHandle(WXHWND hWnd)
 {

-  wxNode *node = wxSoundHandleList->Find((long)hWnd);
+  wxObjectList::compatibility_iterator node = wxSoundHandleList->Find((long)hWnd);

   if (!node)
     return NULL;
   if (!node)
     return NULL;

-  return (wxSoundStreamWin *)node->Data();
+  return (wxSoundStreamWin *)node->GetData();

 }
 
 struct _wxSoundInternal {
 }
 
 struct _wxSoundInternal {


@@ -80,7 +81,7 @@ wxSoundStreamWin::wxSoundStreamWin()
 {
   wxSoundFormatPcm pcm;
 
 {
   wxSoundFormatPcm pcm;
 

-  m_production_started = FALSE;
+  m_production_started = false;

   m_internal = new wxSoundInternal;
   if (!m_internal) {
     m_snderror = wxSOUND_MEMERROR;
   m_internal = new wxSoundInternal;
   if (!m_internal) {
     m_snderror = wxSOUND_MEMERROR;


@@ -93,10 +94,10 @@ wxSoundStreamWin::wxSoundStreamWin()
   CreateSndWindow();
   SetSoundFormat(pcm);
 
   CreateSndWindow();
   SetSoundFormat(pcm);
 

-  m_internal->m_input_enabled = FALSE;
-  m_internal->m_output_enabled = FALSE;
+  m_internal->m_input_enabled = false;
+  m_internal->m_output_enabled = false;

 
 

-  m_waiting_for = FALSE;
+  m_waiting_for = false;

 
   if (!OpenDevice(wxSOUND_OUTPUT)) {
     m_snderror = wxSOUND_NOERROR; //next call to OpenDevice won't do this
 
   if (!OpenDevice(wxSOUND_OUTPUT)) {
     m_snderror = wxSOUND_NOERROR; //next call to OpenDevice won't do this


@@ -157,7 +158,7 @@ void wxSoundStreamWin::CreateSndWindow()
   // NB: class name must be kept in sync with wxCanvasClassName in 
   // src/msw/app.cpp!
   m_internal->m_sndWin = ::CreateWindow(wxT("wxWindowClass"), NULL, 0,
   // NB: class name must be kept in sync with wxCanvasClassName in 
   // src/msw/app.cpp!
   m_internal->m_sndWin = ::CreateWindow(wxT("wxWindowClass"), NULL, 0,

-                                       0, 0, 0, 0, NULL, (HMENU) NULL,
+                    0, 0, 0, 0, NULL, (HMENU) NULL,

                                         wxGetInstance(), NULL);
 
   GetLastError();
                                         wxGetInstance(), NULL);
 
   GetLastError();


@@ -199,7 +200,7 @@ bool wxSoundStreamWin::OpenDevice(int mode)
 
   if (!m_sndformat) {
     m_snderror = wxSOUND_INVFRMT;
 
   if (!m_sndformat) {
     m_snderror = wxSOUND_INVFRMT;

-    return FALSE;
+    return false;

   }
     
   pcm = (wxSoundFormatPcm *)m_sndformat;
   }
     
   pcm = (wxSoundFormatPcm *)m_sndformat;


@@ -225,13 +226,13 @@ bool wxSoundStreamWin::OpenDevice(int mode)
 
     if (result != MMSYSERR_NOERROR) {
       m_snderror = wxSOUND_INVDEV;
 
     if (result != MMSYSERR_NOERROR) {
       m_snderror = wxSOUND_INVDEV;

-      return FALSE;
+      return false;

     }
 
     m_output_frag_out  = WXSOUND_MAX_QUEUE-1;
     m_current_frag_out = 0;
 
     }
 
     m_output_frag_out  = WXSOUND_MAX_QUEUE-1;
     m_current_frag_out = 0;
 

-    m_internal->m_output_enabled = TRUE;
+    m_internal->m_output_enabled = true;

   }
   // -----------------------------------
   // Open the driver for Input operation
   }
   // -----------------------------------
   // Open the driver for Input operation


@@ -246,29 +247,29 @@ bool wxSoundStreamWin::OpenDevice(int mode)
 
     if (result != MMSYSERR_NOERROR) {
       m_snderror = wxSOUND_INVDEV;
 
     if (result != MMSYSERR_NOERROR) {
       m_snderror = wxSOUND_INVDEV;

-      return FALSE;
+      return false;

     }
 
     m_current_frag_in = WXSOUND_MAX_QUEUE-1;
     m_input_frag_in   = 0;
 
     }
 
     m_current_frag_in = WXSOUND_MAX_QUEUE-1;
     m_input_frag_in   = 0;
 

-    m_internal->m_input_enabled = TRUE;
+    m_internal->m_input_enabled = true;

   }
 
   if (mode & wxSOUND_OUTPUT) {
     if (!AllocHeaders(wxSOUND_OUTPUT)) {
       CloseDevice();
   }
 
   if (mode & wxSOUND_OUTPUT) {
     if (!AllocHeaders(wxSOUND_OUTPUT)) {
       CloseDevice();

-      return FALSE;
+      return false;

     }
   }
   if (mode & wxSOUND_INPUT) {
     if (!AllocHeaders(wxSOUND_INPUT)) {
       CloseDevice();
     }
   }
   if (mode & wxSOUND_INPUT) {
     if (!AllocHeaders(wxSOUND_INPUT)) {
       CloseDevice();

-      return FALSE;
+      return false;

     }
   }
 
     }
   }
 

-  return TRUE;
+  return true;

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


@@ -279,13 +280,13 @@ void wxSoundStreamWin::CloseDevice()
 {
   if (m_internal->m_output_enabled) {
     FreeHeaders(wxSOUND_OUTPUT);
 {
   if (m_internal->m_output_enabled) {
     FreeHeaders(wxSOUND_OUTPUT);

-    m_internal->m_output_enabled = FALSE;
+    m_internal->m_output_enabled = false;

     waveOutClose(m_internal->m_devout);
   }
 
   if (m_internal->m_input_enabled) {
     FreeHeaders(wxSOUND_INPUT);
     waveOutClose(m_internal->m_devout);
   }
 
   if (m_internal->m_input_enabled) {
     FreeHeaders(wxSOUND_INPUT);

-    m_internal->m_input_enabled  = FALSE;
+    m_internal->m_input_enabled  = false;

     waveInClose(m_internal->m_devin);
   }
 }
     waveInClose(m_internal->m_devin);
   }
 }


@@ -381,8 +382,8 @@ wxSoundInfoHeader *wxSoundStreamWin::AllocHeader(int mode)
 // AllocHeaders() allocates WXSOUND_MAX_QUEUE (= 128) blocks for an operation
 // queue. It uses AllocHeader() for each element.
 //
 // AllocHeaders() allocates WXSOUND_MAX_QUEUE (= 128) blocks for an operation
 // queue. It uses AllocHeader() for each element.
 //

-// Once it has allocated all blocks, it returns TRUE and if an error occured
-// it returns FALSE.
+// Once it has allocated all blocks, it returns true and if an error occured
+// it returns false.

 // -------------------------------------------------------------------------
 bool wxSoundStreamWin::AllocHeaders(int mode)
 {
 // -------------------------------------------------------------------------
 bool wxSoundStreamWin::AllocHeaders(int mode)
 {


@@ -400,10 +401,10 @@ bool wxSoundStreamWin::AllocHeaders(int mode)
     headers[i] = AllocHeader(mode);
     if (!headers[i]) {
       FreeHeaders(mode);
     headers[i] = AllocHeader(mode);
     if (!headers[i]) {
       FreeHeaders(mode);

-      return FALSE;
+      return false;

     }
   }
     }
   }

-  return TRUE;
+  return true;

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


@@ -482,11 +483,11 @@ void wxSoundStreamWin::WaitFor(wxSoundInfoHeader *info)
         // PROBLEM //
         return;
     }
         // PROBLEM //
         return;
     }

-    m_waiting_for = TRUE;
+    m_waiting_for = true;

     // Else, we wait for its termination
     while (info->m_playing || info->m_recording)
       wxYield();
     // Else, we wait for its termination
     while (info->m_playing || info->m_recording)
       wxYield();

-    m_waiting_for = FALSE;
+    m_waiting_for = false;

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


@@ -508,18 +509,18 @@ bool wxSoundStreamWin::AddToQueue(wxSoundInfoHeader *info)
         result = waveInAddBuffer(m_internal->m_devin,
                                  info->m_header, sizeof(WAVEHDR));
         if (result == MMSYSERR_NOERROR)
         result = waveInAddBuffer(m_internal->m_devin,
                                  info->m_header, sizeof(WAVEHDR));
         if (result == MMSYSERR_NOERROR)

-            info->m_recording = TRUE;
+            info->m_recording = true;

         else
         else

-            return FALSE;
+            return false;

     } else if (info->m_mode == wxSOUND_OUTPUT) {
         result = waveOutWrite(m_internal->m_devout,
                               info->m_header, sizeof(WAVEHDR));
         if (result == MMSYSERR_NOERROR)
     } else if (info->m_mode == wxSOUND_OUTPUT) {
         result = waveOutWrite(m_internal->m_devout,
                               info->m_header, sizeof(WAVEHDR));
         if (result == MMSYSERR_NOERROR)

-      info->m_playing = TRUE;
+      info->m_playing = true;

         else
         else

-            return FALSE;
+            return false;

     }
     }

-    return TRUE;
+    return true;

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


@@ -530,8 +531,8 @@ bool wxSoundStreamWin::AddToQueue(wxSoundInfoHeader *info)
 // -------------------------------------------------------------------------
 void wxSoundStreamWin::ClearHeader(wxSoundInfoHeader *info)
 {
 // -------------------------------------------------------------------------
 void wxSoundStreamWin::ClearHeader(wxSoundInfoHeader *info)
 {

-  info->m_playing   = FALSE;
-  info->m_recording = FALSE;
+  info->m_playing   = false;
+  info->m_recording = false;

   info->m_position  = 0;
   info->m_size      = GetBestSize();
 }
   info->m_position  = 0;
   info->m_size      = GetBestSize();
 }


@@ -552,7 +553,7 @@ wxSoundInfoHeader *wxSoundStreamWin::NextFragmentOutput()
       WaitFor(m_headers_play[m_current_frag_out]);
   }
   if (m_current_frag_out == m_output_frag_out)
       WaitFor(m_headers_play[m_current_frag_out]);
   }
   if (m_current_frag_out == m_output_frag_out)

-    m_queue_filled = TRUE;
+    m_queue_filled = true;

   return m_headers_play[m_current_frag_out];
 }
 
   return m_headers_play[m_current_frag_out];
 }
 


@@ -612,7 +613,7 @@ wxSoundInfoHeader *wxSoundStreamWin::NextFragmentInput()
 
     // We reached the writer position: the queue is full.
     if (m_current_frag_in == m_input_frag_in)
 
     // We reached the writer position: the queue is full.
     if (m_current_frag_in == m_input_frag_in)

-        m_queue_filled = TRUE;
+        m_queue_filled = true;

     
     return header;
 }
     
     return header;
 }


@@ -672,7 +673,7 @@ void wxSoundStreamWin::NotifyDoneBuffer(wxUint32 WXUNUSED(dev_handle), int flag)
         info = m_headers_play[m_output_frag_out];
         // Clear header to tell the system the buffer is free now
         ClearHeader(info);
         info = m_headers_play[m_output_frag_out];
         // Clear header to tell the system the buffer is free now
         ClearHeader(info);

-        m_queue_filled = FALSE;
+        m_queue_filled = false;

         if (!m_waiting_for)
             // Try to requeue a new buffer.
             OnSoundEvent(wxSOUND_OUTPUT);
         if (!m_waiting_for)
             // Try to requeue a new buffer.
             OnSoundEvent(wxSOUND_OUTPUT);


@@ -681,12 +682,12 @@ void wxSoundStreamWin::NotifyDoneBuffer(wxUint32 WXUNUSED(dev_handle), int flag)
             return;
 
         // Recording completed
             return;
 
         // Recording completed

-        m_headers_rec[m_input_frag_in]->m_recording = FALSE;
+        m_headers_rec[m_input_frag_in]->m_recording = false;

         // Queue pointer: writer
         m_input_frag_in = (m_input_frag_in + 1) % WXSOUND_MAX_QUEUE;
         if (!m_waiting_for)
             OnSoundEvent(wxSOUND_INPUT);
         // Queue pointer: writer
         m_input_frag_in = (m_input_frag_in + 1) % WXSOUND_MAX_QUEUE;
         if (!m_waiting_for)
             OnSoundEvent(wxSOUND_INPUT);

-        m_queue_filled = FALSE;
+        m_queue_filled = false;

     }
 }
 
     }
 }
 


@@ -705,17 +706,17 @@ bool wxSoundStreamWin::SetSoundFormat(const wxSoundFormatBase& base)
 bool wxSoundStreamWin::StartProduction(int evt)
 {
   if (!m_internal)
 bool wxSoundStreamWin::StartProduction(int evt)
 {
   if (!m_internal)

-    return FALSE;
+    return false;

 
   if ((m_internal->m_output_enabled && (evt & wxSOUND_OUTPUT)) ||
       (m_internal->m_input_enabled && (evt & wxSOUND_INPUT)))
     CloseDevice();
 
   if (!OpenDevice(evt))
 
   if ((m_internal->m_output_enabled && (evt & wxSOUND_OUTPUT)) ||
       (m_internal->m_input_enabled && (evt & wxSOUND_INPUT)))
     CloseDevice();
 
   if (!OpenDevice(evt))

-    return FALSE;
+    return false;

 
 

-  m_production_started = TRUE;
-  m_queue_filled = FALSE;
+  m_production_started = true;
+  m_queue_filled = false;

   // Send a dummy event to start.
   if (evt & wxSOUND_OUTPUT)
     OnSoundEvent(wxSOUND_OUTPUT);
   // Send a dummy event to start.
   if (evt & wxSOUND_OUTPUT)
     OnSoundEvent(wxSOUND_OUTPUT);


@@ -728,7 +729,7 @@ bool wxSoundStreamWin::StartProduction(int evt)
     waveInStart(m_internal->m_devin);
   }
 
     waveInStart(m_internal->m_devin);
   }
 

-  return TRUE;
+  return true;

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


@@ -738,13 +739,13 @@ bool wxSoundStreamWin::StopProduction()
 {
     if (!m_production_started) {
         m_snderror = wxSOUND_NOTSTARTED;
 {
     if (!m_production_started) {
         m_snderror = wxSOUND_NOTSTARTED;

-        return FALSE;
+        return false;

     }
     
     m_snderror = wxSOUND_NOERROR;
     }
     
     m_snderror = wxSOUND_NOERROR;

-    m_production_started = FALSE;
+    m_production_started = false;

     CloseDevice();
     CloseDevice();

-    return TRUE;
+    return true;

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


@@ -771,7 +772,7 @@ IMPLEMENT_DYNAMIC_CLASS(wxSoundWinModule, wxModule)
 
 bool wxSoundWinModule::OnInit() {
   wxSoundHandleList = new wxList(wxKEY_INTEGER);
 
 bool wxSoundWinModule::OnInit() {
   wxSoundHandleList = new wxList(wxKEY_INTEGER);

-  return TRUE;
+  return true;

 }
 
 void wxSoundWinModule::OnExit() {
 }
 
 void wxSoundWinModule::OnExit() {