cleanup - reformatting

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@37445 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

diff --git a/src/mac/carbon/mediactrl.cpp b/src/mac/carbon/mediactrl.cpp
index a9267f74b6c122a6dbc715ee8860c182ce743de4..aeb1539217ab19a249dfa99f3274d293f534c51f 100644 (file)
--- a/src/mac/carbon/mediactrl.cpp
+++ b/src/mac/carbon/mediactrl.cpp
@@ -14,14 +14,6 @@
 // on systems > 10.2 - see main.c of QTCarbonShell sample for details
 //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
 // on systems > 10.2 - see main.c of QTCarbonShell sample for details
 //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 

-//===========================================================================
-//  DECLARATIONS
-//===========================================================================
-
-//---------------------------------------------------------------------------
-// Pre-compiled header stuff
-//---------------------------------------------------------------------------
-

 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 


@@ -29,14 +21,20 @@
 #pragma hdrstop
 #endif
 
 #pragma hdrstop
 #endif
 

-//---------------------------------------------------------------------------
-// Includes
-//---------------------------------------------------------------------------

 #include "wx/mediactrl.h"
 
 #include "wx/mediactrl.h"
 

-//---------------------------------------------------------------------------
-// Compilation guard
-//---------------------------------------------------------------------------
+// uma is for wxMacFSSpec
+#include "wx/mac/uma.h"
+#include "wx/timer.h"
+
+#ifndef __DARWIN__
+#include <Movies.h>
+#include <Gestalt.h>
+#include <QuickTimeComponents.h>    // standard QT stuff
+#else
+#include <QuickTime/QuickTimeComponents.h>
+#endif
+

 #if wxUSE_MEDIACTRL
 
 //---------------------------------------------------------------------------
 #if wxUSE_MEDIACTRL
 
 //---------------------------------------------------------------------------


@@ -63,24 +61,9 @@
 //===========================================================================
 
 //---------------------------------------------------------------------------
 //===========================================================================
 
 //---------------------------------------------------------------------------

-//

 //  wxQTMediaBackend
 //  wxQTMediaBackend

-//

 //---------------------------------------------------------------------------
 
 //---------------------------------------------------------------------------
 

-//---------------------------------------------------------------------------
-//  QT Includes
-//---------------------------------------------------------------------------
-//uma is for wxMacFSSpec
-#include "wx/mac/uma.h"
-#include "wx/timer.h"
-#ifndef __DARWIN__
-#include <Movies.h>
-#include <Gestalt.h>
-#include <QuickTimeComponents.h>    //Standard QT stuff
-#else
-#include <QuickTime/QuickTimeComponents.h>
-#endif

 
 class WXDLLIMPEXP_MEDIA wxQTMediaBackend : public wxMediaBackendCommonBase
 {
 
 class WXDLLIMPEXP_MEDIA wxQTMediaBackend : public wxMediaBackendCommonBase
 {


@@ -122,11 +105,9 @@ public:
     void FinishLoad();
 
     virtual bool ShowPlayerControls(wxMediaCtrlPlayerControls flags);
     void FinishLoad();
 
     virtual bool ShowPlayerControls(wxMediaCtrlPlayerControls flags);

-        

 
 

-    //

     //  ------  Implementation from now on  --------
     //  ------  Implementation from now on  --------

-    //
+

     void DoLoadBestSize();
     void DoSetControllerVisible(wxMediaCtrlPlayerControls flags);
 
     void DoLoadBestSize();
     void DoSetControllerVisible(wxMediaCtrlPlayerControls flags);
 


@@ -135,7 +116,7 @@ public:
         short action, void *params, long refCon);
 
 #if wxUSE_CREATEMOVIECONTROL
         short action, void *params, long refCon);
 
 #if wxUSE_CREATEMOVIECONTROL

-    void DoCreateMovieControl();    
+    void DoCreateMovieControl();

 #else
     Boolean IsQuickTime4Installed();
     void DoNewMovieController();
 #else
     Boolean IsQuickTime4Installed();
     void DoNewMovieController();


@@ -143,20 +124,24 @@ public:
 #endif
 
     wxSize m_bestSize;          // Original movie size
 #endif
 
     wxSize m_bestSize;          // Original movie size

+

 #ifdef __WXMAC_OSX__
     struct MovieType** m_movie; // QT Movie handle/instance
 #else
     Movie m_movie;              // Movie instance
 #endif
 #ifdef __WXMAC_OSX__
     struct MovieType** m_movie; // QT Movie handle/instance
 #else
     Movie m_movie;              // Movie instance
 #endif

+

     bool m_bPlaying;            // Whether media is playing or not
     class wxTimer* m_timer;     // Timer for streaming the movie
     MovieController m_mc;       // MovieController instance
     wxMediaCtrlPlayerControls m_interfaceflags; // Saved interface flags
     bool m_bPlaying;            // Whether media is playing or not
     class wxTimer* m_timer;     // Timer for streaming the movie
     MovieController m_mc;       // MovieController instance
     wxMediaCtrlPlayerControls m_interfaceflags; // Saved interface flags

+

 #if !wxUSE_CREATEMOVIECONTROL
     EventHandlerRef m_pEventHandlerRef; // Event handler to cleanup
 
     friend class wxQTMediaEvtHandler;
 #if !wxUSE_CREATEMOVIECONTROL
     EventHandlerRef m_pEventHandlerRef; // Event handler to cleanup
 
     friend class wxQTMediaEvtHandler;

-#endif    
+#endif
+

     DECLARE_DYNAMIC_CLASS(wxQTMediaBackend)
 };
 
     DECLARE_DYNAMIC_CLASS(wxQTMediaBackend)
 };
 


@@ -169,7 +154,8 @@ public:
     {
         m_qtb = qtb;
 
     {
         m_qtb = qtb;
 

-        qtb->m_ctrl->Connect(qtb->m_ctrl->GetId(), wxEVT_ERASE_BACKGROUND,
+        qtb->m_ctrl->Connect(
+            qtb->m_ctrl->GetId(), wxEVT_ERASE_BACKGROUND,

             wxEraseEventHandler(wxQTMediaEvtHandler::OnEraseBackground),
             NULL, this);
     }
             wxEraseEventHandler(wxQTMediaEvtHandler::OnEraseBackground),
             NULL, this);
     }


@@ -184,8 +170,8 @@ private:
 
 // Window event handler
 static pascal OSStatus wxQTMediaWindowEventHandler(
 
 // Window event handler
 static pascal OSStatus wxQTMediaWindowEventHandler(

-                                    EventHandlerCallRef inHandlerCallRef, 
-                                    EventRef inEvent, void *inUserData);
+    EventHandlerCallRef inHandlerCallRef,
+    EventRef inEvent, void *inUserData);

 DEFINE_ONE_SHOT_HANDLER_GETTER( wxQTMediaWindowEventHandler );
 
 #endif
 DEFINE_ONE_SHOT_HANDLER_GETTER( wxQTMediaWindowEventHandler );
 
 #endif


