include/wx/mediactrl.h

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        wx/mediactrl.h
   3 // Purpose:     wxMediaCtrl class
   4 // Author:      Ryan Norton <wxprojects@comcast.net>
   5 // Modified by:
   6 // Created:     11/07/04
   7 // Copyright:   (c) Ryan Norton
   8 // Licence:     wxWindows licence
   9 ///////////////////////////////////////////////////////////////////////////////
  10
  11 // ============================================================================
  12 // Definitions
  13 // ============================================================================
  14
  15 // ----------------------------------------------------------------------------
  16 // Header guard
  17 // ----------------------------------------------------------------------------
  18 #ifndef _WX_MEDIACTRL_H_
  19 #define _WX_MEDIACTRL_H_
  20
  21 // ----------------------------------------------------------------------------
  22 // Pre-compiled header stuff
  23 // ----------------------------------------------------------------------------
  24
  25 #include "wx/defs.h"
  26
  27 // ----------------------------------------------------------------------------
  28 // Compilation guard
  29 // ----------------------------------------------------------------------------
  30
  31 #if wxUSE_MEDIACTRL
  32
  33 // ----------------------------------------------------------------------------
  34 // Includes
  35 // ----------------------------------------------------------------------------
  36
  37 #include "wx/control.h"
  38 #include "wx/uri.h"
  39
  40 // ============================================================================
  41 // Declarations
  42 // ============================================================================
  43
  44 // ----------------------------------------------------------------------------
  45 //
  46 // Enumerations
  47 //
  48 // ----------------------------------------------------------------------------
  49
  50 enum wxMediaState
  51 {
  52     wxMEDIASTATE_STOPPED,
  53     wxMEDIASTATE_PAUSED,
  54     wxMEDIASTATE_PLAYING
  55 };
  56
  57 enum wxMediaCtrlPlayerControls
  58 {
  59     wxMEDIACTRLPLAYERCONTROLS_NONE           =   0,
  60     //Step controls like fastforward, step one frame etc.
  61     wxMEDIACTRLPLAYERCONTROLS_STEP           =   1 << 0,
  62     //Volume controls like the speaker icon, volume slider, etc.
  63     wxMEDIACTRLPLAYERCONTROLS_VOLUME         =   1 << 1,
  64     wxMEDIACTRLPLAYERCONTROLS_DEFAULT        =
  65                     wxMEDIACTRLPLAYERCONTROLS_STEP |
  66                     wxMEDIACTRLPLAYERCONTROLS_VOLUME
  67 };
  68
  69 #define wxMEDIABACKEND_DIRECTSHOW   wxT("wxAMMediaBackend")
  70 #define wxMEDIABACKEND_MCI          wxT("wxMCIMediaBackend")
  71 #define wxMEDIABACKEND_QUICKTIME    wxT("wxQTMediaBackend")
  72 #define wxMEDIABACKEND_GSTREAMER    wxT("wxGStreamerMediaBackend")
  73 #define wxMEDIABACKEND_REALPLAYER   wxT("wxRealPlayerMediaBackend")
  74 #define wxMEDIABACKEND_WMP10        wxT("wxWMP10MediaBackend")
  75
  76 // ----------------------------------------------------------------------------
  77 //
  78 // wxMediaEvent
  79 //
  80 // ----------------------------------------------------------------------------
  81
  82 class WXDLLIMPEXP_MEDIA wxMediaEvent : public wxNotifyEvent
  83 {
  84 public:
  85     // ------------------------------------------------------------------------
  86     // wxMediaEvent Constructor
  87     //
  88     // Normal constructor, much the same as wxNotifyEvent
  89     // ------------------------------------------------------------------------
  90     wxMediaEvent(wxEventType commandType = wxEVT_NULL, int winid = 0)
  91         : wxNotifyEvent(commandType, winid)
  92     {                                       }
  93
  94     // ------------------------------------------------------------------------
  95     // wxMediaEvent Copy Constructor
  96     //
  97     // Normal copy constructor, much the same as wxNotifyEvent
  98     // ------------------------------------------------------------------------
  99     wxMediaEvent(const wxMediaEvent &clone)
 100             : wxNotifyEvent(clone)
 101     {                                       }
 102
 103     // ------------------------------------------------------------------------
 104     // wxMediaEvent::Clone
 105     //
 106     // Allocates a copy of this object.
 107     // Required for wxEvtHandler::AddPendingEvent
 108     // ------------------------------------------------------------------------
 109     virtual wxEvent *Clone() const
 110     {   return new wxMediaEvent(*this);     }
 111
 112
 113     // Put this class on wxWidget's RTTI table
 114     DECLARE_DYNAMIC_CLASS(wxMediaEvent)
 115 };
 116
 117 // ----------------------------------------------------------------------------
 118 //
 119 // wxMediaCtrl
 120 //
 121 // ----------------------------------------------------------------------------
 122
 123 class WXDLLIMPEXP_MEDIA wxMediaCtrl : public wxControl
 124 {
 125 public:
 126     wxMediaCtrl() : m_imp(NULL), m_bLoaded(false)
 127     {                                                                   }
 128
 129     wxMediaCtrl(wxWindow* parent, wxWindowID winid,
 130                 const wxString& fileName = wxEmptyString,
 131                 const wxPoint& pos = wxDefaultPosition,
 132                 const wxSize& size = wxDefaultSize,
 133                 long style = 0,
 134                 const wxString& szBackend = wxEmptyString,
 135                 const wxValidator& validator = wxDefaultValidator,
 136                 const wxString& name = wxT("mediaCtrl"))
 137                 : m_imp(NULL), m_bLoaded(false)
 138     {   Create(parent, winid, fileName, pos, size, style,
 139                szBackend, validator, name);                             }
 140
 141     wxMediaCtrl(wxWindow* parent, wxWindowID winid,
 142                 const wxURI& location,
 143                 const wxPoint& pos = wxDefaultPosition,
 144                 const wxSize& size = wxDefaultSize,
 145                 long style = 0,
 146                 const wxString& szBackend = wxEmptyString,
 147                 const wxValidator& validator = wxDefaultValidator,
 148                 const wxString& name = wxT("mediaCtrl"))
 149                 : m_imp(NULL), m_bLoaded(false)
 150     {   Create(parent, winid, location, pos, size, style,
 151                szBackend, validator, name);                             }
 152
 153     virtual ~wxMediaCtrl();
 154
 155     bool Create(wxWindow* parent, wxWindowID winid,
 156                 const wxString& fileName = wxEmptyString,
 157                 const wxPoint& pos = wxDefaultPosition,
 158                 const wxSize& size = wxDefaultSize,
 159                 long style = 0,
 160                 const wxString& szBackend = wxEmptyString,
 161                 const wxValidator& validator = wxDefaultValidator,
 162                 const wxString& name = wxT("mediaCtrl"));
 163
 164     bool Create(wxWindow* parent, wxWindowID winid,
 165                 const wxURI& location,
 166                 const wxPoint& pos = wxDefaultPosition,
 167                 const wxSize& size = wxDefaultSize,
 168                 long style = 0,
 169                 const wxString& szBackend = wxEmptyString,
 170                 const wxValidator& validator = wxDefaultValidator,
 171                 const wxString& name = wxT("mediaCtrl"));
 172
 173     bool DoCreate(const wxClassInfo* instance,
 174                 wxWindow* parent, wxWindowID winid,
 175                 const wxPoint& pos = wxDefaultPosition,
 176                 const wxSize& size = wxDefaultSize,
 177                 long style = 0,
 178                 const wxValidator& validator = wxDefaultValidator,
 179                 const wxString& name = wxT("mediaCtrl"));
 180
 181     bool Play();
 182     bool Pause();
 183     bool Stop();
 184
 185     bool Load(const wxString& fileName);
 186
 187     wxMediaState GetState();
 188
 189     wxFileOffset Seek(wxFileOffset where, wxSeekMode mode = wxFromStart);
 190     wxFileOffset Tell(); //FIXME: This should be const
 191     wxFileOffset Length(); //FIXME: This should be const
 192
 193     double GetPlaybackRate();           //All but MCI & GStreamer
 194     bool SetPlaybackRate(double dRate); //All but MCI & GStreamer
 195
 196     bool Load(const wxURI& location);
 197     bool Load(const wxURI& location, const wxURI& proxy);
 198
 199     wxFileOffset GetDownloadProgress(); // DirectShow only
 200     wxFileOffset GetDownloadTotal();    // DirectShow only
 201
 202     double GetVolume();
 203     bool   SetVolume(double dVolume);
 204
 205     bool    ShowPlayerControls(
 206         wxMediaCtrlPlayerControls flags = wxMEDIACTRLPLAYERCONTROLS_DEFAULT);
 207
 208     //helpers for the wxPython people
 209     bool LoadURI(const wxString& fileName)
 210     {   return Load(wxURI(fileName));       }
 211     bool LoadURIWithProxy(const wxString& fileName, const wxString& proxy)
 212     {   return Load(wxURI(fileName), wxURI(proxy));       }
 213
 214 protected:
 215     static const wxClassInfo* NextBackend(wxClassInfo::const_iterator* it);
 216
 217     void OnMediaFinished(wxMediaEvent& evt);
 218     virtual void DoMoveWindow(int x, int y, int w, int h);
 219     wxSize DoGetBestSize() const;
 220
 221     //FIXME:  This is nasty... find a better way to work around
 222     //inheritance issues
 223 #if defined(__WXOSX_CARBON__)
 224     virtual void MacVisibilityChanged();
 225 #endif
 226 #if defined(__WXOSX_CARBON__) || defined(__WXCOCOA__)
 227     friend class wxQTMediaBackend;
 228 #endif
 229     class wxMediaBackend* m_imp;
 230     bool m_bLoaded;
 231
 232     DECLARE_DYNAMIC_CLASS(wxMediaCtrl)
 233 };
 234
 235 // ----------------------------------------------------------------------------
 236 //
 237 // wxMediaBackend
 238 //
 239 // Derive from this and use standard wxWidgets RTTI
 240 // (DECLARE_DYNAMIC_CLASS and IMPLEMENT_CLASS) to make a backend
 241 // for wxMediaCtrl.  Backends are searched alphabetically -
 242 // the one with the earliest letter is tried first.
 243 //
 244 // Note that this is currently not API or ABI compatible -
 245 // so statically link or make the client compile on-site.
 246 //
 247 // ----------------------------------------------------------------------------
 248
 249 class WXDLLIMPEXP_MEDIA wxMediaBackend : public wxObject
 250 {
 251 public:
 252     wxMediaBackend()
 253     {                                   }
 254
 255     virtual ~wxMediaBackend();
 256
 257     virtual bool CreateControl(wxControl* WXUNUSED(ctrl),
 258                                wxWindow* WXUNUSED(parent),
 259                                wxWindowID WXUNUSED(winid),
 260                                const wxPoint& WXUNUSED(pos),
 261                                const wxSize& WXUNUSED(size),
 262                                long WXUNUSED(style),
 263                                const wxValidator& WXUNUSED(validator),
 264                                const wxString& WXUNUSED(name))
 265     {   return false;                   }
 266
 267     virtual bool Play()
 268     {   return false;                   }
 269     virtual bool Pause()
 270     {   return false;                   }
 271     virtual bool Stop()
 272     {   return false;                   }
 273
 274     virtual bool Load(const wxString& WXUNUSED(fileName))
 275     {   return false;                   }
 276     virtual bool Load(const wxURI& WXUNUSED(location))
 277     {   return false;                   }
 278
 279     virtual bool SetPosition(wxLongLong WXUNUSED(where))
 280     {   return 0;                       }
 281     virtual wxLongLong GetPosition()
 282     {   return 0;                       }
 283     virtual wxLongLong GetDuration()
 284     {   return 0;                       }
 285
 286     virtual void Move(int WXUNUSED(x), int WXUNUSED(y),
 287                       int WXUNUSED(w), int WXUNUSED(h))
 288     {                                   }
 289     virtual wxSize GetVideoSize() const
 290     {   return wxSize(0,0);             }
 291
 292     virtual double GetPlaybackRate()
 293     {   return 0.0;                     }
 294     virtual bool SetPlaybackRate(double WXUNUSED(dRate))
 295     {   return false;                   }
 296
 297     virtual wxMediaState GetState()
 298     {   return wxMEDIASTATE_STOPPED;    }
 299
 300     virtual double GetVolume()
 301     {   return 0.0;                     }
 302     virtual bool SetVolume(double WXUNUSED(dVolume))
 303     {   return false;                   }
 304
 305     virtual bool Load(const wxURI& WXUNUSED(location),
 306                       const wxURI& WXUNUSED(proxy))
 307     {   return false;                   }
 308
 309     virtual bool   ShowPlayerControls(
 310                     wxMediaCtrlPlayerControls WXUNUSED(flags))
 311     {   return false;                   }
 312     virtual bool   IsInterfaceShown()
 313     {   return false;                   }
 314
 315     virtual wxLongLong GetDownloadProgress()
 316     {    return 0;                      }
 317     virtual wxLongLong GetDownloadTotal()
 318     {    return 0;                      }
 319
 320     virtual void MacVisibilityChanged()
 321     {                                   }
 322     virtual void RESERVED9() {}
 323
 324     DECLARE_DYNAMIC_CLASS(wxMediaBackend)
 325 };
 326
 327
 328 //Our events
 329 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_MEDIA, wxEVT_MEDIA_FINISHED, wxMediaEvent );
 330 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_MEDIA, wxEVT_MEDIA_STOP, wxMediaEvent );
 331
 332 //Function type(s) our events need
 333 typedef void (wxEvtHandler::*wxMediaEventFunction)(wxMediaEvent&);
 334
 335 #define wxMediaEventHandler(func) \
 336     wxEVENT_HANDLER_CAST(wxMediaEventFunction, func)
 337
 338 //Macro for usage with message maps
 339 #define EVT_MEDIA_FINISHED(winid, fn)   wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_MEDIA_FINISHED, winid, wxID_ANY, wxMediaEventHandler(fn), NULL ),
 340 #define EVT_MEDIA_STOP(winid, fn)       wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_MEDIA_STOP, winid, wxID_ANY, wxMediaEventHandler(fn), NULL ),
 341
 342 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_MEDIA, wxEVT_MEDIA_LOADED, wxMediaEvent );
 343 #define EVT_MEDIA_LOADED(winid, fn)     wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_MEDIA_LOADED, winid, wxID_ANY, wxMediaEventHandler(fn), NULL ),
 344
 345 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_MEDIA, wxEVT_MEDIA_STATECHANGED, wxMediaEvent );
 346 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_MEDIA, wxEVT_MEDIA_PLAY, wxMediaEvent );
 347 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_MEDIA, wxEVT_MEDIA_PAUSE, wxMediaEvent );
 348 #define EVT_MEDIA_STATECHANGED(winid, fn)   wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_MEDIA_STATECHANGED, winid, wxID_ANY, wxMediaEventHandler(fn), NULL ),
 349 #define EVT_MEDIA_PLAY(winid, fn)           wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_MEDIA_PLAY, winid, wxID_ANY, wxMediaEventHandler(fn), NULL ),
 350 #define EVT_MEDIA_PAUSE(winid, fn)          wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_MEDIA_PAUSE, winid, wxID_ANY, wxMediaEventHandler(fn), NULL ),
 351
 352 // ----------------------------------------------------------------------------
 353 // common backend base class used by many other backends
 354 // ----------------------------------------------------------------------------
 355
 356 class WXDLLIMPEXP_MEDIA wxMediaBackendCommonBase : public wxMediaBackend
 357 {
 358 public:
 359     // add a pending wxMediaEvent of the given type
 360     void QueueEvent(wxEventType evtType);
 361
 362     // notify that the movie playback is finished
 363     void QueueFinishEvent()
 364     {
 365         QueueEvent(wxEVT_MEDIA_STATECHANGED);
 366         QueueEvent(wxEVT_MEDIA_FINISHED);
 367     }
 368
 369     // send the stop event and return true if it hasn't been vetoed
 370     bool SendStopEvent();
 371
 372     // Queue pause event
 373     void QueuePlayEvent();
 374
 375     // Queue pause event
 376     void QueuePauseEvent();
 377
 378     // Queue stop event (no veto)
 379     void QueueStopEvent();
 380
 381 protected:
 382     // call this when the movie size has changed but not because it has just
 383     // been loaded (in this case, call NotifyMovieLoaded() below)
 384     void NotifyMovieSizeChanged();
 385
 386     // call this when the movie is fully loaded
 387     void NotifyMovieLoaded();
 388
 389
 390     wxMediaCtrl *m_ctrl;      // parent control
 391 };
 392
 393 // ----------------------------------------------------------------------------
 394 // End compilation guard
 395 // ----------------------------------------------------------------------------
 396 #endif // wxUSE_MEDIACTRL
 397
 398 // ----------------------------------------------------------------------------
 399 // End header guard and header itself
 400 // ----------------------------------------------------------------------------
 401 #endif // _WX_MEDIACTRL_H_
 402
 403