]> git.saurik.com Git - wxWidgets.git/blame - src/mac/carbon/mediactrl.cpp
forward port from 2.8
[wxWidgets.git] / src / mac / carbon / mediactrl.cpp
CommitLineData
1a680109 1/////////////////////////////////////////////////////////////////////////////
987e9419 2// Name: src/mac/carbon/mediactrl.cpp
ff4aedc5 3// Purpose: Built-in Media Backends for Mac
1a680109 4// Author: Ryan Norton <wxprojects@comcast.net>
ff4aedc5 5// Modified by:
1a680109
RN
6// Created: 11/07/04
7// RCS-ID: $Id$
0c81ef7f 8// Copyright: (c) 2004-2006 Ryan Norton
1a680109
RN
9// Licence: wxWindows licence
10/////////////////////////////////////////////////////////////////////////////
11
bf354396 12//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
0c81ef7f
SC
13// OK, a casual overseer of this file may wonder why we don't use
14// either CreateMovieControl or HIMovieView...
557002cf 15//
0c81ef7f
SC
16// CreateMovieControl
17// 1) Need to dispose and create each time a new movie is loaded
18// 2) Not that many real advantages
19// 3) Progressively buggier in higher OSX versions
20// (see main.c of QTCarbonShell sample for details)
21// HIMovieView
22// 1) Crashes on destruction in ALL cases on quite a few systems!
23// (With the only real "alternative" is to simply not
24// dispose of it and let it leak...)
25// 2) Massive refreshing bugs with its movie controller between
26// movies
557002cf 27//
0c81ef7f
SC
28// At one point we had a complete implementation for CreateMovieControl
29// and on my (RN) local copy I had one for HIMovieView - but they
30// were simply deemed to be too buggy/unuseful. HIMovieView could
31// have been useful as well because it uses OpenGL contexts instead
32// of GWorlds. Perhaps someday when someone comes out with some
33// ingenious workarounds :).
bf354396
VZ
34//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
35
1a680109
RN
36// For compilers that support precompilation, includes "wx.h".
37#include "wx/wxprec.h"
38
987e9419
WS
39#if wxUSE_MEDIACTRL
40
ff4aedc5 41#include "wx/mediactrl.h"
1a680109 42
987e9419
WS
43#ifndef WX_PRECOMP
44 #include "wx/log.h"
c0badb70 45 #include "wx/timer.h"
987e9419
WS
46#endif
47
9419b0d6
DS
48// uma is for wxMacFSSpec
49#include "wx/mac/uma.h"
9419b0d6 50
9419b0d6 51// standard QT stuff
0c81ef7f 52#ifndef __DARWIN__
9419b0d6
DS
53#include <Movies.h>
54#include <Gestalt.h>
55#include <QuickTimeComponents.h>
56#else
57#include <QuickTime/QuickTimeComponents.h>
58#endif
59
3b5023b9 60//---------------------------------------------------------------------------
0c81ef7f 61// Height and Width of movie controller in the movie control (apple samples)
bf354396
VZ
62//---------------------------------------------------------------------------
63#define wxMCWIDTH 320
64#define wxMCHEIGHT 16
65
ff4aedc5
RN
66//===========================================================================
67// BACKEND DECLARATIONS
68//===========================================================================
212945de 69
ff4aedc5 70//---------------------------------------------------------------------------
ff4aedc5 71// wxQTMediaBackend
ff4aedc5 72//---------------------------------------------------------------------------
1a680109 73
bf354396 74class WXDLLIMPEXP_MEDIA wxQTMediaBackend : public wxMediaBackendCommonBase
ff4aedc5
RN
75{
76public:
ff4aedc5 77 wxQTMediaBackend();
d3c7fc99 78 virtual ~wxQTMediaBackend();
ff4aedc5 79
d0ee33f5 80 virtual bool CreateControl(wxControl* ctrl, wxWindow* parent,
ff4aedc5 81 wxWindowID id,
d0ee33f5 82 const wxPoint& pos,
ff4aedc5 83 const wxSize& size,
d0ee33f5 84 long style,
ff4aedc5
RN
85 const wxValidator& validator,
86 const wxString& name);
87
0c81ef7f
SC
88 virtual bool Load(const wxString& fileName);
89 virtual bool Load(const wxURI& location);
90
ff4aedc5
RN
91 virtual bool Play();
92 virtual bool Pause();
93 virtual bool Stop();
94
ff4aedc5
RN
95 virtual wxMediaState GetState();
96
97 virtual bool SetPosition(wxLongLong where);
98 virtual wxLongLong GetPosition();
99 virtual wxLongLong GetDuration();
100
101 virtual void Move(int x, int y, int w, int h);
102 wxSize GetVideoSize() const;
103
104 virtual double GetPlaybackRate();
105 virtual bool SetPlaybackRate(double dRate);
106
c5191fbd
VZ
107 virtual double GetVolume();
108 virtual bool SetVolume(double);
109
ff4aedc5
RN
110 void Cleanup();
111 void FinishLoad();
112
bf354396 113 virtual bool ShowPlayerControls(wxMediaCtrlPlayerControls flags);
9419b0d6 114
557002cf
VZ
115 virtual wxLongLong GetDownloadProgress();
116 virtual wxLongLong GetDownloadTotal();
bf354396 117
0c81ef7f
SC
118 virtual void MacVisibilityChanged();
119
557002cf 120 //
bf354396 121 // ------ Implementation from now on --------
557002cf
VZ
122 //
123 bool DoPause();
124 bool DoStop();
592a247d 125
bf354396
VZ
126 void DoLoadBestSize();
127 void DoSetControllerVisible(wxMediaCtrlPlayerControls flags);
128
557002cf
VZ
129 wxLongLong GetDataSizeFromStart(TimeValue end);
130
0c81ef7f
SC
131 Boolean IsQuickTime4Installed();
132 void DoNewMovieController();
133
134 static pascal void PPRMProc(
135 Movie theMovie, OSErr theErr, void* theRefCon);
136
bf354396 137 //TODO: Last param actually long - does this work on 64bit machines?
9419b0d6 138 static pascal Boolean MCFilterProc(MovieController theController,
bf354396
VZ
139 short action, void *params, long refCon);
140
0c81ef7f
SC
141 static pascal OSStatus WindowEventHandler(
142 EventHandlerCallRef inHandlerCallRef,
143 EventRef inEvent, void *inUserData );
bf354396
VZ
144
145 wxSize m_bestSize; // Original movie size
bf354396 146 Movie m_movie; // Movie instance
bf354396
VZ
147 bool m_bPlaying; // Whether media is playing or not
148 class wxTimer* m_timer; // Timer for streaming the movie
149 MovieController m_mc; // MovieController instance
150 wxMediaCtrlPlayerControls m_interfaceflags; // Saved interface flags
9419b0d6 151
0c81ef7f 152 // Event handlers and UPPs/Callbacks
987e9419 153 EventHandlerRef m_windowEventHandler;
0c81ef7f
SC
154 EventHandlerUPP m_windowUPP;
155
557002cf 156 MoviePrePrerollCompleteUPP m_preprerollupp;
557002cf 157 MCActionFilterWithRefConUPP m_mcactionupp;
ff4aedc5 158
987e9419 159 GWorldPtr m_movieWorld; //Offscreen movie GWorld
0c81ef7f 160
bf354396 161 friend class wxQTMediaEvtHandler;
9419b0d6 162
d0ee33f5 163 DECLARE_DYNAMIC_CLASS(wxQTMediaBackend)
ff4aedc5
RN
164};
165
bf354396
VZ
166// helper to hijack background erasing for the QT window
167class WXDLLIMPEXP_MEDIA wxQTMediaEvtHandler : public wxEvtHandler
168{
169public:
170 wxQTMediaEvtHandler(wxQTMediaBackend *qtb)
171 {
172 m_qtb = qtb;
173
9419b0d6
DS
174 qtb->m_ctrl->Connect(
175 qtb->m_ctrl->GetId(), wxEVT_ERASE_BACKGROUND,
bf354396
VZ
176 wxEraseEventHandler(wxQTMediaEvtHandler::OnEraseBackground),
177 NULL, this);
178 }
179
180 void OnEraseBackground(wxEraseEvent& event);
181
182private:
183 wxQTMediaBackend *m_qtb;
184
185 DECLARE_NO_COPY_CLASS(wxQTMediaEvtHandler)
186};
187
bf354396
VZ
188//===========================================================================
189// IMPLEMENTATION
190//===========================================================================
191
ff4aedc5
RN
192
193//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
0c81ef7f 194//
ff4aedc5 195// wxQTMediaBackend
0c81ef7f 196//
ff4aedc5
RN
197//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
198
412e0d47 199IMPLEMENT_DYNAMIC_CLASS(wxQTMediaBackend, wxMediaBackend)
1a680109 200
bf354396
VZ
201//Time between timer calls - this is the Apple recommondation to the TCL
202//team I believe
203#define MOVIE_DELAY 20
1a680109 204
bf354396
VZ
205//---------------------------------------------------------------------------
206// wxQTMediaLoadTimer
207//
208// QT, esp. QT for Windows is very picky about how you go about
209// async loading. If you were to go through a Windows message loop
210// or a MoviesTask or both and then check the movie load state
211// it would still return 1000 (loading)... even (pre)prerolling doesn't
212// help. However, making a load timer like this works
213//---------------------------------------------------------------------------
214class wxQTMediaLoadTimer : public wxTimer
1a680109
RN
215{
216public:
0c81ef7f
SC
217 wxQTMediaLoadTimer(wxQTMediaBackend* parent) :
218 m_parent(parent) {}
1a680109 219
bf354396
VZ
220 void Notify()
221 {
bf354396 222 ::MCIdle(m_parent->m_mc);
9419b0d6
DS
223
224 // kMovieLoadStatePlayable is not enough on MAC:
225 // it plays, but IsMovieDone might return true (!)
226 // sure we need to wait until kMovieLoadStatePlaythroughOK
0c81ef7f 227 if (::GetMovieLoadState(m_parent->m_movie) >= 20000)
9419b0d6 228 {
bf354396
VZ
229 m_parent->FinishLoad();
230 delete this;
9419b0d6 231 }
1a680109
RN
232 }
233
bf354396 234protected:
9419b0d6 235 wxQTMediaBackend *m_parent; // Backend pointer
bf354396
VZ
236};
237
238// --------------------------------------------------------------------------
239// wxQTMediaPlayTimer - Handle Asyncronous Playing
240//
241// 1) Checks to see if the movie is done, and if not continues
242// streaming the movie
243// 2) Sends the wxEVT_MEDIA_STOP event if we have reached the end of
244// the movie.
245// --------------------------------------------------------------------------
246class wxQTMediaPlayTimer : public wxTimer
247{
248public:
0c81ef7f
SC
249 wxQTMediaPlayTimer(wxQTMediaBackend* parent) :
250 m_parent(parent) {}
1a680109
RN
251
252 void Notify()
9419b0d6 253 {
bf354396
VZ
254 //
255 // OK, a little explaining - basically originally
256 // we only called MoviesTask if the movie was actually
257 // playing (not paused or stopped)... this was before
258 // we realized MoviesTask actually handles repainting
259 // of the current frame - so if you were to resize
260 // or something it would previously not redraw that
261 // portion of the movie.
262 //
263 // So now we call MoviesTask always so that it repaints
264 // correctly.
265 //
266 ::MCIdle(m_parent->m_mc);
ff4aedc5 267
0c81ef7f 268 //
bf354396
VZ
269 // Handle the stop event - if the movie has reached
270 // the end, notify our handler
0c81ef7f
SC
271 //
272 if (::IsMovieDone(m_parent->m_movie))
9419b0d6 273 {
bf354396
VZ
274 if ( m_parent->SendStopEvent() )
275 {
ff4aedc5
RN
276 m_parent->Stop();
277 wxASSERT(::GetMoviesError() == noErr);
278
bf354396 279 m_parent->QueueFinishEvent();
1a680109
RN
280 }
281 }
282 }
283
284protected:
9419b0d6 285 wxQTMediaBackend* m_parent; // Backend pointer
1a680109
RN
286};
287
bf354396 288
ff4aedc5 289//---------------------------------------------------------------------------
e7b97da3 290// wxQTMediaBackend Constructor
ff4aedc5
RN
291//
292// Sets m_timer to NULL signifying we havn't loaded anything yet
293//---------------------------------------------------------------------------
9419b0d6 294wxQTMediaBackend::wxQTMediaBackend()
bf354396
VZ
295 : m_movie(NULL), m_bPlaying(false), m_timer(NULL)
296 , m_mc(NULL), m_interfaceflags(wxMEDIACTRLPLAYERCONTROLS_NONE)
0c81ef7f 297 , m_preprerollupp(NULL), m_movieWorld(NULL)
1a680109 298{
1a680109
RN
299}
300
ff4aedc5
RN
301//---------------------------------------------------------------------------
302// wxQTMediaBackend Destructor
303//
304// 1) Cleans up the QuickTime movie instance
305// 2) Decrements the QuickTime reference counter - if this reaches
306// 0, QuickTime shuts down
307// 3) Decrements the QuickTime Windows Media Layer reference counter -
308// if this reaches 0, QuickTime shuts down the Windows Media Layer
309//---------------------------------------------------------------------------
310wxQTMediaBackend::~wxQTMediaBackend()
1a680109 311{
9419b0d6 312 if (m_movie)
ff4aedc5 313 Cleanup();
1a680109 314
bf354396 315 // Cleanup for moviecontroller
9419b0d6 316 if (m_mc)
bf354396
VZ
317 {
318 // destroy wxQTMediaEvtHandler we pushed on it
319 m_ctrl->PopEventHandler(true);
0c81ef7f
SC
320 RemoveEventHandler(m_windowEventHandler);
321 DisposeEventHandlerUPP(m_windowUPP);
557002cf
VZ
322
323 // Dispose of the movie controller
bf354396 324 ::DisposeMovieController(m_mc);
0c81ef7f 325 m_mc = NULL;
3e7f4432 326
0c81ef7f
SC
327 // Dispose of offscreen GWorld
328 ::DisposeGWorld(m_movieWorld);
bf354396 329 }
bf354396 330
9419b0d6 331 // Note that ExitMovies() is not necessary...
ff4aedc5 332 ExitMovies();
1a680109
RN
333}
334
ff4aedc5
RN
335//---------------------------------------------------------------------------
336// wxQTMediaBackend::CreateControl
337//
338// 1) Intializes QuickTime
339// 2) Creates the control window
340//---------------------------------------------------------------------------
9419b0d6
DS
341bool wxQTMediaBackend::CreateControl(
342 wxControl* ctrl,
343 wxWindow* parent,
344 wxWindowID id,
345 const wxPoint& pos,
346 const wxSize& size,
347 long style,
348 const wxValidator& validator,
349 const wxString& name)
1a680109 350{
bf354396 351 if (!IsQuickTime4Installed())
1a680109 352 return false;
1a680109 353
ff4aedc5
RN
354 EnterMovies();
355
0c81ef7f
SC
356 wxMediaCtrl* mediactrl = (wxMediaCtrl*)ctrl;
357
358 //
ff4aedc5
RN
359 // Create window
360 // By default wxWindow(s) is created with a border -
361 // so we need to get rid of those
362 //
363 // Since we don't have a child window like most other
364 // backends, we don't need wxCLIP_CHILDREN
0c81ef7f
SC
365 //
366 if ( !mediactrl->wxControl::Create(
9419b0d6
DS
367 parent, id, pos, size,
368 wxWindow::MacRemoveBordersFromStyle(style),
369 validator, name))
370 {
1a680109 371 return false;
9419b0d6 372 }
1a680109 373
ecd20d4a 374#if wxUSE_VALIDATORS
0c81ef7f 375 mediactrl->SetValidator(validator);
ecd20d4a
RN
376#endif
377
0c81ef7f 378 m_ctrl = mediactrl;
1a680109
RN
379 return true;
380}
381
bf354396
VZ
382//---------------------------------------------------------------------------
383// wxQTMediaBackend::IsQuickTime4Installed
384//
9419b0d6
DS
385// Determines whether version 4 of QT is installed
386// (Pretty much for Classic only)
bf354396 387//---------------------------------------------------------------------------
bf354396
VZ
388Boolean wxQTMediaBackend::IsQuickTime4Installed()
389{
9419b0d6 390 OSErr error;
bf354396
VZ
391 long result;
392
9419b0d6 393 error = Gestalt(gestaltQuickTime, &result);
bf354396
VZ
394 return (error == noErr) && (((result >> 16) & 0xffff) >= 0x0400);
395}
bf354396 396
ff4aedc5
RN
397//---------------------------------------------------------------------------
398// wxQTMediaBackend::Load (file version)
399//
400// 1) Get an FSSpec from the Windows path name
401// 2) Open the movie
402// 3) Obtain the movie instance from the movie resource
3b5023b9
RN
403// 4) Close the movie resource
404// 5) Finish loading
ff4aedc5
RN
405//---------------------------------------------------------------------------
406bool wxQTMediaBackend::Load(const wxString& fileName)
1a680109 407{
9419b0d6 408 if (m_movie)
1a680109
RN
409 Cleanup();
410
987e9419 411 ::ClearMoviesStickyError(); // clear previous errors so
0c81ef7f 412 // GetMoviesStickyError is useful
987e9419 413
1a680109
RN
414 OSErr err = noErr;
415 short movieResFile;
416 FSSpec sfFile;
d0ee33f5 417
9419b0d6
DS
418 wxMacFilename2FSSpec( fileName, &sfFile );
419 if (OpenMovieFile( &sfFile, &movieResFile, fsRdPerm ) != noErr)
1a680109
RN
420 return false;
421
422 short movieResID = 0;
423 Str255 movieName;
557002cf 424
9419b0d6
DS
425 err = NewMovieFromFile(
426 &m_movie,
427 movieResFile,
428 &movieResID,
429 movieName,
430 newMovieActive,
431 NULL); // wasChanged
557002cf 432
b20907ef
KO
433 // Do not use ::GetMoviesStickyError() here because it returns -2009
434 // a.k.a. invalid track on valid mpegs
435 if (err == noErr && ::GetMoviesError() == noErr)
bf354396 436 {
9419b0d6 437 ::CloseMovieFile(movieResFile);
1a680109 438
bf354396 439 // Create movie controller/control
bf354396 440 DoNewMovieController();
9419b0d6
DS
441
442 FinishLoad();
0c81ef7f 443 return true;
bf354396 444 }
9419b0d6 445
0c81ef7f 446 return false;
bf354396 447}
1a680109 448
ff4aedc5 449//---------------------------------------------------------------------------
3b5023b9 450// wxQTMediaBackend::Load (URL Version)
ff4aedc5 451//
3b5023b9
RN
452// 1) Build an escaped URI from location
453// 2) Create a handle to store the URI string
454// 3) Put the URI string inside the handle
455// 4) Make a QuickTime URL data ref from the handle with the URI in it
456// 5) Clean up the URI string handle
457// 6) Do some prerolling
458// 7) Finish Loading
ff4aedc5
RN
459//---------------------------------------------------------------------------
460bool wxQTMediaBackend::Load(const wxURI& location)
1a680109 461{
9419b0d6 462 if (m_movie)
1a680109
RN
463 Cleanup();
464
987e9419 465 ::ClearMoviesStickyError(); // clear previous errors so
0c81ef7f
SC
466 // GetMoviesStickyError is useful
467
1a680109 468 wxString theURI = location.BuildURI();
0c81ef7f 469 OSErr err;
1a680109 470
0c81ef7f
SC
471 size_t len;
472 const char* theURIString;
473
474#if wxUSE_UNICODE
475 wxCharBuffer buf = wxConvLocal.cWC2MB(theURI, theURI.length(), &len);
476 theURIString = buf;
477#else
478 theURIString = theURI;
479 len = theURI.length();
480#endif
1a680109 481
0c81ef7f 482 Handle theHandle = ::NewHandleClear(len + 1);
1a680109
RN
483 wxASSERT(theHandle);
484
0c81ef7f 485 ::BlockMoveData(theURIString, *theHandle, len + 1);
1a680109 486
9419b0d6
DS
487 // create the movie from the handle that refers to the URI
488 err = ::NewMovieFromDataRef(
489 &m_movie,
490 newMovieActive | newMovieAsyncOK /* | newMovieIdleImportOK*/,
491 NULL, theHandle,
492 URLDataHandlerSubType);
1a680109 493
bf354396 494 ::DisposeHandle(theHandle);
1a680109 495
0c81ef7f 496 if (err == noErr && ::GetMoviesStickyError() == noErr)
bf354396 497 {
9419b0d6 498 // Movie controller resets prerolling, so we must create first
bf354396 499 DoNewMovieController();
9419b0d6 500
bf354396 501 long timeNow;
9419b0d6 502 Fixed playRate;
1a680109 503
bf354396
VZ
504 timeNow = ::GetMovieTime(m_movie, NULL);
505 wxASSERT(::GetMoviesError() == noErr);
1a680109 506
bf354396
VZ
507 playRate = ::GetMoviePreferredRate(m_movie);
508 wxASSERT(::GetMoviesError() == noErr);
509
0c81ef7f 510 //
bf354396
VZ
511 // Note that the callback here is optional,
512 // but without it PrePrerollMovie can be buggy
513 // (see Apple ml). Also, some may wonder
514 // why we need this at all - this is because
515 // Apple docs say QuickTime streamed movies
516 // require it if you don't use a Movie Controller,
517 // which we don't by default.
518 //
3e7f4432 519 m_preprerollupp = wxQTMediaBackend::PPRMProc;
987e9419 520 ::PrePrerollMovie( m_movie, timeNow, playRate,
0c81ef7f 521 m_preprerollupp, (void*)this);
9419b0d6 522
0c81ef7f
SC
523 return true;
524 }
1a680109 525
0c81ef7f 526 return false;
bf354396 527}
bf354396
VZ
528
529//---------------------------------------------------------------------------
530// wxQTMediaBackend::DoNewMovieController
531//
532// Attaches movie to moviecontroller or creates moviecontroller
533// if not created yet
534//---------------------------------------------------------------------------
bf354396
VZ
535void wxQTMediaBackend::DoNewMovieController()
536{
9419b0d6 537 if (!m_mc)
bf354396
VZ
538 {
539 // Get top level window ref for some mac functions
540 WindowRef wrTLW = (WindowRef) m_ctrl->MacGetTopLevelWindowRef();
9419b0d6
DS
541
542 // MovieController not set up yet, so we need to create a new one.
543 // You have to pass a valid movie to NewMovieController, evidently
bf354396
VZ
544 ::SetMovieGWorld(m_movie,
545 (CGrafPtr) GetWindowPort(wrTLW),
546 NULL);
547 wxASSERT(::GetMoviesError() == noErr);
548
9419b0d6
DS
549 Rect bounds = wxMacGetBoundsForControl(
550 m_ctrl,
551 m_ctrl->GetPosition(),
552 m_ctrl->GetSize());
bf354396 553
9419b0d6
DS
554 m_mc = ::NewMovieController(
555 m_movie, &bounds,
556 mcTopLeftMovie | mcNotVisible /* | mcWithFrame */ );
bf354396 557 wxASSERT(::GetMoviesError() == noErr);
9419b0d6
DS
558
559 ::MCDoAction(m_mc, 32, (void*)true); // mcActionSetKeysEnabled
bf354396
VZ
560 wxASSERT(::GetMoviesError() == noErr);
561
562 // Setup a callback so we can tell when the user presses
563 // play on the player controls
3e7f4432 564 m_mcactionupp = wxQTMediaBackend::MCFilterProc;
9419b0d6 565 ::MCSetActionFilterWithRefCon( m_mc, m_mcactionupp, (long)this );
bf354396
VZ
566 wxASSERT(::GetMoviesError() == noErr);
567
9419b0d6 568 // Part of a suggestion from Greg Hazel to repaint movie when idle
bf354396 569 m_ctrl->PushEventHandler(new wxQTMediaEvtHandler(this));
9419b0d6 570
0c81ef7f
SC
571 // Create offscreen GWorld for where to "show" when window is hidden
572 Rect worldRect;
573 worldRect.left = worldRect.top = 0;
574 worldRect.right = worldRect.bottom = 1;
575 ::NewGWorld(&m_movieWorld, 0, &worldRect, NULL, NULL, 0);
576
577 // Catch window messages:
578 // if we do not do this and if the user clicks the play
579 // button on the controller, for instance, nothing will happen...
580 EventTypeSpec theWindowEventTypes[] =
9419b0d6
DS
581 {
582 { kEventClassMouse, kEventMouseDown },
583 { kEventClassMouse, kEventMouseUp },
584 { kEventClassMouse, kEventMouseDragged },
585 { kEventClassKeyboard, kEventRawKeyDown },
586 { kEventClassKeyboard, kEventRawKeyRepeat },
587 { kEventClassKeyboard, kEventRawKeyUp },
588 { kEventClassWindow, kEventWindowUpdate },
589 { kEventClassWindow, kEventWindowActivated },
590 { kEventClassWindow, kEventWindowDeactivated }
591 };
987e9419 592 m_windowUPP =
0c81ef7f 593 NewEventHandlerUPP( wxQTMediaBackend::WindowEventHandler );
9419b0d6
DS
594 InstallWindowEventHandler(
595 wrTLW,
0c81ef7f
SC
596 m_windowUPP,
597 GetEventTypeCount( theWindowEventTypes ), theWindowEventTypes,
987e9419 598 this,
0c81ef7f 599 &m_windowEventHandler );
bf354396
VZ
600 }
601 else
602 {
9419b0d6 603 // MovieController already created:
bf354396
VZ
604 // Just change the movie in it and we're good to go
605 Point thePoint;
606 thePoint.h = thePoint.v = 0;
9419b0d6 607 ::MCSetMovie(m_mc, m_movie,
bf354396 608 (WindowRef)m_ctrl->MacGetTopLevelWindowRef(),
9419b0d6 609 thePoint);
bf354396 610 wxASSERT(::GetMoviesError() == noErr);
1a680109 611 }
bf354396 612}
bf354396
VZ
613
614//---------------------------------------------------------------------------
615// wxQTMediaBackend::FinishLoad
616//
617// Performs operations after a movie ready to play/loaded.
618//---------------------------------------------------------------------------
619void wxQTMediaBackend::FinishLoad()
9419b0d6 620{
bf354396
VZ
621 // get the real size of the movie
622 DoLoadBestSize();
623
9419b0d6
DS
624 // show the player controls if the user wants to
625 if (m_interfaceflags)
bf354396 626 DoSetControllerVisible(m_interfaceflags);
1a680109 627
9419b0d6 628 // we want millisecond precision
1a680109 629 ::SetMovieTimeScale(m_movie, 1000);
ff4aedc5
RN
630 wxASSERT(::GetMoviesError() == noErr);
631
9419b0d6 632 // start movie progress timer
0c81ef7f 633 m_timer = new wxQTMediaPlayTimer(this);
bf354396
VZ
634 wxASSERT(m_timer);
635 m_timer->Start(MOVIE_DELAY, wxTIMER_CONTINUOUS);
636
9419b0d6 637 // send loaded event and refresh size
bf354396
VZ
638 NotifyMovieLoaded();
639}
640
641//---------------------------------------------------------------------------
642// wxQTMediaBackend::DoLoadBestSize
643//
644// Sets the best size of the control from the real size of the movie
645//---------------------------------------------------------------------------
646void wxQTMediaBackend::DoLoadBestSize()
647{
9419b0d6 648 // get the real size of the movie
bf354396 649 Rect outRect;
9419b0d6 650 ::GetMovieNaturalBoundsRect(m_movie, &outRect);
bf354396
VZ
651 wxASSERT(::GetMoviesError() == noErr);
652
9419b0d6 653 // determine best size
bf354396
VZ
654 m_bestSize.x = outRect.right - outRect.left;
655 m_bestSize.y = outRect.bottom - outRect.top;
1a680109
RN
656}
657
ff4aedc5 658//---------------------------------------------------------------------------
e7b97da3 659// wxQTMediaBackend::Play
ff4aedc5 660//
bf354396 661// Start the QT movie
557002cf 662// (Apple recommends mcActionPrerollAndPlay but that's QT 4.1+)
ff4aedc5
RN
663//---------------------------------------------------------------------------
664bool wxQTMediaBackend::Play()
1a680109 665{
bf354396 666 Fixed fixRate = (Fixed) (wxQTMediaBackend::GetPlaybackRate() * 0x10000);
9419b0d6 667 if (!fixRate)
bf354396 668 fixRate = ::GetMoviePreferredRate(m_movie);
9419b0d6 669
bf354396
VZ
670 wxASSERT(fixRate != 0);
671
9419b0d6
DS
672 if (!m_bPlaying)
673 ::MCDoAction( m_mc, 8 /* mcActionPlay */, (void*) fixRate);
557002cf 674
9419b0d6
DS
675 bool result = (::GetMoviesError() == noErr);
676 if (result)
557002cf 677 {
9419b0d6 678 m_bPlaying = true;
557002cf 679 QueuePlayEvent();
557002cf 680 }
9419b0d6
DS
681
682 return result;
1a680109
RN
683}
684
ff4aedc5 685//---------------------------------------------------------------------------
e7b97da3 686// wxQTMediaBackend::Pause
ff4aedc5 687//
bf354396 688// Stop the movie
ff4aedc5 689//---------------------------------------------------------------------------
557002cf 690bool wxQTMediaBackend::DoPause()
1a680109 691{
9419b0d6
DS
692 // Stop the movie A.K.A. ::StopMovie(m_movie);
693 if (m_bPlaying)
bf354396 694 {
9419b0d6 695 ::MCDoAction( m_mc, 8 /*mcActionPlay*/, (void *) 0);
bf354396 696 m_bPlaying = false;
9419b0d6 697 return ::GetMoviesError() == noErr;
bf354396 698 }
9419b0d6
DS
699
700 // already paused
701 return true;
557002cf 702}
592a247d 703
557002cf
VZ
704bool wxQTMediaBackend::Pause()
705{
706 bool bSuccess = DoPause();
9419b0d6 707 if (bSuccess)
557002cf 708 this->QueuePauseEvent();
9419b0d6
DS
709
710 return bSuccess;
1a680109
RN
711}
712
ff4aedc5 713//---------------------------------------------------------------------------
e7b97da3 714// wxQTMediaBackend::Stop
ff4aedc5 715//
3b5023b9 716// 1) Stop the movie
bf354396 717// 2) Seek to the beginning of the movie
ff4aedc5 718//---------------------------------------------------------------------------
4ac483eb 719bool wxQTMediaBackend::DoStop()
1a680109 720{
4ac483eb 721 if (!wxQTMediaBackend::DoPause())
1a680109 722 return false;
d0ee33f5 723
1a680109
RN
724 ::GoToBeginningOfMovie(m_movie);
725 return ::GetMoviesError() == noErr;
726}
727
557002cf
VZ
728bool wxQTMediaBackend::Stop()
729{
730 bool bSuccess = DoStop();
9419b0d6 731 if (bSuccess)
557002cf 732 QueueStopEvent();
9419b0d6
DS
733
734 return bSuccess;
557002cf
VZ
735}
736
ff4aedc5 737//---------------------------------------------------------------------------
e7b97da3 738// wxQTMediaBackend::GetPlaybackRate
ff4aedc5 739//
3b5023b9 740// 1) Get the movie playback rate from ::GetMovieRate
ff4aedc5
RN
741//---------------------------------------------------------------------------
742double wxQTMediaBackend::GetPlaybackRate()
1a680109 743{
1a680109
RN
744 return ( ((double)::GetMovieRate(m_movie)) / 0x10000);
745}
746
ff4aedc5 747//---------------------------------------------------------------------------
e7b97da3 748// wxQTMediaBackend::SetPlaybackRate
ff4aedc5 749//
3b5023b9 750// 1) Convert dRate to Fixed and Set the movie rate through SetMovieRate
ff4aedc5
RN
751//---------------------------------------------------------------------------
752bool wxQTMediaBackend::SetPlaybackRate(double dRate)
1a680109 753{
1a680109
RN
754 ::SetMovieRate(m_movie, (Fixed) (dRate * 0x10000));
755 return ::GetMoviesError() == noErr;
756}
757
ff4aedc5 758//---------------------------------------------------------------------------
e7b97da3 759// wxQTMediaBackend::SetPosition
ff4aedc5 760//
3b5023b9
RN
761// 1) Create a time record struct (TimeRecord) with appropriate values
762// 2) Pass struct to SetMovieTime
ff4aedc5
RN
763//---------------------------------------------------------------------------
764bool wxQTMediaBackend::SetPosition(wxLongLong where)
1a680109 765{
1a680109
RN
766 TimeRecord theTimeRecord;
767 memset(&theTimeRecord, 0, sizeof(TimeRecord));
ff4aedc5 768 theTimeRecord.value.lo = where.GetValue();
1a680109
RN
769 theTimeRecord.scale = ::GetMovieTimeScale(m_movie);
770 theTimeRecord.base = ::GetMovieTimeBase(m_movie);
771 ::SetMovieTime(m_movie, &theTimeRecord);
772
773 if (::GetMoviesError() != noErr)
774 return false;
775
776 return true;
777}
778
ff4aedc5 779//---------------------------------------------------------------------------
e7b97da3 780// wxQTMediaBackend::GetPosition
ff4aedc5 781//
3b5023b9 782// Calls GetMovieTime
ff4aedc5
RN
783//---------------------------------------------------------------------------
784wxLongLong wxQTMediaBackend::GetPosition()
1a680109 785{
1a680109
RN
786 return ::GetMovieTime(m_movie, NULL);
787}
788
ff4aedc5 789//---------------------------------------------------------------------------
c5191fbd
VZ
790// wxQTMediaBackend::GetVolume
791//
792// Gets the volume through GetMovieVolume - which returns a 16 bit short -
793//
794// +--------+--------+
795// + (1) + (2) +
796// +--------+--------+
797//
798// (1) first 8 bits are value before decimal
799// (2) second 8 bits are value after decimal
800//
801// Volume ranges from -1.0 (gain but no sound), 0 (no sound and no gain) to
802// 1 (full gain and sound)
803//---------------------------------------------------------------------------
804double wxQTMediaBackend::GetVolume()
805{
bf354396 806 short sVolume = ::GetMovieVolume(m_movie);
c5191fbd 807
9419b0d6 808 if (sVolume & (128 << 8)) //negative - no sound
c5191fbd
VZ
809 return 0.0;
810
9419b0d6 811 return sVolume / 256.0;
c5191fbd
VZ
812}
813
814//---------------------------------------------------------------------------
815// wxQTMediaBackend::SetVolume
816//
817// Sets the volume through SetMovieVolume - which takes a 16 bit short -
818//
819// +--------+--------+
820// + (1) + (2) +
821// +--------+--------+
822//
823// (1) first 8 bits are value before decimal
824// (2) second 8 bits are value after decimal
825//
826// Volume ranges from -1.0 (gain but no sound), 0 (no sound and no gain) to
827// 1 (full gain and sound)
828//---------------------------------------------------------------------------
829bool wxQTMediaBackend::SetVolume(double dVolume)
830{
bf354396 831 ::SetMovieVolume(m_movie, (short) (dVolume * 256));
c5191fbd
VZ
832 return true;
833}
9419b0d6
DS
834
835//---------------------------------------------------------------------------
e7b97da3 836// wxQTMediaBackend::GetDuration
ff4aedc5 837//
3b5023b9 838// Calls GetMovieDuration
ff4aedc5
RN
839//---------------------------------------------------------------------------
840wxLongLong wxQTMediaBackend::GetDuration()
1a680109 841{
1a680109
RN
842 return ::GetMovieDuration(m_movie);
843}
844
ff4aedc5 845//---------------------------------------------------------------------------
e7b97da3 846// wxQTMediaBackend::GetState
ff4aedc5 847//
3b5023b9
RN
848// Determines the current state - the timer keeps track of whether or not
849// we are paused or stopped (if the timer is running we are playing)
ff4aedc5
RN
850//---------------------------------------------------------------------------
851wxMediaState wxQTMediaBackend::GetState()
1a680109 852{
bf354396 853 // Could use
9419b0d6 854 // GetMovieActive/IsMovieDone/SetMovieActive
bf354396 855 // combo if implemented that way
9419b0d6 856 if (m_bPlaying)
1a680109 857 return wxMEDIASTATE_PLAYING;
0c81ef7f 858 else if (!m_movie || wxQTMediaBackend::GetPosition() == 0)
bf354396 859 return wxMEDIASTATE_STOPPED;
1a680109
RN
860 else
861 return wxMEDIASTATE_PAUSED;
862}
863
ff4aedc5 864//---------------------------------------------------------------------------
e7b97da3 865// wxQTMediaBackend::Cleanup
ff4aedc5 866//
3b5023b9
RN
867// Diposes of the movie timer, Control if native, and stops and disposes
868// of the QT movie
ff4aedc5
RN
869//---------------------------------------------------------------------------
870void wxQTMediaBackend::Cleanup()
1a680109 871{
bf354396 872 m_bPlaying = false;
9419b0d6 873 if (m_timer)
bf354396 874 {
9419b0d6
DS
875 delete m_timer;
876 m_timer = NULL;
bf354396 877 }
d0ee33f5 878
9419b0d6 879 // Stop the movie:
bf354396
VZ
880 // Apple samples with CreateMovieControl typically
881 // install a event handler and do this on the dispose
882 // event, but we do it here for simplicity
883 // (It might keep playing for several seconds after
9419b0d6 884 // control destruction if not)
bf354396 885 wxQTMediaBackend::Pause();
9419b0d6 886
bf354396 887 // Dispose of control or remove movie from MovieController
bf354396
VZ
888 Point thePoint;
889 thePoint.h = thePoint.v = 0;
890 ::MCSetVisible(m_mc, false);
891 ::MCSetMovie(m_mc, NULL, NULL, thePoint);
1a680109 892
bf354396 893 ::DisposeMovie(m_movie);
9419b0d6 894 m_movie = NULL;
bf354396
VZ
895}
896
ff4aedc5 897//---------------------------------------------------------------------------
e7b97da3 898// wxQTMediaBackend::GetVideoSize
ff4aedc5 899//
3b5023b9 900// Returns the actual size of the QT movie
ff4aedc5
RN
901//---------------------------------------------------------------------------
902wxSize wxQTMediaBackend::GetVideoSize() const
1a680109
RN
903{
904 return m_bestSize;
905}
906
ff4aedc5
RN
907//---------------------------------------------------------------------------
908// wxQTMediaBackend::Move
909//
557002cf
VZ
910// Move the movie controller or movie control
911// (we need to actually move the movie control manually...)
912// Top 10 things to do with quicktime in March 93's issue
913// of DEVELOP - very useful
914// http:// www.mactech.com/articles/develop/issue_13/031-033_QuickTime_column.html
915// OLD NOTE: Calling MCSetControllerBoundsRect without detaching
916// supposively resulted in a crash back then. Current code even
917// with CFM classic runs fine. If there is ever a problem,
918// take out the if 0 lines below
ff4aedc5
RN
919//---------------------------------------------------------------------------
920void wxQTMediaBackend::Move(int x, int y, int w, int h)
1a680109 921{
9419b0d6 922 if (m_timer)
1a680109 923 {
9419b0d6
DS
924 m_ctrl->GetParent()->MacWindowToRootWindow(&x, &y);
925 Rect theRect = {y, x, y + h, x + w};
926
0c81ef7f 927#if 0 // see note above
9419b0d6
DS
928 ::MCSetControllerAttached(m_mc, false);
929 wxASSERT(::GetMoviesError() == noErr);
557002cf 930#endif
9419b0d6 931
bf354396 932 ::MCSetControllerBoundsRect(m_mc, &theRect);
1a680109 933 wxASSERT(::GetMoviesError() == noErr);
557002cf
VZ
934
935#if 0 // see note above
9419b0d6 936 if (m_interfaceflags)
557002cf 937 {
9419b0d6
DS
938 ::MCSetVisible(m_mc, true);
939 wxASSERT(::GetMoviesError() == noErr);
940 }
557002cf 941#endif
1a680109
RN
942 }
943}
944
bf354396
VZ
945//---------------------------------------------------------------------------
946// wxQTMediaBackend::DoSetControllerVisible
947//
948// Utility function that takes care of showing the moviecontroller
949// and showing/hiding the particular controls on it
950//---------------------------------------------------------------------------
0c81ef7f
SC
951void wxQTMediaBackend::DoSetControllerVisible(
952 wxMediaCtrlPlayerControls flags)
9419b0d6
DS
953{
954 ::MCSetVisible(m_mc, true);
955
bf354396 956 // Take care of subcontrols
9419b0d6 957 if (::GetMoviesError() == noErr)
bf354396
VZ
958 {
959 long mcFlags = 0;
960 ::MCDoAction(m_mc, 39/*mcActionGetFlags*/, (void*)&mcFlags);
9419b0d6
DS
961
962 if (::GetMoviesError() == noErr)
963 {
bf354396 964 mcFlags |= ( //(1<<0)/*mcFlagSuppressMovieFrame*/ |
9419b0d6 965 (1 << 3)/*mcFlagsUseWindowPalette*/
bf354396 966 | ((flags & wxMEDIACTRLPLAYERCONTROLS_STEP)
9419b0d6 967 ? 0 : (1 << 1)/*mcFlagSuppressStepButtons*/)
bf354396 968 | ((flags & wxMEDIACTRLPLAYERCONTROLS_VOLUME)
9419b0d6 969 ? 0 : (1 << 2)/*mcFlagSuppressSpeakerButton*/)
0c81ef7f 970 //if we take care of repainting ourselves
987e9419 971 // | (1 << 4) /*mcFlagDontInvalidate*/
bf354396 972 );
9419b0d6
DS
973
974 ::MCDoAction(m_mc, 38/*mcActionSetFlags*/, (void*)mcFlags);
bf354396 975 }
9419b0d6
DS
976 }
977
978 // Adjust height and width of best size for movie controller
979 // if the user wants it shown
bf354396
VZ
980 m_bestSize.x = m_bestSize.x > wxMCWIDTH ? m_bestSize.x : wxMCWIDTH;
981 m_bestSize.y += wxMCHEIGHT;
982}
983
984//---------------------------------------------------------------------------
985// wxQTMediaBackend::ShowPlayerControls
986//
987// Shows/Hides subcontrols on the media control
988//---------------------------------------------------------------------------
989bool wxQTMediaBackend::ShowPlayerControls(wxMediaCtrlPlayerControls flags)
990{
9419b0d6
DS
991 if (!m_mc)
992 return false; // no movie controller...
993
bf354396 994 bool bSizeChanged = false;
9419b0d6
DS
995
996 // if the controller is visible and we want to hide it do so
997 if (m_interfaceflags && !flags)
bf354396
VZ
998 {
999 bSizeChanged = true;
1000 DoLoadBestSize();
9419b0d6 1001 ::MCSetVisible(m_mc, false);
bf354396 1002 }
9419b0d6 1003 else if (!m_interfaceflags && flags) // show controller if hidden
bf354396
VZ
1004 {
1005 bSizeChanged = true;
1006 DoSetControllerVisible(flags);
1007 }
9419b0d6
DS
1008
1009 // readjust parent sizers
1010 if (bSizeChanged)
bf354396 1011 {
9419b0d6
DS
1012 NotifyMovieSizeChanged();
1013
1014 // remember state in case of loading new media
bf354396 1015 m_interfaceflags = flags;
9419b0d6
DS
1016 }
1017
557002cf
VZ
1018 return ::GetMoviesError() == noErr;
1019}
1020
1021//---------------------------------------------------------------------------
1022// wxQTMediaBackend::GetDataSizeFromStart
1023//
1024// Calls either GetMovieDataSize or GetMovieDataSize64 with a value
1025// of 0 for the starting value
1026//---------------------------------------------------------------------------
1027wxLongLong wxQTMediaBackend::GetDataSizeFromStart(TimeValue end)
1028{
1029#if 0 // old pre-qt4 way
1030 return ::GetMovieDataSize(m_movie, 0, end)
1031#else // qt4 way
1032 wide llDataSize;
1033 ::GetMovieDataSize64(m_movie, 0, end, &llDataSize);
1034 return wxLongLong(llDataSize.hi, llDataSize.lo);
1035#endif
1036}
1037
1038//---------------------------------------------------------------------------
1039// wxQTMediaBackend::GetDownloadProgress
1040//---------------------------------------------------------------------------
1041wxLongLong wxQTMediaBackend::GetDownloadProgress()
1042{
1043#if 0 // hackish and slow
1044 Handle hMovie = NewHandle(0);
1045 PutMovieIntoHandle(m_movie, hMovie);
1046 long lSize = GetHandleSize(hMovie);
1047 DisposeHandle(hMovie);
9419b0d6 1048
557002cf
VZ
1049 return lSize;
1050#else
1051 TimeValue tv;
9419b0d6 1052 if (::GetMaxLoadedTimeInMovie(m_movie, &tv) != noErr)
557002cf
VZ
1053 {
1054 wxLogDebug(wxT("GetMaxLoadedTimeInMovie failed"));
1055 return 0;
592a247d 1056 }
9419b0d6 1057
557002cf
VZ
1058 return wxQTMediaBackend::GetDataSizeFromStart(tv);
1059#endif
1060}
592a247d 1061
557002cf
VZ
1062//---------------------------------------------------------------------------
1063// wxQTMediaBackend::GetDownloadTotal
1064//---------------------------------------------------------------------------
1065wxLongLong wxQTMediaBackend::GetDownloadTotal()
1066{
987e9419
WS
1067 return wxQTMediaBackend::GetDataSizeFromStart(
1068 ::GetMovieDuration(m_movie)
0c81ef7f
SC
1069 );
1070}
1071
1072//---------------------------------------------------------------------------
1073// wxQTMediaBackend::MacVisibilityChanged
1074//
1075// The main problem here is that Windows quicktime, for example,
1076// renders more directly to a HWND. Mac quicktime does not do this
1077// and instead renders to the port of the WindowRef/WindowPtr on top
1078// of everything else/all other windows.
1079//
1080// So, for example, if you were to have a CreateTabsControl/wxNotebook
1081// and change pages, even if you called HIViewSetVisible/SetControlVisibility
1082// directly the movie will still continue playing on top of everything else
1083// if you went to a different tab.
1084//
1085// Note that another issue, and why we call MCSetControllerPort instead
1086// of SetMovieGWorld directly, is that in addition to rendering on
1087// top of everything else the last created controller steals mouse and
1088// other input from everything else in the window, including other
1089// controllers. Setting the port of it releases this behaviour.
1090//---------------------------------------------------------------------------
1091void wxQTMediaBackend::MacVisibilityChanged()
1092{
1093 if(!m_mc || !m_ctrl->m_bLoaded)
1094 return; //not initialized yet
987e9419 1095
0c81ef7f
SC
1096 if(m_ctrl->MacIsReallyShown())
1097 {
1098 //The window is being shown again, so set the GWorld of the
1099 //controller back to the port of the parent WindowRef
987e9419 1100 WindowRef wrTLW =
0c81ef7f
SC
1101 (WindowRef) m_ctrl->MacGetTopLevelWindowRef();
1102
1103 ::MCSetControllerPort(m_mc, (CGrafPtr) GetWindowPort(wrTLW));
1104 wxASSERT(::GetMoviesError() == noErr);
1105 }
1106 else
1107 {
1108 //We are being hidden - set the GWorld of the controller
1109 //to the offscreen GWorld
1110 ::MCSetControllerPort(m_mc, m_movieWorld);
987e9419 1111 wxASSERT(::GetMoviesError() == noErr);
0c81ef7f 1112 }
bf354396
VZ
1113}
1114
1115//---------------------------------------------------------------------------
1116// wxQTMediaBackend::OnEraseBackground
1117//
1118// Suggestion from Greg Hazel to repaint the movie when idle
1119// (on pause also)
1120//---------------------------------------------------------------------------
bf354396
VZ
1121void wxQTMediaEvtHandler::OnEraseBackground(wxEraseEvent& evt)
1122{
9419b0d6 1123 // Work around Nasty OSX drawing bug:
bf354396 1124 // http://lists.apple.com/archives/QuickTime-API/2002/Feb/msg00311.html
9419b0d6 1125 WindowRef wrTLW = (WindowRef) m_qtb->m_ctrl->MacGetTopLevelWindowRef();
bf354396 1126
0c81ef7f
SC
1127 RgnHandle region = ::MCGetControllerBoundsRgn(m_qtb->m_mc);
1128 ::MCInvalidate(m_qtb->m_mc, wrTLW, region);
1129 ::MCIdle(m_qtb->m_mc);
1130}
1131
1132//---------------------------------------------------------------------------
1133// wxQTMediaBackend::PPRMProc (static)
1134//
1135// Called when done PrePrerolling the movie.
1136// Note that in 99% of the cases this does nothing...
1137// Anyway we set up the loading timer here to tell us when the movie is done
1138//---------------------------------------------------------------------------
1139pascal void wxQTMediaBackend::PPRMProc(
1140 Movie theMovie,
1141 OSErr WXUNUSED_UNLESS_DEBUG(theErr),
1142 void* theRefCon)
1143{
1144 wxASSERT( theMovie );
1145 wxASSERT( theRefCon );
1146 wxASSERT( theErr == noErr );
1147
1148 wxQTMediaBackend* pBE = (wxQTMediaBackend*) theRefCon;
1149
1150 long lTime = ::GetMovieTime(theMovie,NULL);
1151 Fixed rate = ::GetMoviePreferredRate(theMovie);
1152 ::PrerollMovie(theMovie,lTime,rate);
1153 pBE->m_timer = new wxQTMediaLoadTimer(pBE);
1154 pBE->m_timer->Start(MOVIE_DELAY);
bf354396 1155}
bf354396
VZ
1156
1157//---------------------------------------------------------------------------
0c81ef7f
SC
1158// wxQTMediaBackend::MCFilterProc (static)
1159//
1160// Callback for when the movie controller recieves a message
1161//---------------------------------------------------------------------------
1162pascal Boolean wxQTMediaBackend::MCFilterProc(
1163 MovieController WXUNUSED(theController),
1164 short action,
1165 void * WXUNUSED(params),
1166 long refCon)
1167{
1168 wxQTMediaBackend* pThis = (wxQTMediaBackend*)refCon;
1169
1170 switch (action)
1171 {
1172 case 1:
1173 // don't process idle events
1174 break;
1175
1176 case 8:
1177 // play button triggered - MC will set movie to opposite state
1178 // of current - playing ? paused : playing
1179 pThis->m_bPlaying = !(pThis->m_bPlaying);
1180 break;
1181
1182 default:
1183 break;
1184 }
1185
1186 return 0;
1187}
1188
1189//---------------------------------------------------------------------------
1190// wxQTMediaBackend::WindowEventHandler [static]
bf354396
VZ
1191//
1192// Event callback for the top level window of our control that passes
9419b0d6 1193// messages to our moviecontroller so it can receive mouse clicks etc.
bf354396 1194//---------------------------------------------------------------------------
0c81ef7f 1195pascal OSStatus wxQTMediaBackend::WindowEventHandler(
9419b0d6
DS
1196 EventHandlerCallRef inHandlerCallRef,
1197 EventRef inEvent,
1198 void *inUserData)
bf354396 1199{
0c81ef7f 1200 wxQTMediaBackend* be = (wxQTMediaBackend*) inUserData;
987e9419 1201
0c81ef7f
SC
1202 // Only process keyboard messages on this window if it actually
1203 // has focus, otherwise it will steal keystrokes from other windows!
1204 // As well as when it is not loaded properly as it
1205 // will crash in MCIsPlayerEvent
1206 if((GetEventClass(inEvent) == kEventClassKeyboard &&
987e9419 1207 wxWindow::FindFocus() != be->m_ctrl)
0c81ef7f 1208 || !be->m_ctrl->m_bLoaded)
557002cf 1209 return eventNotHandledErr;
9419b0d6 1210
0c81ef7f 1211 // Pass the event onto the movie controller
bf354396
VZ
1212 EventRecord theEvent;
1213 ConvertEventRefToEventRecord( inEvent, &theEvent );
1214 OSStatus err;
592a247d 1215
987e9419 1216 // TODO: Apple says MCIsPlayerEvent is depreciated and
0c81ef7f
SC
1217 // MCClick, MCKey, MCIdle etc. should be used
1218 // (RN: Of course that's what they say about
1219 // CreateMovieControl and HIMovieView as well, LOL!)
1220 err = ::MCIsPlayerEvent( be->m_mc, &theEvent );
9419b0d6 1221
0c81ef7f 1222 // Pass on to other event handlers if not handled- i.e. wx
9419b0d6 1223 if (err != noErr)
bf354396
VZ
1224 return noErr;
1225 else
1226 return eventNotHandledErr;
1227}
ff4aedc5 1228
9419b0d6 1229// in source file that contains stuff you don't directly use
f572d649 1230#include "wx/html/forcelnk.h"
412e0d47 1231FORCE_LINK_ME(basewxmediabackends)
ff4aedc5 1232
9419b0d6 1233#endif // wxUSE_MEDIACTRL