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 78ad0292b086705052c19c113cf4048151e41d1f..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$
+// wxWindows licence
 // --------------------------------------------------------------------------
 #ifdef __GNUG__
 #pragma implementation "sndwin.cpp"
@@ -50,10 +51,10 @@ wxList *wxSoundHandleList = NULL;
 
 static inline wxSoundStreamWin *wxFindSoundFromHandle(WXHWND hWnd)
 {
-  wxNode *node = wxSoundHandleList->Find((long)hWnd);
+  wxObjectList::compatibility_iterator node = wxSoundHandleList->Find((long)hWnd);
   if (!node)
     return NULL;
-  return (wxSoundStreamWin *)node->Data();
+  return (wxSoundStreamWin *)node->GetData();
 }
 
 struct _wxSoundInternal {
@@ -80,7 +81,7 @@ wxSoundStreamWin::wxSoundStreamWin()
 {
   wxSoundFormatPcm pcm;
 
-  m_production_started = FALSE;
+  m_production_started = false;
   m_internal = new wxSoundInternal;
   if (!m_internal) {
     m_snderror = wxSOUND_MEMERROR;
@@ -93,10 +94,10 @@ wxSoundStreamWin::wxSoundStreamWin()
   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
@@ -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,
-                                       0, 0, 0, 0, NULL, (HMENU) NULL,
+                    0, 0, 0, 0, NULL, (HMENU) NULL,
                                         wxGetInstance(), NULL);
 
   GetLastError();
@@ -199,7 +200,7 @@ bool wxSoundStreamWin::OpenDevice(int mode)
 
   if (!m_sndformat) {
     m_snderror = wxSOUND_INVFRMT;
-    return FALSE;
+    return false;
   }
     
   pcm = (wxSoundFormatPcm *)m_sndformat;
@@ -225,13 +226,13 @@ bool wxSoundStreamWin::OpenDevice(int mode)
 
     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_internal->m_output_enabled = TRUE;
+    m_internal->m_output_enabled = true;
   }
   // -----------------------------------
   // Open the driver for Input operation
@@ -246,29 +247,29 @@ bool wxSoundStreamWin::OpenDevice(int mode)
 
     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_internal->m_input_enabled = TRUE;
+    m_internal->m_input_enabled = true;
   }
 
   if (mode & wxSOUND_OUTPUT) {
     if (!AllocHeaders(wxSOUND_OUTPUT)) {
       CloseDevice();
-      return FALSE;
+      return false;
     }
   }
   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);
-    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);
-    m_internal->m_input_enabled  = FALSE;
+    m_internal->m_input_enabled  = false;
     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.
 //
-// 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)
 {
@@ -400,10 +401,10 @@ bool wxSoundStreamWin::AllocHeaders(int 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;
     }
-    m_waiting_for = TRUE;
+    m_waiting_for = true;
     // 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)
-            info->m_recording = TRUE;
+            info->m_recording = true;
         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)
-      info->m_playing = TRUE;
+      info->m_playing = true;
         else
-            return FALSE;
+            return false;
     }
-    return TRUE;
+    return true;
 }
 
 // -------------------------------------------------------------------------
@@ -530,8 +531,8 @@ bool wxSoundStreamWin::AddToQueue(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();
 }
@@ -552,7 +553,7 @@ wxSoundInfoHeader *wxSoundStreamWin::NextFragmentOutput()
       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];
 }
 
@@ -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)
-        m_queue_filled = TRUE;
+        m_queue_filled = true;
     
     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);
-        m_queue_filled = FALSE;
+        m_queue_filled = false;
         if (!m_waiting_for)
             // Try to requeue a new buffer.
             OnSoundEvent(wxSOUND_OUTPUT);
@@ -681,19 +682,19 @@ void wxSoundStreamWin::NotifyDoneBuffer(wxUint32 WXUNUSED(dev_handle), int flag)
             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);
-        m_queue_filled = FALSE;
+        m_queue_filled = false;
     }
 }
 
 // -------------------------------------------------------------------------
 // SetSoundFormat()
 // -------------------------------------------------------------------------
-bool wxSoundStreamWin::SetSoundFormat(wxSoundFormatBase& base)
+bool wxSoundStreamWin::SetSoundFormat(const wxSoundFormatBase& base)
 {
   // TODO: detect best format
   return wxSoundStream::SetSoundFormat(base);
@@ -705,17 +706,17 @@ bool wxSoundStreamWin::SetSoundFormat(wxSoundFormatBase& base)
 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))
-    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);
@@ -728,7 +729,7 @@ bool wxSoundStreamWin::StartProduction(int evt)
     waveInStart(m_internal->m_devin);
   }
 
-  return TRUE;
+  return true;
 }
 
 // -------------------------------------------------------------------------
@@ -738,13 +739,13 @@ bool wxSoundStreamWin::StopProduction()
 {
     if (!m_production_started) {
         m_snderror = wxSOUND_NOTSTARTED;
-        return FALSE;
+        return false;
     }
     
     m_snderror = wxSOUND_NOERROR;
-    m_production_started = FALSE;
+    m_production_started = false;
     CloseDevice();
-    return TRUE;
+    return true;
 }
 
 // -------------------------------------------------------------------------
@@ -771,7 +772,7 @@ IMPLEMENT_DYNAMIC_CLASS(wxSoundWinModule, wxModule)
 
 bool wxSoundWinModule::OnInit() {
   wxSoundHandleList = new wxList(wxKEY_INTEGER);
-  return TRUE;
+  return true;
 }
 
 void wxSoundWinModule::OnExit() {