@@ -196,9 +182,7 @@ DEFINE_ONE_SHOT_HANDLER_GETTER( wxQTMediaWindowEventHandler );
 
 
 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 
 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

-//

 // wxQTMediaBackend
 // wxQTMediaBackend

-//

 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 IMPLEMENT_DYNAMIC_CLASS(wxQTMediaBackend, wxMediaBackend)
 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 IMPLEMENT_DYNAMIC_CLASS(wxQTMediaBackend, wxMediaBackend)


@@ -224,24 +208,25 @@ public:
 
     void Notify()
     {
 
     void Notify()
     {

-        //Note that the CreateMovieControl variety performs
-        //its own custom idleing
+        // Note that the CreateMovieControl variety performs
+        // its own custom idleing

 #if !wxUSE_CREATEMOVIECONTROL
         ::MCIdle(m_parent->m_mc);
 #endif
 #if !wxUSE_CREATEMOVIECONTROL
         ::MCIdle(m_parent->m_mc);
 #endif

-        //kMovieLoadStatePlayable is not enough on MAC
-        //- it plays, but IsMovieDone might return true (!)
-        //sure we need to wait until kMovieLoadStatePlaythroughOK
-        if(::GetMovieLoadState(m_movie) >= 20000)
-    {
+
+        // kMovieLoadStatePlayable is not enough on MAC:
+        // it plays, but IsMovieDone might return true (!)
+        // sure we need to wait until kMovieLoadStatePlaythroughOK
+        if (::GetMovieLoadState(m_movie) >= 20000)
+        {

             m_parent->FinishLoad();
             delete this;
             m_parent->FinishLoad();
             delete this;

-    }
+        }

     }
 
 protected:
     }
 
 protected:

-    Movie m_movie;                  //Our movie instance
-    wxQTMediaBackend* m_parent;     //Backend pointer
+    Movie m_movie;                  // Our movie instance
+    wxQTMediaBackend *m_parent;     // Backend pointer

 };
 
 // --------------------------------------------------------------------------
 };
 
 // --------------------------------------------------------------------------


@@ -259,7 +244,7 @@ public:
         m_movie(movie), m_parent(parent) {}
 
     void Notify()
         m_movie(movie), m_parent(parent) {}
 
     void Notify()

