]> git.saurik.com Git - wxWidgets.git/blob - src/msw/mediactrl_qt.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
renaming
[wxWidgets.git] / src / msw / mediactrl_qt.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/msw/mediactrl_qt.cpp
3 // Purpose: QuickTime Media Backend for Windows
4 // Author: Ryan Norton <wxprojects@comcast.net>
5 // Modified by: Robin Dunn (moved QT code from mediactrl.cpp)
6 //
7 // Created: 11/07/04
8 // RCS-ID: $Id$
9 // Copyright: (c) Ryan Norton
10 // Licence: wxWindows licence
11 /////////////////////////////////////////////////////////////////////////////
12
13
14 //===========================================================================
15 // DECLARATIONS
16 //===========================================================================
17
18 //---------------------------------------------------------------------------
19 // Pre-compiled header stuff
20 //---------------------------------------------------------------------------
21
22 // For compilers that support precompilation, includes "wx.h".
23 #include "wx/wxprec.h"
24
25 #ifdef __BORLANDC__
26 #pragma hdrstop
27 #endif
28
29 #if wxUSE_MEDIACTRL
30
31 #include "wx/mediactrl.h"
32
33 #ifndef WX_PRECOMP
34 #include "wx/log.h"
35 #include "wx/dcclient.h"
36 #include "wx/timer.h"
37 #include "wx/math.h" // log10 & pow
38 #endif
39
40 #include "wx/msw/private.h" // user info and wndproc setting/getting
41 #include "wx/dynlib.h"
42
43 //---------------------------------------------------------------------------
44 // Externals (somewhere in src/msw/app.cpp and src/msw/window.cpp)
45 //---------------------------------------------------------------------------
46 extern "C" WXDLLIMPEXP_BASE HINSTANCE wxGetInstance(void);
47 #ifdef __WXWINCE__
48 extern WXDLLIMPEXP_CORE wxChar *wxCanvasClassName;
49 #else
50 extern WXDLLIMPEXP_CORE const wxChar *wxCanvasClassName;
51 #endif
52
53 LRESULT WXDLLIMPEXP_CORE APIENTRY _EXPORT wxWndProc(HWND hWnd, UINT message,
54 WPARAM wParam, LPARAM lParam);
55
56 //---------------------------------------------------------------------------
57 // Killed MSVC warnings
58 //---------------------------------------------------------------------------
59 //disable "cast truncates constant value" for VARIANT_BOOL values
60 //passed as parameters in VC5 and up
61 #ifdef _MSC_VER
62 #pragma warning (disable:4310)
63 #endif
64
65
66 //---------------------------------------------------------------------------
67 // wxQTMediaBackend
68 //
69 // We don't include Quicktime headers here and define all the types
70 // ourselves because looking for the quicktime libaries etc. would
71 // be tricky to do and making this a dependency for the MSVC projects
72 // would be unrealistic.
73 //
74 // Thanks to Robert Roebling for the wxDL macro/library idea
75 //---------------------------------------------------------------------------
76
77 //---------------------------------------------------------------------------
78 // QT Includes
79 //---------------------------------------------------------------------------
80 //#include <qtml.h> // Windoze QT include
81 //#include <QuickTimeComponents.h> // Standard QT stuff
82 #include "wx/dynlib.h"
83
84 //---------------------------------------------------------------------------
85 // QT Types
86 //---------------------------------------------------------------------------
87 typedef struct MovieRecord* Movie;
88 typedef wxInt16 OSErr;
89 typedef wxInt32 OSStatus;
90 #define noErr 0
91 #define fsRdPerm 1
92 typedef unsigned char Str255[256];
93 #define StringPtr unsigned char*
94 #define newMovieActive 1
95 #define newMovieAsyncOK (1 << 8)
96 #define Ptr char*
97 #define Handle Ptr*
98 #define Fixed long
99 #define OSType unsigned long
100 #define CGrafPtr struct GrafPort *
101 #define TimeScale long
102 #define TimeBase struct TimeBaseRecord *
103 typedef struct ComponentInstanceRecord * ComponentInstance;
104 #define kMovieLoadStatePlayable 10000
105 #define Boolean int
106 #define MovieController ComponentInstance
107
108 #ifndef URLDataHandlerSubType
109 #if defined(__WATCOMC__) || defined(__MINGW32__)
110 // use magic numbers for compilers which complain about multicharacter integers
111 const OSType URLDataHandlerSubType = 1970433056;
112 const OSType VisualMediaCharacteristic = 1702454643;
113 #else
114 const OSType URLDataHandlerSubType = 'url ';
115 const OSType VisualMediaCharacteristic = 'eyes';
116 #endif
117 #endif
118
119 struct FSSpec
120 {
121 short vRefNum;
122 long parID;
123 Str255 name; // Str63 on mac, Str255 on msw
124 };
125
126 struct Rect
127 {
128 short top;
129 short left;
130 short bottom;
131 short right;
132 };
133
134 struct wide
135 {
136 wxInt32 hi;
137 wxUint32 lo;
138 };
139
140 struct TimeRecord
141 {
142 wide value; // units
143 TimeScale scale; // units per second
144 TimeBase base;
145 };
146
147 struct Point
148 {
149 short v;
150 short h;
151 };
152
153 struct EventRecord
154 {
155 wxUint16 what;
156 wxUint32 message;
157 wxUint32 when;
158 Point where;
159 wxUint16 modifiers;
160 };
161
162 enum
163 {
164 mcTopLeftMovie = 1,
165 mcScaleMovieToFit = 2,
166 mcWithBadge = 4,
167 mcNotVisible = 8,
168 mcWithFrame = 16
169 };
170
171 //---------------------------------------------------------------------------
172 // QT Library
173 //---------------------------------------------------------------------------
174
175 class WXDLLIMPEXP_MEDIA wxQuickTimeLibrary
176 {
177 public:
178 ~wxQuickTimeLibrary()
179 {
180 if (m_dll.IsLoaded())
181 m_dll.Unload();
182 }
183
184 bool Initialize();
185 bool IsOk() const {return m_ok;}
186
187 protected:
188 wxDynamicLibrary m_dll;
189 bool m_ok;
190
191 public:
192 wxDL_VOIDMETHOD_DEFINE( StartMovie, (Movie m), (m) )
193 wxDL_VOIDMETHOD_DEFINE( StopMovie, (Movie m), (m) )
194 wxDL_METHOD_DEFINE( bool, IsMovieDone, (Movie m), (m), false)
195 wxDL_VOIDMETHOD_DEFINE( GoToBeginningOfMovie, (Movie m), (m) )
196 wxDL_METHOD_DEFINE( OSErr, GetMoviesError, (), (), -1)
197 wxDL_METHOD_DEFINE( OSErr, EnterMovies, (), (), -1)
198 wxDL_VOIDMETHOD_DEFINE( ExitMovies, (), () )
199 wxDL_METHOD_DEFINE( OSErr, InitializeQTML, (long flags), (flags), -1)
200 wxDL_VOIDMETHOD_DEFINE( TerminateQTML, (), () )
201
202 wxDL_METHOD_DEFINE( OSErr, NativePathNameToFSSpec,
203 (char* inName, FSSpec* outFile, long flags),
204 (inName, outFile, flags), -1)
205
206 wxDL_METHOD_DEFINE( OSErr, OpenMovieFile,
207 (const FSSpec * fileSpec, short * resRefNum, wxInt8 permission),
208 (fileSpec, resRefNum, permission), -1 )
209
210 wxDL_METHOD_DEFINE( OSErr, CloseMovieFile,
211 (short resRefNum), (resRefNum), -1)
212
213 wxDL_METHOD_DEFINE( OSErr, NewMovieFromFile,
214 (Movie * theMovie, short resRefNum, short * resId,
215 StringPtr resName, short newMovieFlags,
216 bool * dataRefWasChanged),
217 (theMovie, resRefNum, resId, resName, newMovieFlags,
218 dataRefWasChanged), -1)
219
220 wxDL_VOIDMETHOD_DEFINE( SetMovieRate, (Movie m, Fixed rate), (m, rate) )
221 wxDL_METHOD_DEFINE( Fixed, GetMovieRate, (Movie m), (m), 0)
222 wxDL_VOIDMETHOD_DEFINE( MoviesTask, (Movie m, long maxms), (m, maxms) )
223 wxDL_VOIDMETHOD_DEFINE( BlockMove,
224 (const char* p1, const char* p2, long s), (p1,p2,s) )
225 wxDL_METHOD_DEFINE( Handle, NewHandleClear, (long s), (s), NULL )
226
227 wxDL_METHOD_DEFINE( OSErr, NewMovieFromDataRef,
228 (Movie * m, short flags, short * id,
229 Handle dataRef, OSType dataRefType),
230 (m,flags,id,dataRef,dataRefType), -1 )
231
232 wxDL_VOIDMETHOD_DEFINE( DisposeHandle, (Handle h), (h) )
233 wxDL_VOIDMETHOD_DEFINE( GetMovieNaturalBoundsRect, (Movie m, Rect* r), (m,r) )
234 wxDL_METHOD_DEFINE( void*, GetMovieIndTrackType,
235 (Movie m, long index, OSType type, long flags),
236 (m,index,type,flags), NULL )
237 wxDL_VOIDMETHOD_DEFINE( CreatePortAssociation,
238 (void* hWnd, void* junk, long morejunk), (hWnd, junk, morejunk) )
239 wxDL_METHOD_DEFINE(void*, GetNativeWindowPort, (void* hWnd), (hWnd), NULL)
240 wxDL_VOIDMETHOD_DEFINE(SetMovieGWorld, (Movie m, CGrafPtr port, void* whatever),
241 (m, port, whatever) )
242 wxDL_VOIDMETHOD_DEFINE(DisposeMovie, (Movie m), (m) )
243 wxDL_VOIDMETHOD_DEFINE(SetMovieBox, (Movie m, Rect* r), (m,r))
244 wxDL_VOIDMETHOD_DEFINE(SetMovieTimeScale, (Movie m, long s), (m,s))
245 wxDL_METHOD_DEFINE(long, GetMovieDuration, (Movie m), (m), 0)
246 wxDL_METHOD_DEFINE(TimeBase, GetMovieTimeBase, (Movie m), (m), 0)
247 wxDL_METHOD_DEFINE(TimeScale, GetMovieTimeScale, (Movie m), (m), 0)
248 wxDL_METHOD_DEFINE(long, GetMovieTime, (Movie m, void* cruft), (m,cruft), 0)
249 wxDL_VOIDMETHOD_DEFINE(SetMovieTime, (Movie m, TimeRecord* tr), (m,tr) )
250 wxDL_METHOD_DEFINE(short, GetMovieVolume, (Movie m), (m), 0)
251 wxDL_VOIDMETHOD_DEFINE(SetMovieVolume, (Movie m, short sVolume), (m,sVolume) )
252 wxDL_VOIDMETHOD_DEFINE(SetMovieTimeValue, (Movie m, long s), (m,s))
253 wxDL_METHOD_DEFINE(ComponentInstance, NewMovieController, (Movie m, const Rect* mr, long fl), (m,mr,fl), 0)
254 wxDL_VOIDMETHOD_DEFINE(DisposeMovieController, (ComponentInstance ci), (ci))
255 wxDL_METHOD_DEFINE(int, MCSetVisible, (ComponentInstance m, int b), (m, b), 0)
256
257 wxDL_VOIDMETHOD_DEFINE(PrePrerollMovie, (Movie m, long t, Fixed r, WXFARPROC p1, void* p2), (m,t,r,p1,p2) )
258 wxDL_VOIDMETHOD_DEFINE(PrerollMovie, (Movie m, long t, Fixed r), (m,t,r) )
259 wxDL_METHOD_DEFINE(Fixed, GetMoviePreferredRate, (Movie m), (m), 0)
260 wxDL_METHOD_DEFINE(long, GetMovieLoadState, (Movie m), (m), 0)
261 wxDL_METHOD_DEFINE(void*, NewRoutineDescriptor, (WXFARPROC f, int l, void* junk), (f, l, junk), 0)
262 wxDL_VOIDMETHOD_DEFINE(DisposeRoutineDescriptor, (void* f), (f))
263 wxDL_METHOD_DEFINE(void*, GetCurrentArchitecture, (), (), 0)
264 wxDL_METHOD_DEFINE(int, MCDoAction, (ComponentInstance ci, long f, void* p), (ci,f,p), 0)
265 wxDL_VOIDMETHOD_DEFINE(MCSetControllerBoundsRect, (ComponentInstance ci, Rect* r), (ci,r))
266 wxDL_VOIDMETHOD_DEFINE(DestroyPortAssociation, (CGrafPtr g), (g))
267 wxDL_VOIDMETHOD_DEFINE(NativeEventToMacEvent, (MSG* p1, EventRecord* p2), (p1,p2))
268 wxDL_VOIDMETHOD_DEFINE(MCIsPlayerEvent, (ComponentInstance ci, EventRecord* p2), (ci, p2))
269 wxDL_METHOD_DEFINE(int, MCSetMovie, (ComponentInstance ci, Movie m, void* p1, Point w),
270 (ci,m,p1,w),0)
271 wxDL_VOIDMETHOD_DEFINE(MCPositionController,
272 (ComponentInstance ci, Rect* r, void* junk, void* morejunk), (ci,r,junk,morejunk))
273 wxDL_VOIDMETHOD_DEFINE(MCSetActionFilterWithRefCon,
274 (ComponentInstance ci, WXFARPROC cb, void* ref), (ci,cb,ref))
275 wxDL_VOIDMETHOD_DEFINE(MCGetControllerInfo, (MovieController mc, long* flags), (mc,flags))
276 wxDL_VOIDMETHOD_DEFINE(BeginUpdate, (CGrafPtr port), (port))
277 wxDL_VOIDMETHOD_DEFINE(UpdateMovie, (Movie m), (m))
278 wxDL_VOIDMETHOD_DEFINE(EndUpdate, (CGrafPtr port), (port))
279 wxDL_METHOD_DEFINE( OSErr, GetMoviesStickyError, (), (), -1)
280 };
281
282 bool wxQuickTimeLibrary::Initialize()
283 {
284 // Turn off the wxDynamicLibrary logging as we're prepared to handle the
285 // errors
286 wxLogNull nolog;
287
288 m_ok = m_dll.Load(wxT("qtmlClient.dll"));
289 if ( !m_ok )
290 return false;
291
292 wxDL_METHOD_LOAD( m_dll, StartMovie );
293 wxDL_METHOD_LOAD( m_dll, StopMovie );
294 wxDL_METHOD_LOAD( m_dll, IsMovieDone );
295 wxDL_METHOD_LOAD( m_dll, GoToBeginningOfMovie );
296 wxDL_METHOD_LOAD( m_dll, GetMoviesError );
297 wxDL_METHOD_LOAD( m_dll, EnterMovies );
298 wxDL_METHOD_LOAD( m_dll, ExitMovies );
299 wxDL_METHOD_LOAD( m_dll, InitializeQTML );
300 wxDL_METHOD_LOAD( m_dll, TerminateQTML );
301 wxDL_METHOD_LOAD( m_dll, NativePathNameToFSSpec );
302 wxDL_METHOD_LOAD( m_dll, OpenMovieFile );
303 wxDL_METHOD_LOAD( m_dll, CloseMovieFile );
304 wxDL_METHOD_LOAD( m_dll, NewMovieFromFile );
305 wxDL_METHOD_LOAD( m_dll, GetMovieRate );
306 wxDL_METHOD_LOAD( m_dll, SetMovieRate );
307 wxDL_METHOD_LOAD( m_dll, MoviesTask );
308 wxDL_METHOD_LOAD( m_dll, BlockMove );
309 wxDL_METHOD_LOAD( m_dll, NewHandleClear );
310 wxDL_METHOD_LOAD( m_dll, NewMovieFromDataRef );
311 wxDL_METHOD_LOAD( m_dll, DisposeHandle );
312 wxDL_METHOD_LOAD( m_dll, GetMovieNaturalBoundsRect );
313 wxDL_METHOD_LOAD( m_dll, GetMovieIndTrackType );
314 wxDL_METHOD_LOAD( m_dll, CreatePortAssociation );
315 wxDL_METHOD_LOAD( m_dll, DestroyPortAssociation );
316 wxDL_METHOD_LOAD( m_dll, GetNativeWindowPort );
317 wxDL_METHOD_LOAD( m_dll, SetMovieGWorld );
318 wxDL_METHOD_LOAD( m_dll, DisposeMovie );
319 wxDL_METHOD_LOAD( m_dll, SetMovieBox );
320 wxDL_METHOD_LOAD( m_dll, SetMovieTimeScale );
321 wxDL_METHOD_LOAD( m_dll, GetMovieDuration );
322 wxDL_METHOD_LOAD( m_dll, GetMovieTimeBase );
323 wxDL_METHOD_LOAD( m_dll, GetMovieTimeScale );
324 wxDL_METHOD_LOAD( m_dll, GetMovieTime );
325 wxDL_METHOD_LOAD( m_dll, SetMovieTime );
326 wxDL_METHOD_LOAD( m_dll, GetMovieVolume );
327 wxDL_METHOD_LOAD( m_dll, SetMovieVolume );
328 wxDL_METHOD_LOAD( m_dll, SetMovieTimeValue );
329 wxDL_METHOD_LOAD( m_dll, NewMovieController );
330 wxDL_METHOD_LOAD( m_dll, DisposeMovieController );
331 wxDL_METHOD_LOAD( m_dll, MCSetVisible );
332 wxDL_METHOD_LOAD( m_dll, PrePrerollMovie );
333 wxDL_METHOD_LOAD( m_dll, PrerollMovie );
334 wxDL_METHOD_LOAD( m_dll, GetMoviePreferredRate );
335 wxDL_METHOD_LOAD( m_dll, GetMovieLoadState );
336 wxDL_METHOD_LOAD( m_dll, MCDoAction );
337 wxDL_METHOD_LOAD( m_dll, MCSetControllerBoundsRect );
338 wxDL_METHOD_LOAD( m_dll, NativeEventToMacEvent );
339 wxDL_METHOD_LOAD( m_dll, MCIsPlayerEvent );
340 wxDL_METHOD_LOAD( m_dll, MCSetMovie );
341 wxDL_METHOD_LOAD( m_dll, MCSetActionFilterWithRefCon );
342 wxDL_METHOD_LOAD( m_dll, MCGetControllerInfo );
343 wxDL_METHOD_LOAD( m_dll, BeginUpdate );
344 wxDL_METHOD_LOAD( m_dll, UpdateMovie );
345 wxDL_METHOD_LOAD( m_dll, EndUpdate );
346 wxDL_METHOD_LOAD( m_dll, GetMoviesStickyError );
347
348 return m_ok;
349 }
350
351 class WXDLLIMPEXP_MEDIA wxQTMediaBackend : public wxMediaBackendCommonBase
352 {
353 public:
354 wxQTMediaBackend();
355 virtual ~wxQTMediaBackend();
356
357 virtual bool CreateControl(wxControl* ctrl, wxWindow* parent,
358 wxWindowID id,
359 const wxPoint& pos,
360 const wxSize& size,
361 long style,
362 const wxValidator& validator,
363 const wxString& name);
364
365 virtual bool Play();
366 virtual bool Pause();
367 virtual bool Stop();
368
369 virtual bool Load(const wxURI& location,
370 const wxURI& proxy)
371 { return wxMediaBackend::Load(location, proxy); }
372
373 virtual bool Load(const wxString& fileName);
374 virtual bool Load(const wxURI& location);
375
376 virtual wxMediaState GetState();
377
378 virtual bool SetPosition(wxLongLong where);
379 virtual wxLongLong GetPosition();
380 virtual wxLongLong GetDuration();
381
382 virtual void Move(int x, int y, int w, int h);
383 wxSize GetVideoSize() const;
384
385 virtual double GetPlaybackRate();
386 virtual bool SetPlaybackRate(double dRate);
387
388 virtual double GetVolume();
389 virtual bool SetVolume(double);
390
391 void Cleanup();
392 void FinishLoad();
393
394 static void PPRMProc (Movie theMovie, OSErr theErr, void* theRefCon);
395
396 // TODO: Last param actually long - does this work on 64bit machines?
397 static Boolean MCFilterProc(MovieController theController,
398 short action, void *params, LONG_PTR refCon);
399
400 static LRESULT CALLBACK QTWndProc(HWND, UINT, WPARAM, LPARAM);
401
402 virtual bool ShowPlayerControls(wxMediaCtrlPlayerControls flags);
403
404 wxSize m_bestSize; // Original movie size
405 Movie m_movie; // QT Movie handle/instance
406 bool m_bVideo; // Whether or not we have video
407 bool m_bPlaying; // Whether or not movie is playing
408 wxTimer* m_timer; // Load or Play timer
409 wxQuickTimeLibrary m_lib; // DLL to load functions from
410 ComponentInstance m_pMC; // Movie Controller
411 wxEvtHandler* m_evthandler;
412
413 friend class wxQTMediaEvtHandler;
414
415 DECLARE_DYNAMIC_CLASS(wxQTMediaBackend)
416 };
417
418 // helper to hijack background erasing for the QT window
419 class WXDLLIMPEXP_MEDIA wxQTMediaEvtHandler : public wxEvtHandler
420 {
421 public:
422 wxQTMediaEvtHandler(wxQTMediaBackend *qtb, WXHWND hwnd)
423 {
424 m_qtb = qtb;
425 m_hwnd = hwnd;
426
427 m_qtb->m_ctrl->Connect(m_qtb->m_ctrl->GetId(),
428 wxEVT_ERASE_BACKGROUND,
429 wxEraseEventHandler(wxQTMediaEvtHandler::OnEraseBackground),
430 NULL, this);
431 }
432
433 void OnEraseBackground(wxEraseEvent& event);
434
435 private:
436 wxQTMediaBackend *m_qtb;
437 WXHWND m_hwnd;
438
439 DECLARE_NO_COPY_CLASS(wxQTMediaEvtHandler)
440 };
441
442
443 //===========================================================================
444 // IMPLEMENTATION
445 //===========================================================================
446
447
448 //---------------------------------------------------------------------------
449 // wxQTMediaBackend
450 //
451 // TODO: Use a less kludgy way to pause/get state/set state
452 // FIXME: Greg Hazel reports that sometimes files that cannot be played
453 // with this backend are treated as playable anyway - not verified though.
454 //---------------------------------------------------------------------------
455
456 IMPLEMENT_DYNAMIC_CLASS(wxQTMediaBackend, wxMediaBackend)
457
458 // Time between timer calls - this is the Apple recommendation to the TCL
459 // team I believe
460 #define MOVIE_DELAY 20
461
462 //---------------------------------------------------------------------------
463 // wxQTLoadTimer
464 //
465 // QT, esp. QT for Windows is very picky about how you go about
466 // async loading. If you were to go through a Windows message loop
467 // or a MoviesTask or both and then check the movie load state
468 // it would still return 1000 (loading)... even (pre)prerolling doesn't
469 // help. However, making a load timer like this works
470 //---------------------------------------------------------------------------
471 class wxQTLoadTimer : public wxTimer
472 {
473 public:
474 wxQTLoadTimer(Movie movie, wxQTMediaBackend* parent, wxQuickTimeLibrary* pLib) :
475 m_movie(movie), m_parent(parent), m_pLib(pLib) {}
476
477 void Notify()
478 {
479 m_pLib->MoviesTask(m_movie, 0);
480 // kMovieLoadStatePlayable
481 if (m_pLib->GetMovieLoadState(m_movie) >= 10000)
482 {
483 m_parent->FinishLoad();
484 delete this;
485 }
486 }
487
488 protected:
489 Movie m_movie; //Our movie instance
490 wxQTMediaBackend* m_parent; //Backend pointer
491 wxQuickTimeLibrary* m_pLib; //Interfaces
492 };
493
494
495 // --------------------------------------------------------------------------
496 // wxQTPlayTimer - Handle Asyncronous Playing
497 //
498 // 1) Checks to see if the movie is done, and if not continues
499 // streaming the movie
500 // 2) Sends the wxEVT_MEDIA_STOP event if we have reached the end of
501 // the movie.
502 // --------------------------------------------------------------------------
503 class wxQTPlayTimer : public wxTimer
504 {
505 public:
506 wxQTPlayTimer(Movie movie, wxQTMediaBackend* parent,
507 wxQuickTimeLibrary* pLib) :
508 m_movie(movie), m_parent(parent), m_pLib(pLib) {}
509
510 void Notify()
511 {
512 //
513 // OK, a little explaining - basically originally
514 // we only called MoviesTask if the movie was actually
515 // playing (not paused or stopped)... this was before
516 // we realized MoviesTask actually handles repainting
517 // of the current frame - so if you were to resize
518 // or something it would previously not redraw that
519 // portion of the movie.
520 //
521 // So now we call MoviesTask always so that it repaints
522 // correctly.
523 //
524 m_pLib->MoviesTask(m_movie, 0);
525
526 //
527 // Handle the stop event - if the movie has reached
528 // the end, notify our handler
529 //
530 // m_bPlaying == !(Stopped | Paused)
531 //
532 if (m_parent->m_bPlaying)
533 {
534 if (m_pLib->IsMovieDone(m_movie))
535 {
536 if ( m_parent->SendStopEvent() )
537 {
538 m_parent->Stop();
539 wxASSERT(m_pLib->GetMoviesError() == noErr);
540
541 m_parent->QueueFinishEvent();
542 }
543 }
544 }
545 }
546
547 protected:
548 Movie m_movie; // Our movie instance
549 wxQTMediaBackend* m_parent; //Backend pointer
550 wxQuickTimeLibrary* m_pLib; //Interfaces
551 };
552
553
554 //---------------------------------------------------------------------------
555 // wxQTMediaBackend::QTWndProc
556 //
557 // Forwards events to the Movie Controller so that it can
558 // redraw itself/process messages etc..
559 //---------------------------------------------------------------------------
560 LRESULT CALLBACK wxQTMediaBackend::QTWndProc(HWND hWnd, UINT nMsg,
561 WPARAM wParam, LPARAM lParam)
562 {
563 wxQTMediaBackend* pThis = (wxQTMediaBackend*)wxGetWindowUserData(hWnd);
564
565 MSG msg;
566 msg.hwnd = hWnd;
567 msg.message = nMsg;
568 msg.wParam = wParam;
569 msg.lParam = lParam;
570 msg.time = 0;
571 msg.pt.x = 0;
572 msg.pt.y = 0;
573 EventRecord theEvent;
574 pThis->m_lib.NativeEventToMacEvent(&msg, &theEvent);
575 pThis->m_lib.MCIsPlayerEvent(pThis->m_pMC, &theEvent);
576
577 return pThis->m_ctrl->MSWWindowProc(nMsg, wParam, lParam);
578 }
579
580 //---------------------------------------------------------------------------
581 // wxQTMediaBackend Destructor
582 //
583 // Sets m_timer to NULL signifying we havn't loaded anything yet
584 //---------------------------------------------------------------------------
585 wxQTMediaBackend::wxQTMediaBackend()
586 : m_movie(NULL), m_bPlaying(false), m_timer(NULL), m_pMC(NULL)
587 {
588 m_evthandler = NULL;
589 }
590
591 //---------------------------------------------------------------------------
592 // wxQTMediaBackend Destructor
593 //
594 // 1) Cleans up the QuickTime movie instance
595 // 2) Decrements the QuickTime reference counter - if this reaches
596 // 0, QuickTime shuts down
597 // 3) Decrements the QuickTime Windows Media Layer reference counter -
598 // if this reaches 0, QuickTime shuts down the Windows Media Layer
599 //---------------------------------------------------------------------------
600 wxQTMediaBackend::~wxQTMediaBackend()
601 {
602 if (m_movie)
603 Cleanup();
604
605 if (m_lib.IsOk())
606 {
607 if (m_pMC)
608 {
609 m_lib.DisposeMovieController(m_pMC);
610 // m_pMC = NULL;
611 }
612
613 // destroy wxQTMediaEvtHandler we pushed on it
614 if (m_evthandler)
615 {
616 m_ctrl->RemoveEventHandler(m_evthandler);
617 delete m_evthandler;
618 }
619
620 m_lib.DestroyPortAssociation(
621 (CGrafPtr)m_lib.GetNativeWindowPort(m_ctrl->GetHWND()));
622
623 //Note that ExitMovies() is not necessary, but
624 //the docs are fuzzy on whether or not TerminateQTML is
625 m_lib.ExitMovies();
626 m_lib.TerminateQTML();
627 }
628 }
629
630 //---------------------------------------------------------------------------
631 // wxQTMediaBackend::CreateControl
632 //
633 // 1) Intializes QuickTime
634 // 2) Creates the control window
635 //---------------------------------------------------------------------------
636 bool wxQTMediaBackend::CreateControl(wxControl* ctrl, wxWindow* parent,
637 wxWindowID id,
638 const wxPoint& pos,
639 const wxSize& size,
640 long style,
641 const wxValidator& validator,
642 const wxString& name)
643 {
644 if (!m_lib.Initialize())
645 return false;
646
647 int nError = m_lib.InitializeQTML(0);
648 if (nError != noErr) //-2093 no dll
649 {
650 wxFAIL_MSG(wxString::Format(wxT("Couldn't Initialize Quicktime-%i"), nError));
651 return false;
652 }
653
654 m_lib.EnterMovies();
655
656 // Create window
657 // By default wxWindow(s) is created with a border -
658 // so we need to get rid of those
659 //
660 // Since we don't have a child window like most other
661 // backends, we don't need wxCLIP_CHILDREN
662 if ( !ctrl->wxControl::Create(parent, id, pos, size,
663 (style & ~wxBORDER_MASK) | wxBORDER_NONE,
664 validator, name) )
665 {
666 return false;
667 }
668
669 m_ctrl = wxStaticCast(ctrl, wxMediaCtrl);
670
671 // Create a port association for our window so we
672 // can use it as a WindowRef
673 m_lib.CreatePortAssociation(m_ctrl->GetHWND(), NULL, 0L);
674
675 // Part of a suggestion from Greg Hazel
676 // to repaint movie when idle
677 m_evthandler = new wxQTMediaEvtHandler(this, m_ctrl->GetHWND());
678 m_ctrl->PushEventHandler(m_evthandler);
679
680 // done
681 return true;
682 }
683
684 //---------------------------------------------------------------------------
685 // wxQTMediaBackend::Load (file version)
686 //
687 // 1) Get an FSSpec from the Windows path name
688 // 2) Open the movie
689 // 3) Obtain the movie instance from the movie resource
690 // 4) Close the movie resource
691 // 5) Finish loading
692 //---------------------------------------------------------------------------
693 bool wxQTMediaBackend::Load(const wxString& fileName)
694 {
695 if (m_movie)
696 Cleanup();
697
698 bool result = true;
699 OSErr err = noErr;
700 short movieResFile = 0; //= 0 because of annoying VC6 warning
701 FSSpec sfFile;
702
703 err = m_lib.NativePathNameToFSSpec(
704 (char*) (const char*) fileName.mb_str(),
705 &sfFile, 0);
706 result = (err == noErr);
707
708 if (result)
709 {
710 err = m_lib.OpenMovieFile(&sfFile, &movieResFile, fsRdPerm);
711 result = (err == noErr);
712 }
713
714 if (result)
715 {
716 short movieResID = 0;
717 Str255 movieName;
718
719 err = m_lib.NewMovieFromFile(
720 &m_movie,
721 movieResFile,
722 &movieResID,
723 movieName,
724 newMovieActive,
725 NULL ); // wasChanged
726 result = (err == noErr /*&& m_lib.GetMoviesStickyError() == noErr*/);
727
728 // check m_lib.GetMoviesStickyError() because it may not find the
729 // proper codec and play black video and other strange effects,
730 // not to mention mess up the dynamic backend loading scheme
731 // of wxMediaCtrl - so it just does what the QuickTime player does
732 if (result)
733 {
734 m_lib.CloseMovieFile(movieResFile);
735 FinishLoad();
736 }
737 }
738
739 return result;
740 }
741
742 //---------------------------------------------------------------------------
743 // wxQTMediaBackend::PPRMProc (static)
744 //
745 // Called when done PrePrerolling the movie.
746 // Note that in 99% of the cases this does nothing...
747 // Anyway we set up the loading timer here to tell us when the movie is done
748 //---------------------------------------------------------------------------
749 void wxQTMediaBackend::PPRMProc (Movie theMovie,
750 OSErr WXUNUSED_UNLESS_DEBUG(theErr),
751 void* theRefCon)
752 {
753 wxASSERT( theMovie );
754 wxASSERT( theRefCon );
755 wxASSERT( theErr == noErr );
756
757 wxQTMediaBackend* pBE = (wxQTMediaBackend*) theRefCon;
758
759 long lTime = pBE->m_lib.GetMovieTime(theMovie,NULL);
760 Fixed rate = pBE->m_lib.GetMoviePreferredRate(theMovie);
761 pBE->m_lib.PrerollMovie(theMovie, lTime, rate);
762 pBE->m_timer = new wxQTLoadTimer(pBE->m_movie, pBE, &pBE->m_lib);
763 pBE->m_timer->Start(MOVIE_DELAY);
764 }
765
766 //---------------------------------------------------------------------------
767 // wxQTMediaBackend::Load (URL Version)
768 //
769 // 1) Build an escaped URI from location
770 // 2) Create a handle to store the URI string
771 // 3) Put the URI string inside the handle
772 // 4) Make a QuickTime URL data ref from the handle with the URI in it
773 // 5) Clean up the URI string handle
774 // 6) Do some prerolling
775 // 7) Finish Loading
776 //---------------------------------------------------------------------------
777 bool wxQTMediaBackend::Load(const wxURI& location)
778 {
779 if (m_movie)
780 Cleanup();
781
782 wxString theURI = location.BuildURI();
783
784 Handle theHandle = m_lib.NewHandleClear(theURI.length() + 1);
785 wxASSERT(theHandle);
786
787 m_lib.BlockMove(theURI.mb_str(), *theHandle, theURI.length() + 1);
788
789 // create the movie from the handle that refers to the URI
790 OSErr err = m_lib.NewMovieFromDataRef(&m_movie, newMovieActive |
791 newMovieAsyncOK
792 /* | newMovieIdleImportOK */,
793 NULL, theHandle,
794 URLDataHandlerSubType);
795
796 m_lib.DisposeHandle(theHandle);
797
798 if (err == noErr)
799 {
800 long timeNow;
801 Fixed playRate;
802
803 timeNow = m_lib.GetMovieTime(m_movie, NULL);
804 wxASSERT(m_lib.GetMoviesError() == noErr);
805
806 playRate = m_lib.GetMoviePreferredRate(m_movie);
807 wxASSERT(m_lib.GetMoviesError() == noErr);
808
809 // Note that the callback here is optional,
810 // but without it PrePrerollMovie can be buggy
811 // (see Apple ml). Also, some may wonder
812 // why we need this at all - this is because
813 // Apple docs say QuickTime streamed movies
814 // require it if you don't use a Movie Controller,
815 // which we don't by default.
816 //
817 m_lib.PrePrerollMovie(m_movie, timeNow, playRate,
818 (WXFARPROC)wxQTMediaBackend::PPRMProc,
819 (void*)this);
820
821 return true;
822 }
823 else
824 return false;
825 }
826
827 //---------------------------------------------------------------------------
828 // wxQTMediaBackend::FinishLoad
829 //
830 // 1) Create the movie timer
831 // 2) Get real size of movie for GetBestSize/sizers
832 // 3) Set the movie time scale to something usable so that seeking
833 // etc. will work correctly
834 // 4) Set our Movie Controller to display the movie if it exists,
835 // otherwise set the bounds of the Movie
836 // 5) Refresh parent window
837 //---------------------------------------------------------------------------
838 void wxQTMediaBackend::FinishLoad()
839 {
840 // Create the playing/streaming timer
841 m_timer = new wxQTPlayTimer(m_movie, (wxQTMediaBackend*) this, &m_lib);
842 wxASSERT(m_timer);
843
844 m_timer->Start(MOVIE_DELAY, wxTIMER_CONTINUOUS);
845
846 // get the real size of the movie
847 Rect outRect;
848 memset(&outRect, 0, sizeof(Rect)); // suppress annoying VC6 warning
849 m_lib.GetMovieNaturalBoundsRect (m_movie, &outRect);
850 wxASSERT(m_lib.GetMoviesError() == noErr);
851
852 m_bestSize.x = outRect.right - outRect.left;
853 m_bestSize.y = outRect.bottom - outRect.top;
854
855 // Handle the movie GWorld
856 if (m_pMC)
857 {
858 Point thePoint;
859 thePoint.h = thePoint.v = 0;
860 m_lib.MCSetMovie(m_pMC, m_movie,
861 m_lib.GetNativeWindowPort(m_ctrl->GetHandle()),
862 thePoint);
863 m_lib.MCSetVisible(m_pMC, true);
864 m_bestSize.y += 16;
865 }
866 else
867 {
868 m_lib.SetMovieGWorld(m_movie,
869 (CGrafPtr) m_lib.GetNativeWindowPort(m_ctrl->GetHWND()),
870 NULL);
871 }
872
873 // Set the movie to millisecond precision
874 m_lib.SetMovieTimeScale(m_movie, 1000);
875 wxASSERT(m_lib.GetMoviesError() == noErr);
876
877 NotifyMovieLoaded();
878 }
879
880 //---------------------------------------------------------------------------
881 // wxQTMediaBackend::Play
882 //
883 // 1) Start the QT movie
884 // 2) Start the movie loading timer
885 //
886 // NOTE: This will still return success even when
887 // the movie is still loading, and as mentioned in wxQTLoadTimer
888 // I don't know of a way to force this to be sync - so if its
889 // still loading the function will return true but the movie will
890 // still be in the stopped state
891 //---------------------------------------------------------------------------
892 bool wxQTMediaBackend::Play()
893 {
894 m_lib.StartMovie(m_movie);
895 m_bPlaying = true;
896
897 return m_lib.GetMoviesError() == noErr;
898 }
899
900 //---------------------------------------------------------------------------
901 // wxQTMediaBackend::Pause
902 //
903 // 1) Stop the movie
904 // 2) Stop the movie timer
905 //---------------------------------------------------------------------------
906 bool wxQTMediaBackend::Pause()
907 {
908 m_bPlaying = false;
909 m_lib.StopMovie(m_movie);
910
911 return m_lib.GetMoviesError() == noErr;
912 }
913
914 //---------------------------------------------------------------------------
915 // wxQTMediaBackend::Stop
916 //
917 // 1) Stop the movie
918 // 2) Stop the movie timer
919 // 3) Seek to the beginning of the movie
920 //---------------------------------------------------------------------------
921 bool wxQTMediaBackend::Stop()
922 {
923 m_bPlaying = false;
924
925 m_lib.StopMovie(m_movie);
926 if (m_lib.GetMoviesError() == noErr)
927 m_lib.GoToBeginningOfMovie(m_movie);
928
929 return m_lib.GetMoviesError() == noErr;
930 }
931
932 //---------------------------------------------------------------------------
933 // wxQTMediaBackend::GetPlaybackRate
934 //
935 // Get the movie playback rate from ::GetMovieRate
936 //---------------------------------------------------------------------------
937 double wxQTMediaBackend::GetPlaybackRate()
938 {
939 return ( ((double)m_lib.GetMovieRate(m_movie)) / 0x10000);
940 }
941
942 //---------------------------------------------------------------------------
943 // wxQTMediaBackend::SetPlaybackRate
944 //
945 // Convert dRate to Fixed and Set the movie rate through SetMovieRate
946 //---------------------------------------------------------------------------
947 bool wxQTMediaBackend::SetPlaybackRate(double dRate)
948 {
949 m_lib.SetMovieRate(m_movie, (Fixed) (dRate * 0x10000));
950
951 return m_lib.GetMoviesError() == noErr;
952 }
953
954 //---------------------------------------------------------------------------
955 // wxQTMediaBackend::SetPosition
956 //
957 // 1) Create a time record struct (TimeRecord) with appropriate values
958 // 2) Pass struct to SetMovieTime
959 //---------------------------------------------------------------------------
960 bool wxQTMediaBackend::SetPosition(wxLongLong where)
961 {
962 // NB: For some reason SetMovieTime does not work
963 // correctly with the Quicktime Windows SDK (6)
964 // From Muskelkatermann at the wxForum
965 // http://www.solidsteel.nl/users/wxwidgets/viewtopic.php?t=2957
966 // RN - note that I have not verified this but there
967 // is no harm in calling SetMovieTimeValue instead
968 #if 0
969 TimeRecord theTimeRecord;
970 memset(&theTimeRecord, 0, sizeof(TimeRecord));
971 theTimeRecord.value.lo = where.GetLo();
972 theTimeRecord.scale = m_lib.GetMovieTimeScale(m_movie);
973 theTimeRecord.base = m_lib.GetMovieTimeBase(m_movie);
974 m_lib.SetMovieTime(m_movie, &theTimeRecord);
975 #else
976 m_lib.SetMovieTimeValue(m_movie, where.GetLo());
977 #endif
978
979 return (m_lib.GetMoviesError() == noErr);
980 }
981
982 //---------------------------------------------------------------------------
983 // wxQTMediaBackend::GetPosition
984 //
985 // 1) Calls GetMovieTime to get the position we are in in the movie
986 // in milliseconds (we called
987 //---------------------------------------------------------------------------
988 wxLongLong wxQTMediaBackend::GetPosition()
989 {
990 return m_lib.GetMovieTime(m_movie, NULL);
991 }
992
993 //---------------------------------------------------------------------------
994 // wxQTMediaBackend::GetVolume
995 //
996 // Gets the volume through GetMovieVolume - which returns a 16 bit short -
997 //
998 // +--------+--------+
999 // + (1) + (2) +
1000 // +--------+--------+
1001 //
1002 // (1) first 8 bits are value before decimal
1003 // (2) second 8 bits are value after decimal
1004 //
1005 // Volume ranges from -1.0 (gain but no sound), 0 (no sound and no gain) to
1006 // 1 (full gain and sound)
1007 //---------------------------------------------------------------------------
1008 double wxQTMediaBackend::GetVolume()
1009 {
1010 short sVolume = m_lib.GetMovieVolume(m_movie);
1011 wxASSERT(m_lib.GetMoviesError() == noErr);
1012
1013 if (sVolume & (128 << 8)) //negative - no sound
1014 return 0.0;
1015
1016 return sVolume / 256.0;
1017 }
1018
1019 //---------------------------------------------------------------------------
1020 // wxQTMediaBackend::SetVolume
1021 //
1022 // Sets the volume through SetMovieVolume - which takes a 16 bit short -
1023 //
1024 // +--------+--------+
1025 // + (1) + (2) +
1026 // +--------+--------+
1027 //
1028 // (1) first 8 bits are value before decimal
1029 // (2) second 8 bits are value after decimal
1030 //
1031 // Volume ranges from -1.0 (gain but no sound), 0 (no sound and no gain) to
1032 // 1 (full gain and sound)
1033 //---------------------------------------------------------------------------
1034 bool wxQTMediaBackend::SetVolume(double dVolume)
1035 {
1036 m_lib.SetMovieVolume(m_movie, (short) (dVolume * 256));
1037 return m_lib.GetMoviesError() == noErr;
1038 }
1039
1040 //---------------------------------------------------------------------------
1041 // wxQTMediaBackend::GetDuration
1042 //
1043 // Calls GetMovieDuration
1044 //---------------------------------------------------------------------------
1045 wxLongLong wxQTMediaBackend::GetDuration()
1046 {
1047 return m_lib.GetMovieDuration(m_movie);
1048 }
1049
1050 //---------------------------------------------------------------------------
1051 // wxQTMediaBackend::GetState
1052 //
1053 // Determines the current state:
1054 // if we are at the beginning, then we are stopped
1055 //---------------------------------------------------------------------------
1056 wxMediaState wxQTMediaBackend::GetState()
1057 {
1058 if (m_bPlaying)
1059 return wxMEDIASTATE_PLAYING;
1060 else if ( !m_movie || wxQTMediaBackend::GetPosition() == 0 )
1061 return wxMEDIASTATE_STOPPED;
1062 else
1063 return wxMEDIASTATE_PAUSED;
1064 }
1065
1066 //---------------------------------------------------------------------------
1067 // wxQTMediaBackend::Cleanup
1068 //
1069 // Diposes of the movie timer, Disassociates the Movie Controller with
1070 // movie and hides it if it exists, and stops and disposes
1071 // of the QT movie
1072 //---------------------------------------------------------------------------
1073 void wxQTMediaBackend::Cleanup()
1074 {
1075 m_bPlaying = false;
1076
1077 if (m_timer)
1078 {
1079 delete m_timer;
1080 m_timer = NULL;
1081 }
1082
1083 m_lib.StopMovie(m_movie);
1084
1085 if (m_pMC)
1086 {
1087 Point thePoint;
1088 thePoint.h = thePoint.v = 0;
1089 m_lib.MCSetVisible(m_pMC, false);
1090 m_lib.MCSetMovie(m_pMC, NULL, NULL, thePoint);
1091 }
1092
1093 m_lib.DisposeMovie(m_movie);
1094 m_movie = NULL;
1095 }
1096
1097 //---------------------------------------------------------------------------
1098 // wxQTMediaBackend::ShowPlayerControls
1099 //
1100 // Creates a movie controller for the Movie if the user wants it
1101 //---------------------------------------------------------------------------
1102 bool wxQTMediaBackend::ShowPlayerControls(wxMediaCtrlPlayerControls flags)
1103 {
1104 if (m_pMC)
1105 {
1106 // restore old wndproc
1107 wxSetWindowProc((HWND)m_ctrl->GetHWND(), wxWndProc);
1108 m_lib.DisposeMovieController(m_pMC);
1109 m_pMC = NULL;
1110
1111 // movie controller height
1112 m_bestSize.y -= 16;
1113 }
1114
1115 if (flags && m_movie)
1116 {
1117 Rect rect;
1118 wxRect wxrect = m_ctrl->GetClientRect();
1119
1120 // make room for controller
1121 if (wxrect.width < 320)
1122 wxrect.width = 320;
1123
1124 rect.top = (short)wxrect.y;
1125 rect.left = (short)wxrect.x;
1126 rect.right = (short)(rect.left + wxrect.width);
1127 rect.bottom = (short)(rect.top + wxrect.height);
1128
1129 if (!m_pMC)
1130 {
1131 m_pMC = m_lib.NewMovieController(m_movie, &rect, mcTopLeftMovie |
1132 // mcScaleMovieToFit |
1133 // mcWithBadge |
1134 mcWithFrame);
1135 m_lib.MCDoAction(m_pMC, 32, (void*)true); // mcActionSetKeysEnabled
1136 m_lib.MCSetActionFilterWithRefCon(m_pMC,
1137 (WXFARPROC)wxQTMediaBackend::MCFilterProc, (void*)this);
1138 m_bestSize.y += 16; // movie controller height
1139
1140 // By default the movie controller uses its own colour palette
1141 // for the movie which can be bad on some files, so turn it off.
1142 // Also turn off its frame / border for the movie
1143 // Also take care of a couple of the interface flags here
1144 long mcFlags = 0;
1145 m_lib.MCDoAction(m_pMC, 39/*mcActionGetFlags*/, (void*)&mcFlags);
1146
1147 mcFlags |=
1148 // (1<< 0) /*mcFlagSuppressMovieFrame*/ |
1149 (1<< 3) /*mcFlagsUseWindowPalette*/
1150 | ((flags & wxMEDIACTRLPLAYERCONTROLS_STEP)
1151 ? 0 : (1<< 1) /*mcFlagSuppressStepButtons*/)
1152 | ((flags & wxMEDIACTRLPLAYERCONTROLS_VOLUME)
1153 ? 0 : (1<< 2) /*mcFlagSuppressSpeakerButton*/)
1154 // | (1<< 4) /*mcFlagDontInvalidate*/ // if we take care of repainting ourselves
1155 ;
1156
1157 m_lib.MCDoAction(m_pMC, 38/*mcActionSetFlags*/, wxUIntToPtr(mcFlags));
1158
1159 // intercept the wndproc of our control window
1160 wxSetWindowProc((HWND)m_ctrl->GetHWND(), wxQTMediaBackend::QTWndProc);
1161
1162 // set the user data of our window
1163 wxSetWindowUserData((HWND)m_ctrl->GetHWND(), this);
1164 }
1165 }
1166
1167 NotifyMovieSizeChanged();
1168
1169 return m_lib.GetMoviesError() == noErr;
1170 }
1171
1172 //---------------------------------------------------------------------------
1173 // wxQTMediaBackend::MCFilterProc (static)
1174 //
1175 // Callback for when the movie controller recieves a message
1176 //---------------------------------------------------------------------------
1177 Boolean wxQTMediaBackend::MCFilterProc(MovieController WXUNUSED(theController),
1178 short action,
1179 void * WXUNUSED(params),
1180 LONG_PTR refCon)
1181 {
1182 // NB: potential optimisation
1183 // if (action == 1)
1184 // return 0;
1185
1186 wxQTMediaBackend* pThis = (wxQTMediaBackend*)refCon;
1187
1188 switch (action)
1189 {
1190 case 1:
1191 // don't process idle events
1192 break;
1193
1194 case 8:
1195 // play button triggered - MC will set movie to opposite state
1196 // of current - playing ? paused : playing
1197 if (pThis)
1198 pThis->m_bPlaying = !(pThis->m_bPlaying);
1199
1200 // NB: Sometimes it doesn't redraw properly -
1201 // if you click on the button but don't move the mouse
1202 // the button will not change its state until you move
1203 // mcActionDraw and Refresh/Update combo do nothing
1204 // to help this unfortunately
1205 break;
1206
1207 default:
1208 break;
1209 }
1210
1211 return 0;
1212 }
1213
1214 //---------------------------------------------------------------------------
1215 // wxQTMediaBackend::GetVideoSize
1216 //
1217 // Returns the actual size of the QT movie
1218 //---------------------------------------------------------------------------
1219 wxSize wxQTMediaBackend::GetVideoSize() const
1220 {
1221 return m_bestSize;
1222 }
1223
1224 //---------------------------------------------------------------------------
1225 // wxQTMediaBackend::Move
1226 //
1227 // Sets the bounds of either the Movie or Movie Controller
1228 //---------------------------------------------------------------------------
1229 void wxQTMediaBackend::Move(int WXUNUSED(x), int WXUNUSED(y), int w, int h)
1230 {
1231 if (m_movie)
1232 {
1233 // make room for controller
1234 if (m_pMC)
1235 {
1236 if (w < 320)
1237 w = 320;
1238
1239 Rect theRect = {0, 0, (short)h, (short)w};
1240 m_lib.MCSetControllerBoundsRect(m_pMC, &theRect);
1241 }
1242 else
1243 {
1244 Rect theRect = {0, 0, (short)h, (short)w};
1245 m_lib.SetMovieBox(m_movie, &theRect);
1246 }
1247
1248 wxASSERT(m_lib.GetMoviesError() == noErr);
1249 }
1250 }
1251
1252 //---------------------------------------------------------------------------
1253 // wxQTMediaBackend::OnEraseBackground
1254 //
1255 // Suggestion from Greg Hazel to repaint the movie when idle
1256 // (on pause also)
1257 //
1258 // TODO: We may be repainting too much here - under what exact circumstances
1259 // do we need this? I think Move also repaints correctly for the Movie
1260 // Controller, so in that instance we don't need this either
1261 //---------------------------------------------------------------------------
1262 void wxQTMediaEvtHandler::OnEraseBackground(wxEraseEvent& evt)
1263 {
1264 wxQuickTimeLibrary& m_pLib = m_qtb->m_lib;
1265
1266 if ( m_qtb->m_pMC )
1267 {
1268 // repaint movie controller
1269 m_pLib.MCDoAction(m_qtb->m_pMC, 2 /*mcActionDraw*/,
1270 m_pLib.GetNativeWindowPort(m_hwnd));
1271 }
1272 else if ( m_qtb->m_movie )
1273 {
1274 // no movie controller
1275 CGrafPtr port = (CGrafPtr)m_pLib.GetNativeWindowPort(m_hwnd);
1276
1277 m_pLib.BeginUpdate(port);
1278 m_pLib.UpdateMovie(m_qtb->m_movie);
1279 wxASSERT(m_pLib.GetMoviesError() == noErr);
1280 m_pLib.EndUpdate(port);
1281 }
1282 else
1283 {
1284 // no movie
1285 // let the system repaint the window
1286 evt.Skip();
1287 }
1288 }
1289
1290 //---------------------------------------------------------------------------
1291 // End QT Backend
1292 //---------------------------------------------------------------------------
1293
1294 // in source file that contains stuff you don't directly use
1295 #include "wx/html/forcelnk.h"
1296 FORCE_LINK_ME(wxmediabackend_qt)
1297
1298 #endif // wxUSE_MEDIACTRL && wxUSE_ACTIVEX
wxWidgets (Impactor)