/////////////////////////////////////////////////////////////////////////////
-// Name: mac/carbon/mediactrl.cpp
+// Name: src/mac/carbon/mediactrl.cpp
// Purpose: Built-in Media Backends for Mac
// Author: Ryan Norton <wxprojects@comcast.net>
// Modified by:
// Created: 11/07/04
// RCS-ID: $Id$
-// Copyright: (c) 2004-2005 Ryan Norton
+// Copyright: (c) 2004-2006 Ryan Norton
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-// There are several known bugs with CreateMovieControl
-// on systems > 10.2 - see main.c of QTCarbonShell sample for details
+// OK, a casual overseer of this file may wonder why we don't use
+// either CreateMovieControl or HIMovieView...
+//
+// CreateMovieControl
+// 1) Need to dispose and create each time a new movie is loaded
+// 2) Not that many real advantages
+// 3) Progressively buggier in higher OSX versions
+// (see main.c of QTCarbonShell sample for details)
+// HIMovieView
+// 1) Crashes on destruction in ALL cases on quite a few systems!
+// (With the only real "alternative" is to simply not
+// dispose of it and let it leak...)
+// 2) Massive refreshing bugs with its movie controller between
+// movies
+//
+// At one point we had a complete implementation for CreateMovieControl
+// and on my (RN) local copy I had one for HIMovieView - but they
+// were simply deemed to be too buggy/unuseful. HIMovieView could
+// have been useful as well because it uses OpenGL contexts instead
+// of GWorlds. Perhaps someday when someone comes out with some
+// ingenious workarounds :).
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
-#ifdef __BORLANDC__
-#pragma hdrstop
-#endif
+#if wxUSE_MEDIACTRL
#include "wx/mediactrl.h"
+#ifndef WX_PRECOMP
+ #include "wx/log.h"
+ #include "wx/timer.h"
+#endif
+
// uma is for wxMacFSSpec
#include "wx/mac/uma.h"
-#include "wx/timer.h"
+// standard QT stuff
#ifndef __DARWIN__
#include <Movies.h>
#include <Gestalt.h>
-#include <QuickTimeComponents.h> // standard QT stuff
+#include <QuickTimeComponents.h>
#else
#include <QuickTime/QuickTimeComponents.h>
#endif
-#if wxUSE_MEDIACTRL
-
-//---------------------------------------------------------------------------
-// Whether or not to use OSX 10.2's CreateMovieControl for native QuickTime
-// control - i.e. native positioning and event handling etc..
-//---------------------------------------------------------------------------
-#ifndef wxUSE_CREATEMOVIECONTROL
-# if defined( __WXMAC_OSX__ ) && \
- ( MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_2 )
-# define wxUSE_CREATEMOVIECONTROL 1
-# else
-# define wxUSE_CREATEMOVIECONTROL 0
-# endif
+#if !defined(__LP64__)
+#define USE_QUICKTIME 1
+#else
+#define USE_QUICKTIME 0
#endif
+#if USE_QUICKTIME
+
//---------------------------------------------------------------------------
-// Height and Width of movie controller in the movie control
+// Height and Width of movie controller in the movie control (apple samples)
//---------------------------------------------------------------------------
#define wxMCWIDTH 320
#define wxMCHEIGHT 16
// wxQTMediaBackend
//---------------------------------------------------------------------------
-
class WXDLLIMPEXP_MEDIA wxQTMediaBackend : public wxMediaBackendCommonBase
{
public:
wxQTMediaBackend();
- ~wxQTMediaBackend();
+ virtual ~wxQTMediaBackend();
virtual bool CreateControl(wxControl* ctrl, wxWindow* parent,
wxWindowID id,
const wxValidator& validator,
const wxString& name);
+ virtual bool Load(const wxString& fileName);
+ virtual bool Load(const wxURI& location);
+
virtual bool Play();
virtual bool Pause();
virtual bool Stop();
- virtual bool Load(const wxString& fileName);
- virtual bool Load(const wxURI& location);
-
virtual wxMediaState GetState();
virtual bool SetPosition(wxLongLong where);
virtual bool ShowPlayerControls(wxMediaCtrlPlayerControls flags);
+ virtual wxLongLong GetDownloadProgress();
+ virtual wxLongLong GetDownloadTotal();
+
+ virtual void MacVisibilityChanged();
+
+ //
// ------ Implementation from now on --------
+ //
+ bool DoPause();
+ bool DoStop();
void DoLoadBestSize();
void DoSetControllerVisible(wxMediaCtrlPlayerControls flags);
- //TODO: Last param actually long - does this work on 64bit machines?
- static Boolean MCFilterProc (MovieController theController,
- short action, void *params, long refCon);
+ wxLongLong GetDataSizeFromStart(TimeValue end);
-#if wxUSE_CREATEMOVIECONTROL
- void DoCreateMovieControl();
-#else
Boolean IsQuickTime4Installed();
void DoNewMovieController();
- static void PPRMProc (Movie theMovie, OSErr theErr, void* theRefCon);
-#endif
- wxSize m_bestSize; // Original movie size
+ static pascal void PPRMProc(
+ Movie theMovie, OSErr theErr, void* theRefCon);
-#ifdef __WXMAC_OSX__
- struct MovieType** m_movie; // QT Movie handle/instance
-#else
- Movie m_movie; // Movie instance
-#endif
+ //TODO: Last param actually long - does this work on 64bit machines?
+ static pascal Boolean MCFilterProc(MovieController theController,
+ short action, void *params, long refCon);
+
+ static pascal OSStatus WindowEventHandler(
+ EventHandlerCallRef inHandlerCallRef,
+ EventRef inEvent, void *inUserData );
+ wxSize m_bestSize; // Original movie size
+ Movie m_movie; // Movie instance
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
+ // Event handlers and UPPs/Callbacks
+ EventHandlerRef m_windowEventHandler;
+ EventHandlerUPP m_windowUPP;
+
+ MoviePrePrerollCompleteUPP m_preprerollupp;
+ MCActionFilterWithRefConUPP m_mcactionupp;
+
+ GWorldPtr m_movieWorld; //Offscreen movie GWorld
friend class wxQTMediaEvtHandler;
-#endif
DECLARE_DYNAMIC_CLASS(wxQTMediaBackend)
};
-#if !wxUSE_CREATEMOVIECONTROL
// helper to hijack background erasing for the QT window
class WXDLLIMPEXP_MEDIA wxQTMediaEvtHandler : public wxEvtHandler
{
DECLARE_NO_COPY_CLASS(wxQTMediaEvtHandler)
};
-// Window event handler
-static pascal OSStatus wxQTMediaWindowEventHandler(
- EventHandlerCallRef inHandlerCallRef,
- EventRef inEvent, void *inUserData);
-DEFINE_ONE_SHOT_HANDLER_GETTER( wxQTMediaWindowEventHandler );
-
-#endif
-
//===========================================================================
// IMPLEMENTATION
//===========================================================================
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+//
// wxQTMediaBackend
+//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
IMPLEMENT_DYNAMIC_CLASS(wxQTMediaBackend, wxMediaBackend)
class wxQTMediaLoadTimer : public wxTimer
{
public:
- wxQTMediaLoadTimer(Movie movie, wxQTMediaBackend* parent) :
- m_movie(movie), m_parent(parent) {}
+ wxQTMediaLoadTimer(wxQTMediaBackend* parent) :
+ m_parent(parent) {}
void Notify()
{
- // Note that the CreateMovieControl variety performs
- // its own custom idleing
-#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)
+ if (::GetMovieLoadState(m_parent->m_movie) >= 20000)
{
m_parent->FinishLoad();
delete this;
}
protected:
- Movie m_movie; // Our movie instance
wxQTMediaBackend *m_parent; // Backend pointer
};
class wxQTMediaPlayTimer : public wxTimer
{
public:
- wxQTMediaPlayTimer(Movie movie, wxQTMediaBackend* parent) :
- m_movie(movie), m_parent(parent) {}
+ wxQTMediaPlayTimer(wxQTMediaBackend* parent) :
+ m_parent(parent) {}
void Notify()
{
- //Note that CreateMovieControl performs its own idleing
-#if !wxUSE_CREATEMOVIECONTROL
//
// OK, a little explaining - basically originally
// we only called MoviesTask if the movie was actually
// correctly.
//
::MCIdle(m_parent->m_mc);
-#endif
+ //
// Handle the stop event - if the movie has reached
// the end, notify our handler
- if (::IsMovieDone(m_movie))
+ //
+ if (::IsMovieDone(m_parent->m_movie))
{
if ( m_parent->SendStopEvent() )
{
}
protected:
- Movie m_movie; // Our movie instance
wxQTMediaBackend* m_parent; // Backend pointer
};
wxQTMediaBackend::wxQTMediaBackend()
: m_movie(NULL), m_bPlaying(false), m_timer(NULL)
, m_mc(NULL), m_interfaceflags(wxMEDIACTRLPLAYERCONTROLS_NONE)
+ , m_preprerollupp(NULL), m_movieWorld(NULL)
{
}
if (m_movie)
Cleanup();
-#if !wxUSE_CREATEMOVIECONTROL
// Cleanup for moviecontroller
if (m_mc)
{
// destroy wxQTMediaEvtHandler we pushed on it
m_ctrl->PopEventHandler(true);
- RemoveEventHandler((EventHandlerRef&)m_pEventHandlerRef);
+ RemoveEventHandler(m_windowEventHandler);
+ DisposeEventHandlerUPP(m_windowUPP);
+
+ // Dispose of the movie controller
::DisposeMovieController(m_mc);
+ m_mc = NULL;
+
+ // Dispose of offscreen GWorld
+ ::DisposeGWorld(m_movieWorld);
}
-#endif
// Note that ExitMovies() is not necessary...
ExitMovies();
const wxValidator& validator,
const wxString& name)
{
- // Don't bother in Native control mode
-#if !wxUSE_CREATEMOVIECONTROL
if (!IsQuickTime4Installed())
return false;
-#endif
EnterMovies();
+ wxMediaCtrl* mediactrl = (wxMediaCtrl*)ctrl;
+
+ //
// 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),
- validator, name))
+ //
+ if ( !mediactrl->wxControl::Create(
+ parent, id, pos, size,
+ wxWindow::MacRemoveBordersFromStyle(style),
+ validator, name))
{
return false;
}
#if wxUSE_VALIDATORS
- ctrl->SetValidator(validator);
+ mediactrl->SetValidator(validator);
#endif
- m_ctrl = (wxMediaCtrl*)ctrl;
+ m_ctrl = mediactrl;
return true;
}
// wxQTMediaBackend::IsQuickTime4Installed
//
// Determines whether version 4 of QT is installed
-// (Pretty much for classic only)
+// (Pretty much for Classic only)
//---------------------------------------------------------------------------
-#if !wxUSE_CREATEMOVIECONTROL
Boolean wxQTMediaBackend::IsQuickTime4Installed()
{
OSErr error;
error = Gestalt(gestaltQuickTime, &result);
return (error == noErr) && (((result >> 16) & 0xffff) >= 0x0400);
}
-#endif
//---------------------------------------------------------------------------
// wxQTMediaBackend::Load (file version)
if (m_movie)
Cleanup();
+ ::ClearMoviesStickyError(); // clear previous errors so
+ // GetMoviesStickyError is useful
+
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?
- if (fileName.empty())
- return false;
-
wxMacFilename2FSSpec( fileName, &sfFile );
-
if (OpenMovieFile( &sfFile, &movieResFile, fsRdPerm ) != noErr)
return false;
short movieResID = 0;
Str255 movieName;
- bool result;
err = NewMovieFromFile(
&m_movie,
movieName,
newMovieActive,
NULL); // wasChanged
- result = (err == noErr);
- // No ::GetMoviesStickyError() here because it returns -2009
- // a.k.a. invalid track on valid mpegs
- if (result)
+ // Do not use ::GetMoviesStickyError() here because it returns -2009
+ // a.k.a. invalid track on valid mpegs
+ if (err == noErr && ::GetMoviesError() == noErr)
{
::CloseMovieFile(movieResFile);
// Create movie controller/control
-#if wxUSE_CREATEMOVIECONTROL
- DoCreateMovieControl();
-#else
DoNewMovieController();
-#endif
FinishLoad();
+ return true;
}
- return result;
-}
-
-//---------------------------------------------------------------------------
-// wxQTMediaBackend::PPRMProc (static)
-//
-// Called when done PrePrerolling the movie.
-// Note that in 99% of the cases this does nothing...
-// Anyway we set up the loading timer here to tell us when the movie is done
-//---------------------------------------------------------------------------
-#if !wxUSE_CREATEMOVIECONTROL
-void wxQTMediaBackend::PPRMProc (Movie theMovie,
- OSErr WXUNUSED_UNLESS_DEBUG(theErr),
- void* theRefCon)
-{
- wxASSERT( theMovie );
- wxASSERT( theRefCon );
- wxASSERT( theErr == noErr );
-
- wxQTMediaBackend* pBE = (wxQTMediaBackend*) theRefCon;
-
- long lTime = ::GetMovieTime(theMovie,NULL);
- Fixed rate = ::GetMoviePreferredRate(theMovie);
- ::PrerollMovie(theMovie,lTime,rate);
- pBE->m_timer = new wxQTMediaLoadTimer(pBE->m_movie, pBE);
- pBE->m_timer->Start(MOVIE_DELAY);
+ return false;
}
-#endif
//---------------------------------------------------------------------------
// wxQTMediaBackend::Load (URL Version)
if (m_movie)
Cleanup();
+ ::ClearMoviesStickyError(); // clear previous errors so
+ // GetMoviesStickyError is useful
+
wxString theURI = location.BuildURI();
+ OSErr err;
- OSErr err = noErr;
- bool result;
+ size_t len;
+ const char* theURIString;
+
+#if wxUSE_UNICODE
+ wxCharBuffer buf = wxConvLocal.cWC2MB(theURI, theURI.length(), &len);
+ theURIString = buf;
+#else
+ theURIString = theURI;
+ len = theURI.length();
+#endif
- // FIXME: lurking Unicode problem here
- Handle theHandle = ::NewHandleClear(theURI.length() + 1);
+ Handle theHandle = ::NewHandleClear(len + 1);
wxASSERT(theHandle);
- ::BlockMoveData(theURI.mb_str(), *theHandle, theURI.length() + 1);
+ ::BlockMoveData(theURIString, *theHandle, len + 1);
// create the movie from the handle that refers to the URI
- err = ::NewMovieFromDataRef(&m_movie, newMovieActive |
- newMovieAsyncOK
- /* | newMovieIdleImportOK*/,
- NULL, theHandle,
- URLDataHandlerSubType);
+ err = ::NewMovieFromDataRef(
+ &m_movie,
+ newMovieActive | newMovieAsyncOK /* | newMovieIdleImportOK*/,
+ NULL, theHandle,
+ URLDataHandlerSubType);
::DisposeHandle(theHandle);
- result = (err == noErr);
- if (result)
+ if (err == noErr && ::GetMoviesStickyError() == noErr)
{
-#if wxUSE_CREATEMOVIECONTROL
- // Movie control resets prerolling, so we must create first
- DoCreateMovieControl();
-
- // Setup timer to catch load event
- m_timer = new wxQTMediaLoadTimer(m_movie, this);
- m_timer->Start(MOVIE_DELAY);
-#else
// Movie controller resets prerolling, so we must create first
DoNewMovieController();
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
// 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);
-#endif
- }
+ m_preprerollupp = wxQTMediaBackend::PPRMProc;
+ ::PrePrerollMovie( m_movie, timeNow, playRate,
+ m_preprerollupp, (void*)this);
- return result;
-}
+ return true;
+ }
-//---------------------------------------------------------------------------
-// wxQTMediaBackend::DoCreateMovieControl
-//
-// Calls CreateMovieControl and performs setup related to it
-//
-// Note that we always hide the controller initially becuase when loading
-// from a url it displays about a 40x40 box with the word loading... in it,
-// but the box is outside the range of the control, which is bad (0,0
-// i believe), so we need to wait until finishload to actually display
-// the movie controller in this instance
-//---------------------------------------------------------------------------
-#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
- 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());
-
- // set up MovieController for the new movie
- long 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
- ::MCSetActionFilterWithRefCon(m_mc,
- wxQTMediaBackend::MCFilterProc, (long)this);
+ return false;
}
-#endif
//---------------------------------------------------------------------------
// wxQTMediaBackend::DoNewMovieController
// Attaches movie to moviecontroller or creates moviecontroller
// if not created yet
//---------------------------------------------------------------------------
-#if !wxUSE_CREATEMOVIECONTROL
void wxQTMediaBackend::DoNewMovieController()
{
if (!m_mc)
// Get top level window ref for some mac functions
WindowRef wrTLW = (WindowRef) m_ctrl->MacGetTopLevelWindowRef();
- // MovieController not setup yet:
- // so we need to create a new one.
- // You have to pass a valid movie to
- // NewMovieController, evidently
+ // MovieController not set up yet, so we need to create a new one.
+ // You have to pass a valid movie to NewMovieController, evidently
::SetMovieGWorld(m_movie,
(CGrafPtr) GetWindowPort(wrTLW),
NULL);
mcTopLeftMovie | mcNotVisible /* | mcWithFrame */ );
wxASSERT(::GetMoviesError() == noErr);
- ::MCDoAction(m_mc, 32, (void*)true); //mcActionSetKeysEnabled
+ ::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,
- wxQTMediaBackend::MCFilterProc, (long)this);
+ m_mcactionupp = wxQTMediaBackend::MCFilterProc;
+ ::MCSetActionFilterWithRefCon( m_mc, m_mcactionupp, (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));
- // Event types to catch from the TLW
- // for the moviecontroller
- EventTypeSpec theEventTypes[] =
+ // Create offscreen GWorld for where to "show" when window is hidden
+ Rect worldRect;
+ worldRect.left = worldRect.top = 0;
+ worldRect.right = worldRect.bottom = 1;
+ ::NewGWorld(&m_movieWorld, 0, &worldRect, NULL, NULL, 0);
+
+ // 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...
+ EventTypeSpec theWindowEventTypes[] =
{
{ kEventClassMouse, kEventMouseDown },
{ kEventClassMouse, kEventMouseUp },
+ { kEventClassMouse, kEventMouseDragged },
{ kEventClassKeyboard, kEventRawKeyDown },
{ kEventClassKeyboard, kEventRawKeyRepeat },
{ kEventClassKeyboard, kEventRawKeyUp },
{ 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...
- InstallWindowEventHandler( wrTLW,
- GetwxQTMediaWindowEventHandlerUPP(),
- GetEventTypeCount( theEventTypes ), theEventTypes,
- m_mc, (&(EventHandlerRef&)m_pEventHandlerRef) );
+ m_windowUPP =
+ NewEventHandlerUPP( wxQTMediaBackend::WindowEventHandler );
+ InstallWindowEventHandler(
+ wrTLW,
+ m_windowUPP,
+ GetEventTypeCount( theWindowEventTypes ), theWindowEventTypes,
+ this,
+ &m_windowEventHandler );
}
else
{
thePoint.h = thePoint.v = 0;
::MCSetMovie(m_mc, m_movie,
(WindowRef)m_ctrl->MacGetTopLevelWindowRef(),
- thePoint);
-
+ thePoint);
wxASSERT(::GetMoviesError() == noErr);
}
}
-#endif
//---------------------------------------------------------------------------
// wxQTMediaBackend::FinishLoad
wxASSERT(::GetMoviesError() == noErr);
// start movie progress timer
- m_timer = new wxQTMediaPlayTimer(m_movie, (wxQTMediaBackend*) this);
+ m_timer = new wxQTMediaPlayTimer(this);
wxASSERT(m_timer);
m_timer->Start(MOVIE_DELAY, wxTIMER_CONTINUOUS);
- // send loaded event & refresh size
+ // send loaded event and refresh size
NotifyMovieLoaded();
}
{
// get the real size of the movie
Rect outRect;
- ::GetMovieNaturalBoundsRect (m_movie, &outRect);
+ ::GetMovieNaturalBoundsRect(m_movie, &outRect);
wxASSERT(::GetMoviesError() == noErr);
// determine best size
// wxQTMediaBackend::Play
//
// Start the QT movie
+// (Apple recommends mcActionPrerollAndPlay but that's QT 4.1+)
//---------------------------------------------------------------------------
bool wxQTMediaBackend::Play()
{
if (!m_bPlaying)
::MCDoAction( m_mc, 8 /* mcActionPlay */, (void*) fixRate);
- m_bPlaying = true;
- return ::GetMoviesError() == noErr;
+ bool result = (::GetMoviesError() == noErr);
+ if (result)
+ {
+ m_bPlaying = true;
+ QueuePlayEvent();
+ }
+
+ return result;
}
//---------------------------------------------------------------------------
//
// Stop the movie
//---------------------------------------------------------------------------
-bool wxQTMediaBackend::Pause()
+bool wxQTMediaBackend::DoPause()
{
// 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;
return ::GetMoviesError() == noErr;
}
return true;
}
+bool wxQTMediaBackend::Pause()
+{
+ bool bSuccess = DoPause();
+ if (bSuccess)
+ this->QueuePauseEvent();
+
+ return bSuccess;
+}
+
//---------------------------------------------------------------------------
// wxQTMediaBackend::Stop
//
// 1) Stop the movie
// 2) Seek to the beginning of the movie
//---------------------------------------------------------------------------
-bool wxQTMediaBackend::Stop()
+bool wxQTMediaBackend::DoStop()
{
- if (!wxQTMediaBackend::Pause())
+ if (!wxQTMediaBackend::DoPause())
return false;
::GoToBeginningOfMovie(m_movie);
return ::GetMoviesError() == noErr;
}
+bool wxQTMediaBackend::Stop()
+{
+ bool bSuccess = DoStop();
+ if (bSuccess)
+ QueueStopEvent();
+
+ return bSuccess;
+}
+
//---------------------------------------------------------------------------
// wxQTMediaBackend::GetPlaybackRate
//
return true;
}
- //---------------------------------------------------------------------------
+//---------------------------------------------------------------------------
// wxQTMediaBackend::GetDuration
//
// Calls GetMovieDuration
// combo if implemented that way
if (m_bPlaying)
return wxMEDIASTATE_PLAYING;
- else if ( !m_movie || wxQTMediaBackend::GetPosition() == 0)
+ else if (!m_movie || wxQTMediaBackend::GetPosition() == 0)
return wxMEDIASTATE_STOPPED;
else
return wxMEDIASTATE_PAUSED;
wxQTMediaBackend::Pause();
// 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();
-#else
Point thePoint;
thePoint.h = thePoint.v = 0;
::MCSetVisible(m_mc, false);
::MCSetMovie(m_mc, NULL, NULL, thePoint);
-#endif
::DisposeMovie(m_movie);
m_movie = NULL;
}
-//---------------------------------------------------------------------------
-// wxQTMediaBackend::MCFilterProc (static)
-//
-// Callback for when the movie controller recieves a message
-//---------------------------------------------------------------------------
-Boolean wxQTMediaBackend::MCFilterProc(
- MovieController WXUNUSED(theController),
- short action,
- void * WXUNUSED(params),
- long refCon)
-{
- wxQTMediaBackend* pThis = (wxQTMediaBackend*)refCon;
-
- 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;
-}
-
//---------------------------------------------------------------------------
// wxQTMediaBackend::GetVideoSize
//
//---------------------------------------------------------------------------
// wxQTMediaBackend::Move
//
-// We need to do this even when using native qt control because
-// CreateMovieControl is broken in this regard...
+// Move the movie controller or movie control
+// (we need to actually move the movie control manually...)
+// Top 10 things to do with quicktime in March 93's issue
+// of DEVELOP - very useful
+// http:// www.mactech.com/articles/develop/issue_13/031-033_QuickTime_column.html
+// OLD NOTE: Calling MCSetControllerBoundsRect without detaching
+// supposively resulted in a crash back then. Current code even
+// with CFM classic runs fine. If there is ever a problem,
+// take out the if 0 lines below
//---------------------------------------------------------------------------
void wxQTMediaBackend::Move(int x, int y, int w, int h)
{
-#if !wxUSE_CREATEMOVIECONTROL
if (m_timer)
{
m_ctrl->GetParent()->MacWindowToRootWindow(&x, &y);
- Rect theRect = {y, x, y+h, x+w};
+ Rect theRect = {y, x, y + h, x + w};
+
+#if 0 // see note above
+ ::MCSetControllerAttached(m_mc, false);
+ wxASSERT(::GetMoviesError() == noErr);
+#endif
::MCSetControllerBoundsRect(m_mc, &theRect);
wxASSERT(::GetMoviesError() == noErr);
- }
-#else
- if (m_timer && m_ctrl)
- {
- m_ctrl->GetParent()->MacWindowToRootWindow(&x, &y);
- ::MoveControl( (ControlRef) m_ctrl->GetHandle(), x, y );
- m_ctrl->GetParent()->Refresh();
- m_ctrl->GetParent()->Update();
- }
+#if 0 // see note above
+ if (m_interfaceflags)
+ {
+ ::MCSetVisible(m_mc, true);
+ wxASSERT(::GetMoviesError() == noErr);
+ }
#endif
+ }
}
//---------------------------------------------------------------------------
// Utility function that takes care of showing the moviecontroller
// and showing/hiding the particular controls on it
//---------------------------------------------------------------------------
-void wxQTMediaBackend::DoSetControllerVisible(wxMediaCtrlPlayerControls flags)
+void wxQTMediaBackend::DoSetControllerVisible(
+ wxMediaCtrlPlayerControls flags)
{
::MCSetVisible(m_mc, true);
? 0 : (1 << 1)/*mcFlagSuppressStepButtons*/)
| ((flags & wxMEDIACTRLPLAYERCONTROLS_VOLUME)
? 0 : (1 << 2)/*mcFlagSuppressSpeakerButton*/)
- // | (1 << 4) /*mcFlagDontInvalidate*/ //if we take care of repainting ourselves
+ //if we take care of repainting ourselves
+ // | (1 << 4) /*mcFlagDontInvalidate*/
);
::MCDoAction(m_mc, 38/*mcActionSetFlags*/, (void*)mcFlags);
bool wxQTMediaBackend::ShowPlayerControls(wxMediaCtrlPlayerControls flags)
{
if (!m_mc)
- return false; //no movie controller...
+ return false; // no movie controller...
bool bSizeChanged = false;
DoLoadBestSize();
::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);
{
NotifyMovieSizeChanged();
- //remember state in case of loading new media
+ // remember state in case of loading new media
m_interfaceflags = flags;
}
return ::GetMoviesError() == noErr;
}
+//---------------------------------------------------------------------------
+// wxQTMediaBackend::GetDataSizeFromStart
+//
+// Calls either GetMovieDataSize or GetMovieDataSize64 with a value
+// of 0 for the starting value
+//---------------------------------------------------------------------------
+wxLongLong wxQTMediaBackend::GetDataSizeFromStart(TimeValue end)
+{
+#if 0 // old pre-qt4 way
+ return ::GetMovieDataSize(m_movie, 0, end)
+#else // qt4 way
+ wide llDataSize;
+ ::GetMovieDataSize64(m_movie, 0, end, &llDataSize);
+ return wxLongLong(llDataSize.hi, llDataSize.lo);
+#endif
+}
+
+//---------------------------------------------------------------------------
+// wxQTMediaBackend::GetDownloadProgress
+//---------------------------------------------------------------------------
+wxLongLong wxQTMediaBackend::GetDownloadProgress()
+{
+#if 0 // hackish and slow
+ Handle hMovie = NewHandle(0);
+ PutMovieIntoHandle(m_movie, hMovie);
+ long lSize = GetHandleSize(hMovie);
+ DisposeHandle(hMovie);
+
+ return lSize;
+#else
+ TimeValue tv;
+ if (::GetMaxLoadedTimeInMovie(m_movie, &tv) != noErr)
+ {
+ wxLogDebug(wxT("GetMaxLoadedTimeInMovie failed"));
+ return 0;
+ }
+
+ return wxQTMediaBackend::GetDataSizeFromStart(tv);
+#endif
+}
+
+//---------------------------------------------------------------------------
+// wxQTMediaBackend::GetDownloadTotal
+//---------------------------------------------------------------------------
+wxLongLong wxQTMediaBackend::GetDownloadTotal()
+{
+ return wxQTMediaBackend::GetDataSizeFromStart(
+ ::GetMovieDuration(m_movie)
+ );
+}
+
+//---------------------------------------------------------------------------
+// wxQTMediaBackend::MacVisibilityChanged
+//
+// The main problem here is that Windows quicktime, for example,
+// renders more directly to a HWND. Mac quicktime does not do this
+// and instead renders to the port of the WindowRef/WindowPtr on top
+// of everything else/all other windows.
+//
+// So, for example, if you were to have a CreateTabsControl/wxNotebook
+// and change pages, even if you called HIViewSetVisible/SetControlVisibility
+// directly the movie will still continue playing on top of everything else
+// if you went to a different tab.
+//
+// Note that another issue, and why we call MCSetControllerPort instead
+// of SetMovieGWorld directly, is that in addition to rendering on
+// top of everything else the last created controller steals mouse and
+// other input from everything else in the window, including other
+// controllers. Setting the port of it releases this behaviour.
+//---------------------------------------------------------------------------
+void wxQTMediaBackend::MacVisibilityChanged()
+{
+ if(!m_mc || !m_ctrl->m_bLoaded)
+ return; //not initialized yet
+
+ if(m_ctrl->MacIsReallyShown())
+ {
+ //The window is being shown again, so set the GWorld of the
+ //controller back to the port of the parent WindowRef
+ WindowRef wrTLW =
+ (WindowRef) m_ctrl->MacGetTopLevelWindowRef();
+
+ ::MCSetControllerPort(m_mc, (CGrafPtr) GetWindowPort(wrTLW));
+ wxASSERT(::GetMoviesError() == noErr);
+ }
+ else
+ {
+ //We are being hidden - set the GWorld of the controller
+ //to the offscreen GWorld
+ ::MCSetControllerPort(m_mc, m_movieWorld);
+ wxASSERT(::GetMoviesError() == noErr);
+ }
+}
+
//---------------------------------------------------------------------------
// wxQTMediaBackend::OnEraseBackground
//
// Suggestion from Greg Hazel to repaint the movie when idle
// (on pause also)
//---------------------------------------------------------------------------
-#if !wxUSE_CREATEMOVIECONTROL
void wxQTMediaEvtHandler::OnEraseBackground(wxEraseEvent& evt)
{
- // Work around Nasty OSX drawing bug -
+ // Work around Nasty OSX drawing bug:
// http://lists.apple.com/archives/QuickTime-API/2002/Feb/msg00311.html
- WindowRef wrTLW =
- (WindowRef) m_qtb->m_ctrl->MacGetTopLevelWindowRef();
+ WindowRef wrTLW = (WindowRef) m_qtb->m_ctrl->MacGetTopLevelWindowRef();
- RgnHandle region = MCGetControllerBoundsRgn(m_qtb->m_mc);
- MCInvalidate(m_qtb->m_mc, wrTLW, region);
- MCIdle(m_qtb->m_mc);
+ RgnHandle region = ::MCGetControllerBoundsRgn(m_qtb->m_mc);
+ ::MCInvalidate(m_qtb->m_mc, wrTLW, region);
+ ::MCIdle(m_qtb->m_mc);
}
-#endif
//---------------------------------------------------------------------------
-// wxQTMediaWindowEventHandler
+// wxQTMediaBackend::PPRMProc (static)
+//
+// Called when done PrePrerolling the movie.
+// Note that in 99% of the cases this does nothing...
+// Anyway we set up the loading timer here to tell us when the movie is done
+//---------------------------------------------------------------------------
+pascal void wxQTMediaBackend::PPRMProc(
+ Movie theMovie,
+ OSErr WXUNUSED_UNLESS_DEBUG(theErr),
+ void* theRefCon)
+{
+ wxASSERT( theMovie );
+ wxASSERT( theRefCon );
+ wxASSERT( theErr == noErr );
+
+ wxQTMediaBackend* pBE = (wxQTMediaBackend*) theRefCon;
+
+ long lTime = ::GetMovieTime(theMovie,NULL);
+ Fixed rate = ::GetMoviePreferredRate(theMovie);
+ ::PrerollMovie(theMovie,lTime,rate);
+ pBE->m_timer = new wxQTMediaLoadTimer(pBE);
+ pBE->m_timer->Start(MOVIE_DELAY);
+}
+
+//---------------------------------------------------------------------------
+// wxQTMediaBackend::MCFilterProc (static)
+//
+// Callback for when the movie controller recieves a message
+//---------------------------------------------------------------------------
+pascal Boolean wxQTMediaBackend::MCFilterProc(
+ MovieController WXUNUSED(theController),
+ short action,
+ void * WXUNUSED(params),
+ long refCon)
+{
+ wxQTMediaBackend* pThis = (wxQTMediaBackend*)refCon;
+
+ 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;
+}
+
+//---------------------------------------------------------------------------
+// wxQTMediaBackend::WindowEventHandler [static]
//
// Event callback for the top level window of our control that passes
-// messages to our moviecontroller so it can recieve mouse clicks etc.
+// messages to our moviecontroller so it can receive mouse clicks etc.
//---------------------------------------------------------------------------
-#if !wxUSE_CREATEMOVIECONTROL
-OSStatus wxQTMediaWindowEventHandler(
+pascal OSStatus wxQTMediaBackend::WindowEventHandler(
EventHandlerCallRef inHandlerCallRef,
- EventRef inEvent, void *inUserData)
+ EventRef inEvent,
+ void *inUserData)
{
+ wxQTMediaBackend* be = (wxQTMediaBackend*) inUserData;
+
+ // Only process keyboard messages on this window if it actually
+ // has focus, otherwise it will steal keystrokes from other windows!
+ // As well as when it is not loaded properly as it
+ // will crash in MCIsPlayerEvent
+ if((GetEventClass(inEvent) == kEventClassKeyboard &&
+ wxWindow::FindFocus() != be->m_ctrl)
+ || !be->m_ctrl->m_bLoaded)
+ return eventNotHandledErr;
+
+ // Pass the event onto the movie controller
EventRecord theEvent;
ConvertEventRefToEventRecord( inEvent, &theEvent );
OSStatus err;
- err = ::MCIsPlayerEvent( (MovieController) inUserData, &theEvent );
- // pass on to other event handlers if not handled- i.e. wx
+ // TODO: Apple says MCIsPlayerEvent is depreciated and
+ // MCClick, MCKey, MCIdle etc. should be used
+ // (RN: Of course that's what they say about
+ // CreateMovieControl and HIMovieView as well, LOL!)
+ err = ::MCIsPlayerEvent( be->m_mc, &theEvent );
+
+ // Pass on to other event handlers if not handled- i.e. wx
if (err != noErr)
return noErr;
else
return eventNotHandledErr;
}
+
#endif
// in source file that contains stuff you don't directly use
projects / wxWidgets.git / blobdiff