-        {
+    {

         //Note that CreateMovieControl performs its own idleing
 #if !wxUSE_CREATEMOVIECONTROL
         //
         //Note that CreateMovieControl performs its own idleing
 #if !wxUSE_CREATEMOVIECONTROL
         //


@@ -277,12 +262,10 @@ public:
         ::MCIdle(m_parent->m_mc);
 #endif
 
         ::MCIdle(m_parent->m_mc);
 #endif
 

-        //

         //  Handle the stop event - if the movie has reached
         //  the end, notify our handler
         //  Handle the stop event - if the movie has reached
         //  the end, notify our handler

-        //
-        if(::IsMovieDone(m_movie))
-                {
+        if (::IsMovieDone(m_movie))
+        {

             if ( m_parent->SendStopEvent() )
             {
                     m_parent->Stop();
             if ( m_parent->SendStopEvent() )
             {
                     m_parent->Stop();


@@ -294,8 +277,8 @@ public:
     }
 
 protected:
     }
 
 protected:

-    Movie m_movie;                  //Our movie instance
-    wxQTMediaBackend* m_parent;     //Backend pointer
+    Movie m_movie;                  // Our movie instance
+    wxQTMediaBackend* m_parent;     // Backend pointer

 };
 
 
 };
 
 


@@ -304,7 +287,7 @@ protected:
 //
 // Sets m_timer to NULL signifying we havn't loaded anything yet
 //---------------------------------------------------------------------------
 //
 // Sets m_timer to NULL signifying we havn't loaded anything yet
 //---------------------------------------------------------------------------

-wxQTMediaBackend::wxQTMediaBackend() 
+wxQTMediaBackend::wxQTMediaBackend()

     : m_movie(NULL), m_bPlaying(false), m_timer(NULL)
       , m_mc(NULL), m_interfaceflags(wxMEDIACTRLPLAYERCONTROLS_NONE)
 {
     : m_movie(NULL), m_bPlaying(false), m_timer(NULL)
       , m_mc(NULL), m_interfaceflags(wxMEDIACTRLPLAYERCONTROLS_NONE)
 {


@@ -321,12 +304,12 @@ wxQTMediaBackend::wxQTMediaBackend()
 //---------------------------------------------------------------------------
 wxQTMediaBackend::~wxQTMediaBackend()
 {
 //---------------------------------------------------------------------------
 wxQTMediaBackend::~wxQTMediaBackend()
 {

-    if(m_movie)
+    if (m_movie)

         Cleanup();
 
 #if !wxUSE_CREATEMOVIECONTROL
     // Cleanup for moviecontroller
         Cleanup();
 
 #if !wxUSE_CREATEMOVIECONTROL
     // Cleanup for moviecontroller

-    if(m_mc)
+    if (m_mc)

     {
         // destroy wxQTMediaEvtHandler we pushed on it
         m_ctrl->PopEventHandler(true);
     {
         // destroy wxQTMediaEvtHandler we pushed on it
         m_ctrl->PopEventHandler(true);


@@ -335,7 +318,7 @@ wxQTMediaBackend::~wxQTMediaBackend()
     }
 #endif
 
     }
 #endif
 

-    //Note that ExitMovies() is not necessary...
+    // Note that ExitMovies() is not necessary...

     ExitMovies();
 }
 
     ExitMovies();
 }
 


@@ -345,15 +328,17 @@ wxQTMediaBackend::~wxQTMediaBackend()
 // 1) Intializes QuickTime
 // 2) Creates the control window
 //---------------------------------------------------------------------------
 // 1) Intializes QuickTime
 // 2) Creates the control window
 //---------------------------------------------------------------------------

-bool wxQTMediaBackend::CreateControl(wxControl* ctrl, wxWindow* parent,
-                                     wxWindowID id,
-                                     const wxPoint& pos,
-                                     const wxSize& size,
-                                     long style,
-                                     const wxValidator& validator,
-                                     const wxString& name)
+bool wxQTMediaBackend::CreateControl(
+    wxControl* ctrl,
+    wxWindow* parent,
+    wxWindowID id,
+    const wxPoint& pos,
+    const wxSize& size,
+    long style,
+    const wxValidator& validator,
+    const wxString& name)

 {
 {

-    //Don't bother in Native control mode
+    // Don't bother in Native control mode

 #if !wxUSE_CREATEMOVIECONTROL
     if (!IsQuickTime4Installed())
         return false;
 #if !wxUSE_CREATEMOVIECONTROL
     if (!IsQuickTime4Installed())
         return false;


@@ -361,19 +346,18 @@ bool wxQTMediaBackend::CreateControl(wxControl* ctrl, wxWindow* parent,
 
     EnterMovies();
 
 
     EnterMovies();
 

-    //

     // Create window
     // By default wxWindow(s) is created with a border -
     // so we need to get rid of those
     //
     // Since we don't have a child window like most other
     // backends, we don't need wxCLIP_CHILDREN
     // Create window
     // By default wxWindow(s) is created with a border -
     // so we need to get rid of those
     //
     // Since we don't have a child window like most other
     // backends, we don't need wxCLIP_CHILDREN

-    //

     if ( !ctrl->wxControl::Create(parent, id, pos, size,
                                  wxWindow::MacRemoveBordersFromStyle(style),
     if ( !ctrl->wxControl::Create(parent, id, pos, size,
                                  wxWindow::MacRemoveBordersFromStyle(style),

-                                  validator, name)
-        )
+                                  validator, name))
+    {

         return false;
         return false;

+    }

 
 #if wxUSE_VALIDATORS
     ctrl->SetValidator(validator);
 
 #if wxUSE_VALIDATORS
     ctrl->SetValidator(validator);


@@ -386,16 +370,16 @@ bool wxQTMediaBackend::CreateControl(wxControl* ctrl, wxWindow* parent,
 //---------------------------------------------------------------------------
 // wxQTMediaBackend::IsQuickTime4Installed
 //
 //---------------------------------------------------------------------------
 // wxQTMediaBackend::IsQuickTime4Installed
 //

-// Determines whether version 4 of QT is installed 
+// Determines whether version 4 of QT is installed

 // (Pretty much for classic only)
 //---------------------------------------------------------------------------
 #if !wxUSE_CREATEMOVIECONTROL
 Boolean wxQTMediaBackend::IsQuickTime4Installed()
 {
 // (Pretty much for classic only)
 //---------------------------------------------------------------------------
 #if !wxUSE_CREATEMOVIECONTROL
 Boolean wxQTMediaBackend::IsQuickTime4Installed()
 {

-    short error;
+    OSErr error;

     long result;
 
     long result;
 

-    error = Gestalt (gestaltQuickTime, &result);
+    error = Gestalt(gestaltQuickTime, &result);

     return (error == noErr) && (((result >> 16) & 0xffff) >= 0x0400);
 }
 #endif
     return (error == noErr) && (((result >> 16) & 0xffff) >= 0x0400);
 }
 #endif


@@ -411,40 +395,42 @@ Boolean wxQTMediaBackend::IsQuickTime4Installed()
 //---------------------------------------------------------------------------
 bool wxQTMediaBackend::Load(const wxString& fileName)
 {
 //---------------------------------------------------------------------------
 bool wxQTMediaBackend::Load(const wxString& fileName)
 {

-    if(m_movie)
+    if (m_movie)

         Cleanup();
 
     OSErr err = noErr;
     short movieResFile;
     FSSpec sfFile;
 
         Cleanup();
 
     OSErr err = noErr;
     short movieResFile;
     FSSpec sfFile;
 

-    //FIXME:wxMacFilename2FSSpec crashes on empty string -
-    //does it crash on other strings too and should this
-    //"fix" be put in the carbon wxSound?
+    // FIXME:wxMacFilename2FSSpec crashes on empty string -
+    // does it crash on other strings too and should this
+    // "fix" be put in the carbon wxSound?

     if (fileName.empty())
         return false;
 
     if (fileName.empty())
         return false;
 

-    wxMacFilename2FSSpec( fileName , &sfFile );
+    wxMacFilename2FSSpec( fileName, &sfFile );

 
 

-    if (OpenMovieFile (&sfFile, &movieResFile, fsRdPerm) != noErr)
+    if (OpenMovieFile( &sfFile, &movieResFile, fsRdPerm ) != noErr)

         return false;
 
     short movieResID = 0;
     Str255 movieName;
         return false;
 
     short movieResID = 0;
     Str255 movieName;

-
-    err = NewMovieFromFile (
-    &m_movie,
-    movieResFile,
-    &movieResID,
-    movieName,
-    newMovieActive,
-    NULL); //wasChanged
-
-    //No ::GetMoviesStickyError() here because it returns -2009 
+    bool result;
+
+    err = NewMovieFromFile(
+        &m_movie,
+        movieResFile,
+        &movieResID,
+        movieName,
+        newMovieActive,
+        NULL); // wasChanged
+    result = (err == noErr);
+
+    // No ::GetMoviesStickyError() here because it returns -2009

     // a.k.a. invalid track on valid mpegs
     // a.k.a. invalid track on valid mpegs

-    if(err == noErr)
+    if (result)

     {
     {

-        ::CloseMovieFile (movieResFile);
+        ::CloseMovieFile(movieResFile);

 
         // Create movie controller/control
 #if wxUSE_CREATEMOVIECONTROL
 
         // Create movie controller/control
 #if wxUSE_CREATEMOVIECONTROL


@@ -452,13 +438,11 @@ bool wxQTMediaBackend::Load(const wxString& fileName)
 #else
         DoNewMovieController();
 #endif
 #else
         DoNewMovieController();
 #endif

-    FinishLoad();
-        return true;
-    }
-    else
-    {
-        return false;        
+
+        FinishLoad();

     }
     }

+
+    return result;

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


@@ -500,28 +484,31 @@ void wxQTMediaBackend::PPRMProc (Movie theMovie,
 //---------------------------------------------------------------------------
 bool wxQTMediaBackend::Load(const wxURI& location)
 {
 //---------------------------------------------------------------------------
 bool wxQTMediaBackend::Load(const wxURI& location)
 {

-    if(m_movie)
+    if (m_movie)

         Cleanup();
 
     wxString theURI = location.BuildURI();
 
     OSErr err = noErr;
         Cleanup();
 
     wxString theURI = location.BuildURI();
 
     OSErr err = noErr;

+    bool result;

 
 

+    // FIXME: lurking Unicode problem here

     Handle theHandle = ::NewHandleClear(theURI.length() + 1);
     wxASSERT(theHandle);
 
     Handle theHandle = ::NewHandleClear(theURI.length() + 1);
     wxASSERT(theHandle);
 

-    ::BlockMove(theURI.mb_str(), *theHandle, theURI.length() + 1);
+    ::BlockMoveData(theURI.mb_str(), *theHandle, theURI.length() + 1);

 
 

-    //create the movie from the handle that refers to the URI
+    // create the movie from the handle that refers to the URI

     err = ::NewMovieFromDataRef(&m_movie, newMovieActive |
                                                     newMovieAsyncOK
     err = ::NewMovieFromDataRef(&m_movie, newMovieActive |
                                                     newMovieAsyncOK

-                                                    /*|newMovieIdleImportOK*/,
+                                                    /* | newMovieIdleImportOK*/,

                                 NULL, theHandle,
                                 URLDataHandlerSubType);
 
     ::DisposeHandle(theHandle);
 
                                 NULL, theHandle,
                                 URLDataHandlerSubType);
 
     ::DisposeHandle(theHandle);
 

-    if (err == noErr)
+    result = (err == noErr);
+    if (result)

     {
 #if wxUSE_CREATEMOVIECONTROL
         // Movie control resets prerolling, so we must create first
     {
 #if wxUSE_CREATEMOVIECONTROL
         // Movie control resets prerolling, so we must create first


@@ -531,11 +518,11 @@ bool wxQTMediaBackend::Load(const wxURI& location)
         m_timer = new wxQTMediaLoadTimer(m_movie, this);
         m_timer->Start(MOVIE_DELAY);
 #else
         m_timer = new wxQTMediaLoadTimer(m_movie, this);
         m_timer->Start(MOVIE_DELAY);
 #else

-        // Movie controller resets prerolling, so we must create first 
+        // Movie controller resets prerolling, so we must create first

         DoNewMovieController();
         DoNewMovieController();

-        
+

         long timeNow;
         long timeNow;

-    Fixed playRate;
+        Fixed playRate;

 
         timeNow = ::GetMovieTime(m_movie, NULL);
         wxASSERT(::GetMoviesError() == noErr);
 
         timeNow = ::GetMovieTime(m_movie, NULL);
         wxASSERT(::GetMoviesError() == noErr);


@@ -543,7 +530,6 @@ bool wxQTMediaBackend::Load(const wxURI& location)
         playRate = ::GetMoviePreferredRate(m_movie);
         wxASSERT(::GetMoviesError() == noErr);
 
         playRate = ::GetMoviePreferredRate(m_movie);
         wxASSERT(::GetMoviesError() == noErr);
 

-        //

         //  Note that the callback here is optional,
         //  but without it PrePrerollMovie can be buggy
         //  (see Apple ml).  Also, some may wonder
         //  Note that the callback here is optional,
         //  but without it PrePrerollMovie can be buggy
         //  (see Apple ml).  Also, some may wonder


@@ -552,14 +538,14 @@ bool wxQTMediaBackend::Load(const wxURI& location)
         //  require it if you don't use a Movie Controller,
         //  which we don't by default.
         //
         //  require it if you don't use a Movie Controller,
         //  which we don't by default.
         //

-        ::PrePrerollMovie(m_movie, timeNow, playRate,
-                              wxQTMediaBackend::PPRMProc,
-                              (void*)this);
+        ::PrePrerollMovie(
+            m_movie, timeNow, playRate,
+            wxQTMediaBackend::PPRMProc,
+            (void*)this);

 #endif
 #endif

-        return true;

     }
     }

-    else
-        return false;
+
+    return result;

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


@@ -576,54 +562,53 @@ bool wxQTMediaBackend::Load(const wxURI& location)
 #if wxUSE_CREATEMOVIECONTROL
 void wxQTMediaBackend::DoCreateMovieControl()
 {
 #if wxUSE_CREATEMOVIECONTROL
 void wxQTMediaBackend::DoCreateMovieControl()
 {

-        //
-        //Native CreateMovieControl QT control (Thanks to Kevin Olliver's
-        //wxQTMovie for some of this).
-        //
-            Rect bounds = wxMacGetBoundsForControl(m_ctrl,
-                                                   m_ctrl->GetPosition(),
-                                                   m_ctrl->GetSize());
-
-        //Dispose of old control for new one
+    // Native CreateMovieControl QT control (Thanks to Kevin Olliver's
+    // wxQTMovie for some of this).
+    Rect bounds = wxMacGetBoundsForControl(
+        m_ctrl,
+        m_ctrl->GetPosition(),
+        m_ctrl->GetSize());
+
+    // Dispose of old control for new one

     if (m_ctrl->m_peer && m_ctrl->m_peer->Ok() )
         m_ctrl->m_peer->Dispose();
 
     if (m_ctrl->m_peer && m_ctrl->m_peer->Ok() )
         m_ctrl->m_peer->Dispose();
 

-        //Options-
-        //kMovieControlOptionXXX
-        //HideController - hide the movie controller
-        //LocateTopLeft - movie is pinned to top left rather than centered in the control
-        //EnableEditing - Allows programmatic editing and dragn'drop
-        //HandleEditingHI- Installs event stuff for edit menu - forces EnableEditing also
-        //SetKeysEnabled - Allows keyboard input
-        //ManuallyIdled - app handles movie idling rather than internal timer event loop
-        ::CreateMovieControl(
-                    (WindowRef)
-                   m_ctrl->MacGetTopLevelWindowRef(), //parent
-                       &bounds,                         //control bounds
-                       m_movie,                         //movie handle
-                       kMovieControlOptionHideController
-                       | kMovieControlOptionLocateTopLeft
-                       | kMovieControlOptionSetKeysEnabled
-                 //  | kMovieControlOptionManuallyIdled
-                       ,                                //flags
-                   m_ctrl->m_peer->GetControlRefAddr() );
-
-    ::EmbedControl(m_ctrl->m_peer->GetControlRef(), 
-                    (ControlRef)m_ctrl->GetParent()->GetHandle());    
-                    
-        //
-    // Setup MovieController for the new movie
-        //
+    // Options:
+    // kMovieControlOptionXXX
+    // HideController - hide the movie controller
+    // LocateTopLeft - movie is pinned to top left rather than centered in the control
+    // EnableEditing - Allows programmatic editing and dragn'drop
+    // HandleEditingHI- Installs event stuff for edit menu - forces EnableEditing also
+    // SetKeysEnabled - Allows keyboard input
+    // ManuallyIdled - app handles movie idling rather than internal timer event loop
+    ::CreateMovieControl(
+        (WindowRef)
+        m_ctrl->MacGetTopLevelWindowRef(), //parent
+        &bounds,                         //control bounds
+        m_movie,                         //movie handle
+        kMovieControlOptionHideController
+            | kMovieControlOptionLocateTopLeft
+            | kMovieControlOptionSetKeysEnabled
+            // | kMovieControlOptionManuallyIdled
+        ,                                // flags
+        m_ctrl->m_peer->GetControlRefAddr() );
+
+    ::EmbedControl(
+        m_ctrl->m_peer->GetControlRef(),
+        (ControlRef)m_ctrl->GetParent()->GetHandle());
+
+    // set up MovieController for the new movie

     long dataSize;
 
     long dataSize;
 

-    //Get movie controller from our control
-    ::GetControlData(   m_ctrl->m_peer->GetControlRef(), 0, 
-                    kMovieControlDataMovieController, 
-                    sizeof(MovieController), (Ptr)&m_mc, &dataSize );
+    // Get movie controller from our control
+    ::GetControlData(
+        m_ctrl->m_peer->GetControlRef(), 0,
+        kMovieControlDataMovieController,
+        sizeof(MovieController), (Ptr)&m_mc, &dataSize );

 
     // Setup a callback so we can tell when the user presses
     // play on the player controls
 
     // Setup a callback so we can tell when the user presses
     // play on the player controls

-    ::MCSetActionFilterWithRefCon(m_mc, 
+    ::MCSetActionFilterWithRefCon(m_mc,

             wxQTMediaBackend::MCFilterProc, (long)this);
 }
 #endif
             wxQTMediaBackend::MCFilterProc, (long)this);
 }
 #endif


@@ -637,71 +622,75 @@ void wxQTMediaBackend::DoCreateMovieControl()
 #if !wxUSE_CREATEMOVIECONTROL
 void wxQTMediaBackend::DoNewMovieController()
 {
 #if !wxUSE_CREATEMOVIECONTROL
 void wxQTMediaBackend::DoNewMovieController()
 {

-    if(!m_mc)
+    if (!m_mc)

     {
         // Get top level window ref for some mac functions
         WindowRef wrTLW = (WindowRef) m_ctrl->MacGetTopLevelWindowRef();
     {
         // Get top level window ref for some mac functions
         WindowRef wrTLW = (WindowRef) m_ctrl->MacGetTopLevelWindowRef();

-        
-        // MovieController not setup yet - 
+
+        // MovieController not setup yet:

         // so we need to create a new one.
         // so we need to create a new one.

-        // You have to pass a valid movie to 
+        // You have to pass a valid movie to

         // NewMovieController, evidently
         ::SetMovieGWorld(m_movie,
                        (CGrafPtr) GetWindowPort(wrTLW),
                        NULL);
         wxASSERT(::GetMoviesError() == noErr);
 
         // NewMovieController, evidently
         ::SetMovieGWorld(m_movie,
                        (CGrafPtr) GetWindowPort(wrTLW),
                        NULL);
         wxASSERT(::GetMoviesError() == noErr);
 

-        Rect bounds = wxMacGetBoundsForControl(m_ctrl,
-                                           m_ctrl->GetPosition(),
-                                           m_ctrl->GetSize());
+        Rect bounds = wxMacGetBoundsForControl(
+            m_ctrl,
+            m_ctrl->GetPosition(),
+            m_ctrl->GetSize());

 
 

-        m_mc = ::NewMovieController(m_movie, &bounds, mcTopLeftMovie |
-                                                //mcWithFrame |
-                                                mcNotVisible);
+        m_mc = ::NewMovieController(
+            m_movie, &bounds,
+            mcTopLeftMovie | mcNotVisible /* | mcWithFrame */ );

         wxASSERT(::GetMoviesError() == noErr);
         wxASSERT(::GetMoviesError() == noErr);

+

         ::MCDoAction(m_mc, 32, (void*)true); //mcActionSetKeysEnabled
         wxASSERT(::GetMoviesError() == noErr);
 
         // Setup a callback so we can tell when the user presses
         // play on the player controls
         ::MCDoAction(m_mc, 32, (void*)true); //mcActionSetKeysEnabled
         wxASSERT(::GetMoviesError() == noErr);
 
         // Setup a callback so we can tell when the user presses
         // play on the player controls

-        ::MCSetActionFilterWithRefCon(m_mc, 
+        ::MCSetActionFilterWithRefCon(m_mc,

             wxQTMediaBackend::MCFilterProc, (long)this);
         wxASSERT(::GetMoviesError() == noErr);
 
             wxQTMediaBackend::MCFilterProc, (long)this);
         wxASSERT(::GetMoviesError() == noErr);
 

-        //Part of a suggestion from Greg Hazel to repaint
-        //movie when idle
+        // Part of a suggestion from Greg Hazel to repaint
+        // movie when idle

         m_ctrl->PushEventHandler(new wxQTMediaEvtHandler(this));
         m_ctrl->PushEventHandler(new wxQTMediaEvtHandler(this));

-        
+

         // Event types to catch from the TLW
         // for the moviecontroller
         // Event types to catch from the TLW
         // for the moviecontroller

-        EventTypeSpec theEventTypes[] = { 
-                    { kEventClassMouse,     kEventMouseDown },
-                    { kEventClassMouse,     kEventMouseUp },
-                    { kEventClassKeyboard,  kEventRawKeyDown },
-                    { kEventClassKeyboard,  kEventRawKeyRepeat },
-                    { kEventClassKeyboard,  kEventRawKeyUp },
-                    { kEventClassWindow,    kEventWindowUpdate },
-                    { kEventClassWindow,    kEventWindowActivated },
-                    { kEventClassWindow,    kEventWindowDeactivated } 
-                                        };
-                                        
-        // Catch window messages - 
+        EventTypeSpec theEventTypes[] =
+        {
+            { kEventClassMouse,     kEventMouseDown },
+            { kEventClassMouse,     kEventMouseUp },
+            { kEventClassKeyboard,  kEventRawKeyDown },
+            { kEventClassKeyboard,  kEventRawKeyRepeat },
+            { kEventClassKeyboard,  kEventRawKeyUp },
+            { kEventClassWindow,    kEventWindowUpdate },
+            { kEventClassWindow,    kEventWindowActivated },
+            { kEventClassWindow,    kEventWindowDeactivated }
+        };
+
+        // Catch window messages:

         // if we do not do this and if the user clicks the play
         // button on the controller, for instance, nothing will happen...
         // if we do not do this and if the user clicks the play
         // button on the controller, for instance, nothing will happen...

-        InstallWindowEventHandler( wrTLW, 
-                GetwxQTMediaWindowEventHandlerUPP(), 
-                GetEventTypeCount( theEventTypes ), theEventTypes, 
+        InstallWindowEventHandler( wrTLW,
+                GetwxQTMediaWindowEventHandlerUPP(),
+                GetEventTypeCount( theEventTypes ), theEventTypes,

                 m_mc, (&(EventHandlerRef&)m_pEventHandlerRef) );
     }
     else
     {
                 m_mc, (&(EventHandlerRef&)m_pEventHandlerRef) );
     }
     else
     {

-        // MovieController already created - 
+        // MovieController already created:

         // Just change the movie in it and we're good to go
         Point thePoint;
         thePoint.h = thePoint.v = 0;
         // Just change the movie in it and we're good to go
         Point thePoint;
         thePoint.h = thePoint.v = 0;

-        ::MCSetMovie(m_mc, m_movie,  
+        ::MCSetMovie(m_mc, m_movie,

               (WindowRef)m_ctrl->MacGetTopLevelWindowRef(),
                thePoint);
               (WindowRef)m_ctrl->MacGetTopLevelWindowRef(),
                thePoint);

+

         wxASSERT(::GetMoviesError() == noErr);
     }
 }
         wxASSERT(::GetMoviesError() == noErr);
     }
 }


@@ -713,24 +702,24 @@ void wxQTMediaBackend::DoNewMovieController()
 // Performs operations after a movie ready to play/loaded.
 //---------------------------------------------------------------------------
 void wxQTMediaBackend::FinishLoad()
 // Performs operations after a movie ready to play/loaded.
 //---------------------------------------------------------------------------
 void wxQTMediaBackend::FinishLoad()

-{                    
+{

     // get the real size of the movie
     DoLoadBestSize();
 
     // get the real size of the movie
     DoLoadBestSize();
 

-    // Show the player controls if the user wants to
-    if(m_interfaceflags)
+    // show the player controls if the user wants to
+    if (m_interfaceflags)

         DoSetControllerVisible(m_interfaceflags);
 
         DoSetControllerVisible(m_interfaceflags);
 

-    //we want millisecond precision
+    // we want millisecond precision

     ::SetMovieTimeScale(m_movie, 1000);
     wxASSERT(::GetMoviesError() == noErr);
 
     ::SetMovieTimeScale(m_movie, 1000);
     wxASSERT(::GetMoviesError() == noErr);
 

-    // Start movie progress timer
+    // start movie progress timer

     m_timer = new wxQTMediaPlayTimer(m_movie, (wxQTMediaBackend*) this);
     wxASSERT(m_timer);
     m_timer->Start(MOVIE_DELAY, wxTIMER_CONTINUOUS);
 
     m_timer = new wxQTMediaPlayTimer(m_movie, (wxQTMediaBackend*) this);
     wxASSERT(m_timer);
     m_timer->Start(MOVIE_DELAY, wxTIMER_CONTINUOUS);
 

-    //send loaded event & refresh size
+    // send loaded event & refresh size

     NotifyMovieLoaded();
 }
 
     NotifyMovieLoaded();
 }
 


@@ -741,12 +730,12 @@ void wxQTMediaBackend::FinishLoad()
 //---------------------------------------------------------------------------
 void wxQTMediaBackend::DoLoadBestSize()
 {
 //---------------------------------------------------------------------------
 void wxQTMediaBackend::DoLoadBestSize()
 {

-    //get the real size of the movie
+    // get the real size of the movie

     Rect outRect;
     ::GetMovieNaturalBoundsRect (m_movie, &outRect);
     wxASSERT(::GetMoviesError() == noErr);
 
     Rect outRect;
     ::GetMovieNaturalBoundsRect (m_movie, &outRect);
     wxASSERT(::GetMoviesError() == noErr);
 

-    //determine best size
+    // determine best size

     m_bestSize.x = outRect.right - outRect.left;
     m_bestSize.y = outRect.bottom - outRect.top;
 }
     m_bestSize.x = outRect.right - outRect.left;
     m_bestSize.y = outRect.bottom - outRect.top;
 }


@@ -759,14 +748,13 @@ void wxQTMediaBackend::DoLoadBestSize()
 bool wxQTMediaBackend::Play()
 {
     Fixed fixRate = (Fixed) (wxQTMediaBackend::GetPlaybackRate() * 0x10000);
 bool wxQTMediaBackend::Play()
 {
     Fixed fixRate = (Fixed) (wxQTMediaBackend::GetPlaybackRate() * 0x10000);

-    if(!fixRate)
+    if (!fixRate)

         fixRate = ::GetMoviePreferredRate(m_movie);
         fixRate = ::GetMoviePreferredRate(m_movie);

-    
+

     wxASSERT(fixRate != 0);
 
     wxASSERT(fixRate != 0);
 

-    if(!m_bPlaying)
-        ::MCDoAction(   m_mc, 8, // mcActionPlay 
-           (void *) fixRate);
+    if (!m_bPlaying)
+        ::MCDoAction( m_mc, 8 /* mcActionPlay */, (void*) fixRate);

 
     m_bPlaying = true;
     return ::GetMoviesError() == noErr;
 
     m_bPlaying = true;
     return ::GetMoviesError() == noErr;


@@ -779,15 +767,16 @@ bool wxQTMediaBackend::Play()
 //---------------------------------------------------------------------------
 bool wxQTMediaBackend::Pause()
 {
 //---------------------------------------------------------------------------
 bool wxQTMediaBackend::Pause()
 {

-    //Stop the movie A.K.A. ::StopMovie(m_movie);
-    if(m_bPlaying)
+    // Stop the movie A.K.A. ::StopMovie(m_movie);
+    if (m_bPlaying)

     {
     {

-        ::MCDoAction(   m_mc, 8 /*mcActionPlay*/, 
-                        (void *) 0);
+        ::MCDoAction( m_mc, 8 /*mcActionPlay*/, (void*) 0);

         m_bPlaying = false;
         m_bPlaying = false;

-    return ::GetMoviesError() == noErr;
+        return ::GetMoviesError() == noErr;

     }
     }

-    return true; //already paused
+
+    // already paused
+    return true;

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


@@ -798,7 +787,7 @@ bool wxQTMediaBackend::Pause()
 //---------------------------------------------------------------------------
 bool wxQTMediaBackend::Stop()
 {
 //---------------------------------------------------------------------------
 bool wxQTMediaBackend::Stop()
 {

-    if(!wxQTMediaBackend::Pause())
+    if (!wxQTMediaBackend::Pause())

         return false;
 
     ::GoToBeginningOfMovie(m_movie);
         return false;
 
     ::GoToBeginningOfMovie(m_movie);


@@ -876,10 +865,10 @@ double wxQTMediaBackend::GetVolume()
 {
     short sVolume = ::GetMovieVolume(m_movie);
 
 {
     short sVolume = ::GetMovieVolume(m_movie);
 

-    if(sVolume & (128 << 8)) //negative - no sound
+    if (sVolume & (128 << 8)) //negative - no sound

         return 0.0;
 
         return 0.0;
 

-    return sVolume/256.0;
+    return sVolume / 256.0;

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


@@ -902,7 +891,7 @@ bool wxQTMediaBackend::SetVolume(double dVolume)
     ::SetMovieVolume(m_movie, (short) (dVolume * 256));
     return true;
 }
     ::SetMovieVolume(m_movie, (short) (dVolume * 256));
     return true;
 }

- 
+

  //---------------------------------------------------------------------------
 // wxQTMediaBackend::GetDuration
 //
  //---------------------------------------------------------------------------
 // wxQTMediaBackend::GetDuration
 //


@@ -922,9 +911,9 @@ wxLongLong wxQTMediaBackend::GetDuration()
 wxMediaState wxQTMediaBackend::GetState()
 {
     // Could use
 wxMediaState wxQTMediaBackend::GetState()
 {
     // Could use

-    // GetMovieActive/IsMovieDone/SetMovieActive 
+    // GetMovieActive/IsMovieDone/SetMovieActive

     // combo if implemented that way
     // combo if implemented that way

-    if (m_bPlaying == true)
+    if (m_bPlaying)

         return wxMEDIASTATE_PLAYING;
     else if ( !m_movie || wxQTMediaBackend::GetPosition() == 0)
         return wxMEDIASTATE_STOPPED;
         return wxMEDIASTATE_PLAYING;
     else if ( !m_movie || wxQTMediaBackend::GetPosition() == 0)
         return wxMEDIASTATE_STOPPED;


@@ -941,23 +930,21 @@ wxMediaState wxQTMediaBackend::GetState()
 void wxQTMediaBackend::Cleanup()
 {
     m_bPlaying = false;
 void wxQTMediaBackend::Cleanup()
 {
     m_bPlaying = false;

-    if(m_timer)
+    if (m_timer)

     {
     {

-    delete m_timer;
-    m_timer = NULL;
+        delete m_timer;
+        m_timer = NULL;

     }
 
     }
 

-    // Stop the movie
+    // Stop the movie:

     // Apple samples with CreateMovieControl typically
     // install a event handler and do this on the dispose
     // event, but we do it here for simplicity
     // (It might keep playing for several seconds after
     // Apple samples with CreateMovieControl typically
     // install a event handler and do this on the dispose
     // event, but we do it here for simplicity
     // (It might keep playing for several seconds after

-    //  control destruction if not)
+    // control destruction if not)

     wxQTMediaBackend::Pause();
     wxQTMediaBackend::Pause();

-    
-    //
+

     // Dispose of control or remove movie from MovieController
     // Dispose of control or remove movie from MovieController

-    //

 #if wxUSE_CREATEMOVIECONTROL
     if (m_ctrl->m_peer && m_ctrl->m_peer->Ok() )
         m_ctrl->m_peer->Dispose();
 #if wxUSE_CREATEMOVIECONTROL
     if (m_ctrl->m_peer && m_ctrl->m_peer->Ok() )
         m_ctrl->m_peer->Dispose();


@@ -969,6 +956,7 @@ void wxQTMediaBackend::Cleanup()
 #endif
 
     ::DisposeMovie(m_movie);
 #endif
 
     ::DisposeMovie(m_movie);

+    m_movie = NULL;

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


@@ -977,25 +965,29 @@ void wxQTMediaBackend::Cleanup()
 // Callback for when the movie controller recieves a message
 //---------------------------------------------------------------------------
 Boolean wxQTMediaBackend::MCFilterProc(
 // Callback for when the movie controller recieves a message
 //---------------------------------------------------------------------------
 Boolean wxQTMediaBackend::MCFilterProc(

-                               MovieController WXUNUSED(theController),
-                               short action,
-                               void * WXUNUSED(params),
-                               long refCon)
+    MovieController WXUNUSED(theController),
+    short action,
+    void * WXUNUSED(params),
+    long refCon)

 {
 {

-    if(action != 1) //don't process idle events
-    {
-        wxQTMediaBackend* pThis = (wxQTMediaBackend*)refCon;
+    wxQTMediaBackend* pThis = (wxQTMediaBackend*)refCon;

 
 

-        switch(action)
-        {
-        case 8: //play button triggered - MC will set movie to opposite state
-                //of current - playing ? paused : playing
-            pThis->m_bPlaying = !(pThis->m_bPlaying);
-            break;
-        default:
-            break;
-        }
+    switch (action)
+    {
+    case 1:
+        // don't process idle events
+        break;
+
+    case 8:
+        // play button triggered - MC will set movie to opposite state
+        // of current - playing ? paused : playing
+        pThis->m_bPlaying = !(pThis->m_bPlaying);
+        break;
+
+    default:
+        break;

     }
     }

+

     return 0;
 }
 
     return 0;
 }
 


@@ -1018,16 +1010,16 @@ wxSize wxQTMediaBackend::GetVideoSize() const
 void wxQTMediaBackend::Move(int x, int y, int w, int h)
 {
 #if !wxUSE_CREATEMOVIECONTROL
 void wxQTMediaBackend::Move(int x, int y, int w, int h)
 {
 #if !wxUSE_CREATEMOVIECONTROL

-    if(m_timer)
+    if (m_timer)

     {
     {

-            m_ctrl->GetParent()->MacWindowToRootWindow(&x, &y);
+        m_ctrl->GetParent()->MacWindowToRootWindow(&x, &y);

         Rect theRect = {y, x, y+h, x+w};
 
         ::MCSetControllerBoundsRect(m_mc, &theRect);
         wxASSERT(::GetMoviesError() == noErr);
     }
 #else
         Rect theRect = {y, x, y+h, x+w};
 
         ::MCSetControllerBoundsRect(m_mc, &theRect);
         wxASSERT(::GetMoviesError() == noErr);
     }
 #else

-    if(m_timer && m_ctrl)
+    if (m_timer && m_ctrl)

     {
         m_ctrl->GetParent()->MacWindowToRootWindow(&x, &y);
 
     {
         m_ctrl->GetParent()->MacWindowToRootWindow(&x, &y);
 


@@ -1045,35 +1037,32 @@ void wxQTMediaBackend::Move(int x, int y, int w, int h)
 // and showing/hiding the particular controls on it
 //---------------------------------------------------------------------------
 void wxQTMediaBackend::DoSetControllerVisible(wxMediaCtrlPlayerControls flags)
 // and showing/hiding the particular controls on it
 //---------------------------------------------------------------------------
 void wxQTMediaBackend::DoSetControllerVisible(wxMediaCtrlPlayerControls flags)

-{    
-    ::MCSetVisible(m_mc, TRUE);
-    
-    //
+{
+    ::MCSetVisible(m_mc, true);
+

     // Take care of subcontrols
     // Take care of subcontrols

-    //
-    if(::GetMoviesError() == noErr)
+    if (::GetMoviesError() == noErr)

     {
         long mcFlags = 0;
         ::MCDoAction(m_mc, 39/*mcActionGetFlags*/, (void*)&mcFlags);
     {
         long mcFlags = 0;
         ::MCDoAction(m_mc, 39/*mcActionGetFlags*/, (void*)&mcFlags);

-        
-        if(::GetMoviesError() == noErr)
-        {            
+
+        if (::GetMoviesError() == noErr)
+        {

              mcFlags |= (  //(1<<0)/*mcFlagSuppressMovieFrame*/ |
              mcFlags |= (  //(1<<0)/*mcFlagSuppressMovieFrame*/ |

-                     (1<<3)/*mcFlagsUseWindowPalette*/
+                     (1 << 3)/*mcFlagsUseWindowPalette*/

                        | ((flags & wxMEDIACTRLPLAYERCONTROLS_STEP)
                        | ((flags & wxMEDIACTRLPLAYERCONTROLS_STEP)

-                          ? 0 : (1<<1)/*mcFlagSuppressStepButtons*/)
+                          ? 0 : (1 << 1)/*mcFlagSuppressStepButtons*/)

                        | ((flags & wxMEDIACTRLPLAYERCONTROLS_VOLUME)
                        | ((flags & wxMEDIACTRLPLAYERCONTROLS_VOLUME)

-                          ? 0 : (1<<2)/*mcFlagSuppressSpeakerButton*/)
-         //              | (1<<4) /*mcFlagDontInvalidate*/ //if we take care of repainting ourselves
+                          ? 0 : (1 << 2)/*mcFlagSuppressSpeakerButton*/)
+         //              | (1 << 4) /*mcFlagDontInvalidate*/ //if we take care of repainting ourselves

                           );
                           );

-            ::MCDoAction(m_mc, 38/*mcActionSetFlags*/, (void*)mcFlags);   
+
+            ::MCDoAction(m_mc, 38/*mcActionSetFlags*/, (void*)mcFlags);

         }
         }

-    }    
-    
-    //
-    //Adjust height and width of best size for movie controller
-    //if the user wants it shown
-    //
+    }
+
+    // Adjust height and width of best size for movie controller
+    // if the user wants it shown

     m_bestSize.x = m_bestSize.x > wxMCWIDTH ? m_bestSize.x : wxMCWIDTH;
     m_bestSize.y += wxMCHEIGHT;
 }
     m_bestSize.x = m_bestSize.x > wxMCWIDTH ? m_bestSize.x : wxMCWIDTH;
     m_bestSize.y += wxMCHEIGHT;
 }


@@ -1085,33 +1074,33 @@ void wxQTMediaBackend::DoSetControllerVisible(wxMediaCtrlPlayerControls flags)
 //---------------------------------------------------------------------------
 bool wxQTMediaBackend::ShowPlayerControls(wxMediaCtrlPlayerControls flags)
 {
 //---------------------------------------------------------------------------
 bool wxQTMediaBackend::ShowPlayerControls(wxMediaCtrlPlayerControls flags)
 {

-    if(!m_mc)
+    if (!m_mc)

         return false; //no movie controller...
         return false; //no movie controller...

-        
+

     bool bSizeChanged = false;
     bool bSizeChanged = false;

-    
-    //if the controller is visible and we want to hide it do so
-    if(m_interfaceflags && !flags)
+
+    // if the controller is visible and we want to hide it do so
+    if (m_interfaceflags && !flags)

     {
         bSizeChanged = true;
         DoLoadBestSize();
     {
         bSizeChanged = true;
         DoLoadBestSize();

-        ::MCSetVisible(m_mc, FALSE);
+        ::MCSetVisible(m_mc, false);

     }
     }

-    else if(!m_interfaceflags && flags) //show controller if hidden
+    else if (!m_interfaceflags && flags) //show controller if hidden

     {
         bSizeChanged = true;
         DoSetControllerVisible(flags);
     }
     {
         bSizeChanged = true;
         DoSetControllerVisible(flags);
     }

-    
-    //readjust parent sizers
-    if(bSizeChanged)
+
+    // readjust parent sizers
+    if (bSizeChanged)

     {
     {

-        NotifyMovieSizeChanged();   
-        
+        NotifyMovieSizeChanged();
+

         //remember state in case of loading new media
         m_interfaceflags = flags;
         //remember state in case of loading new media
         m_interfaceflags = flags;

-    }        
-    
+    }
+

     return ::GetMoviesError() == noErr;
 }
 
     return ::GetMoviesError() == noErr;
 }
 


@@ -1126,7 +1115,7 @@ void wxQTMediaEvtHandler::OnEraseBackground(wxEraseEvent& evt)
 {
     // Work around Nasty OSX drawing bug -
     // http://lists.apple.com/archives/QuickTime-API/2002/Feb/msg00311.html
 {
     // Work around Nasty OSX drawing bug -
     // http://lists.apple.com/archives/QuickTime-API/2002/Feb/msg00311.html

-    WindowRef wrTLW = 
+    WindowRef wrTLW =

         (WindowRef) m_qtb->m_ctrl->MacGetTopLevelWindowRef();
 
     RgnHandle region = MCGetControllerBoundsRgn(m_qtb->m_mc);
         (WindowRef) m_qtb->m_ctrl->MacGetTopLevelWindowRef();
 
     RgnHandle region = MCGetControllerBoundsRgn(m_qtb->m_mc);


@@ -1142,24 +1131,25 @@ void wxQTMediaEvtHandler::OnEraseBackground(wxEraseEvent& evt)
 // messages to our moviecontroller so it can recieve mouse clicks etc.
 //---------------------------------------------------------------------------
 #if !wxUSE_CREATEMOVIECONTROL
 // messages to our moviecontroller so it can recieve mouse clicks etc.
 //---------------------------------------------------------------------------
 #if !wxUSE_CREATEMOVIECONTROL

-OSStatus wxQTMediaWindowEventHandler(EventHandlerCallRef inHandlerCallRef, 
-                                        EventRef inEvent, void *inUserData)
+OSStatus wxQTMediaWindowEventHandler(
+    EventHandlerCallRef inHandlerCallRef,
+    EventRef inEvent, void *inUserData)

 {
     EventRecord theEvent;
     ConvertEventRefToEventRecord( inEvent, &theEvent );
     OSStatus err;
     err = ::MCIsPlayerEvent( (MovieController) inUserData, &theEvent );
 {
     EventRecord theEvent;
     ConvertEventRefToEventRecord( inEvent, &theEvent );
     OSStatus err;
     err = ::MCIsPlayerEvent( (MovieController) inUserData, &theEvent );

-    
+

     // pass on to other event handlers if not handled- i.e. wx
     // pass on to other event handlers if not handled- i.e. wx

-    if(err)
+    if (err != noErr)

         return noErr;
     else
         return eventNotHandledErr;
 }
 #endif
 
         return noErr;
     else
         return eventNotHandledErr;
 }
 #endif
 

-//in source file that contains stuff you don't directly use
+// in source file that contains stuff you don't directly use

 #include "wx/html/forcelnk.h"
 FORCE_LINK_ME(basewxmediabackends)
 
 #include "wx/html/forcelnk.h"
 FORCE_LINK_ME(basewxmediabackends)
 

-#endif //wxUSE_MEDIACTRL
+#endif // wxUSE_MEDIACTRL