git.sesse.net Git - vlc/blob - projects/activex/vlccontrol2.h

   1 /*****************************************************************************
   2  * vlccontrol.h: ActiveX control for VLC
   3  *****************************************************************************
   4  * Copyright (C) 2006 the VideoLAN team
   5  * Copyright (C) 2010 M2X BV
   6  *
   7  * Authors: Damien Fouilleul <Damien.Fouilleul@laposte.net>
   8  *          Jean-Paul Saman <jpsaman _at_ m2x _dot_ nl>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License along
  21  * with this program; if not, write to the Free Software Foundation, Inc.,
  22  * 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  23  *****************************************************************************/
  24
  25 #ifndef _VLCCONTROL2_H_
  26 #define _VLCCONTROL2_H_
  27
  28 #include "axvlc_idl.h"
  29
  30 #include <vlc/libvlc.h>
  31 #include <ole2.h>
  32
  33 class VLCInterfaceBase {
  34 public:
  35     VLCInterfaceBase(VLCPlugin *p): _plug(p), _ti(NULL) { }
  36     virtual ~VLCInterfaceBase() { if( _ti ) _ti->Release(); }
  37
  38     VLCPlugin *Instance() const { return _plug; }
  39     HRESULT getVLC(libvlc_instance_t **pp) const { return _plug->getVLC(pp); }
  40     HRESULT getMD(libvlc_media_player_t **pp) const { return _plug->getMD(pp); }
  41
  42 protected:
  43     HRESULT loadTypeInfo(REFIID riid);
  44     ITypeInfo *TypeInfo() const { return _ti; }
  45
  46     STDMETHODIMP_(ULONG) AddRef(void) { return _plug->pUnkOuter->AddRef(); };
  47     STDMETHODIMP_(ULONG) Release(void) { return _plug->pUnkOuter->Release(); };
  48 private:
  49     VLCPlugin *_plug;
  50     ITypeInfo *_ti;
  51 };
  52
  53 template<class T,class I>
  54 class VLCInterface: public I, private VLCInterfaceBase
  55 {
  56 private:
  57     typedef VLCInterfaceBase Base;
  58           T *This()       { return static_cast<      T *>(this); }
  59     const T *This() const { return static_cast<const T *>(this); }
  60
  61     HRESULT loadTypeInfo()
  62     {
  63         return TypeInfo() ? NOERROR : Base::loadTypeInfo(_riid);
  64     }
  65
  66 public:
  67     VLCInterface(VLCPlugin *p): Base(p) { }
  68     VLCPlugin *Instance() const { return Base::Instance(); }
  69
  70     HRESULT getVLC(libvlc_instance_t **pp) const { return Base::getVLC(pp); }
  71     HRESULT getMD(libvlc_media_player_t **pp) const { return Base::getMD(pp); }
  72
  73     STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
  74     {
  75         if( NULL == ppv ) return E_POINTER;
  76
  77         if( (IID_IUnknown == riid)
  78          || (IID_IDispatch == riid)
  79          || (_riid == riid) )
  80         {
  81             This()->AddRef();
  82             *ppv = reinterpret_cast<LPVOID>(This());
  83             return NOERROR;
  84         }
  85         // behaves as a standalone object
  86         return E_NOINTERFACE;
  87     }
  88
  89     STDMETHODIMP GetTypeInfoCount(UINT* pctInfo)
  90     {
  91         if( NULL == pctInfo )
  92             return E_INVALIDARG;
  93         *pctInfo = SUCCEEDED(loadTypeInfo()) ? 1 : 0;
  94         return NOERROR;
  95     }
  96     STDMETHODIMP GetTypeInfo(UINT iTInfo, LCID lcid, LPTYPEINFO* ppTInfo)
  97     {
  98         if( NULL == ppTInfo )
  99             return E_INVALIDARG;
 100
 101         if( SUCCEEDED(loadTypeInfo()) )
 102         {
 103             (*ppTInfo = TypeInfo())->AddRef();
 104             return NOERROR;
 105         }
 106         *ppTInfo = NULL;
 107         return E_NOTIMPL;
 108     }
 109
 110     STDMETHODIMP GetIDsOfNames(REFIID riid, LPOLESTR* rgszNames,
 111             UINT cNames, LCID lcid, DISPID* rgDispID)
 112     {
 113         return FAILED(loadTypeInfo()) ? E_NOTIMPL :
 114             DispGetIDsOfNames(TypeInfo(), rgszNames, cNames, rgDispID);
 115     }
 116
 117     STDMETHODIMP Invoke(DISPID dispIdMember, REFIID riid,
 118         LCID lcid, WORD wFlags, DISPPARAMS* pDispParams,
 119         VARIANT* pVarResult, EXCEPINFO* pExcepInfo, UINT* puArgErr)
 120     {
 121         return FAILED(loadTypeInfo()) ? E_NOTIMPL :
 122             DispInvoke(This(), TypeInfo(), dispIdMember, wFlags,
 123                        pDispParams, pVarResult, pExcepInfo, puArgErr);
 124     }
 125
 126     STDMETHODIMP_(ULONG) AddRef(void)  { return Base::AddRef(); };
 127     STDMETHODIMP_(ULONG) Release(void) { return Base::Release(); };
 128 private:
 129     static REFIID _riid;
 130 };
 131
 132 class VLCAudio : public VLCInterface<VLCAudio,IVLCAudio>
 133 {
 134 public:
 135     VLCAudio(VLCPlugin *p): VLCInterface<VLCAudio,IVLCAudio>(p) { }
 136
 137     // IVLCAudio methods
 138     STDMETHODIMP get_mute(VARIANT_BOOL*);
 139     STDMETHODIMP put_mute(VARIANT_BOOL);
 140     STDMETHODIMP get_volume(long*);
 141     STDMETHODIMP put_volume(long);
 142     STDMETHODIMP get_track(long*);
 143     STDMETHODIMP put_track(long);
 144     STDMETHODIMP get_count(long*);
 145     STDMETHODIMP get_channel(long*);
 146     STDMETHODIMP put_channel(long);
 147     STDMETHODIMP toggleMute();
 148     STDMETHODIMP description(long, BSTR*);
 149 };
 150
 151 class VLCInput: public VLCInterface<VLCInput,IVLCInput>
 152 {
 153 public:
 154     VLCInput(VLCPlugin *p): VLCInterface<VLCInput,IVLCInput>(p) { }
 155
 156     // IVLCInput methods
 157     STDMETHODIMP get_length(double*);
 158     STDMETHODIMP get_position(double*);
 159     STDMETHODIMP put_position(double);
 160     STDMETHODIMP get_time(double*);
 161     STDMETHODIMP put_time(double);
 162     STDMETHODIMP get_state(long*);
 163     STDMETHODIMP get_rate(double*);
 164     STDMETHODIMP put_rate(double);
 165     STDMETHODIMP get_fps(double*);
 166     STDMETHODIMP get_hasVout(VARIANT_BOOL*);
 167 };
 168
 169 class VLCMarquee: public VLCInterface<VLCMarquee,IVLCMarquee>
 170 {
 171 public:
 172     VLCMarquee(VLCPlugin *p): VLCInterface<VLCMarquee,IVLCMarquee>(p) { }
 173
 174     // IVLCMarquee methods
 175     STDMETHODIMP enable()  { return do_put_int(libvlc_marquee_Enable, true); }
 176     STDMETHODIMP disable() { return do_put_int(libvlc_marquee_Enable, false); }
 177
 178     STDMETHODIMP get_text(BSTR *);
 179     STDMETHODIMP put_text(BSTR);
 180     STDMETHODIMP get_position(BSTR *);
 181     STDMETHODIMP put_position(BSTR);
 182
 183 #define PROP_INT( a, b ) \
 184         STDMETHODIMP get_##a(LONG *val) { return do_get_int(b,val); } \
 185         STDMETHODIMP put_##a(LONG val)  { return do_put_int(b,val); }
 186
 187     PROP_INT( color,    libvlc_marquee_Color )
 188     PROP_INT( opacity,  libvlc_marquee_Opacity )
 189     PROP_INT( refresh,  libvlc_marquee_Refresh )
 190     PROP_INT( size,     libvlc_marquee_Size )
 191     PROP_INT( timeout,  libvlc_marquee_Timeout )
 192     PROP_INT( x,        libvlc_marquee_X )
 193     PROP_INT( y,        libvlc_marquee_Y )
 194
 195 #undef  PROP_INT
 196
 197 private:
 198     HRESULT do_put_int(unsigned idx, LONG val);
 199     HRESULT do_get_int(unsigned idx, LONG *val);
 200 };
 201
 202 class VLCLogo: public VLCInterface<VLCLogo,IVLCLogo>
 203 {
 204 public:
 205     VLCLogo(VLCPlugin *p): VLCInterface<VLCLogo,IVLCLogo>(p) { }
 206
 207     STDMETHODIMP enable()  { return do_put_int(libvlc_logo_enable, true); }
 208     STDMETHODIMP disable() { return do_put_int(libvlc_logo_enable, false); }
 209
 210     STDMETHODIMP file(BSTR fname);
 211
 212 #define PROP_INT( a ) \
 213         STDMETHODIMP get_##a(LONG *val) \
 214             { return do_get_int(libvlc_logo_##a,val); } \
 215         STDMETHODIMP put_##a(LONG val) \
 216             { return do_put_int(libvlc_logo_##a,val); }
 217
 218     PROP_INT( delay )
 219     PROP_INT( repeat )
 220     PROP_INT( opacity )
 221     PROP_INT( x )
 222     PROP_INT( y )
 223
 224 #undef  PROP_INT
 225
 226     STDMETHODIMP get_position(BSTR* val);
 227     STDMETHODIMP put_position(BSTR val);
 228
 229 private:
 230     HRESULT do_put_int(unsigned idx, LONG val);
 231     HRESULT do_get_int(unsigned idx, LONG *val);
 232 };
 233
 234 class VLCDeinterlace: public VLCInterface<VLCDeinterlace,IVLCDeinterlace>
 235 {
 236 public:
 237     VLCDeinterlace(VLCPlugin *p):
 238         VLCInterface<VLCDeinterlace,IVLCDeinterlace>(p) { }
 239
 240     STDMETHODIMP enable(BSTR val);
 241     STDMETHODIMP disable();
 242 };
 243
 244 class VLCPlaylistItems: public VLCInterface<VLCPlaylistItems,IVLCPlaylistItems>
 245 {
 246 public:
 247     VLCPlaylistItems(VLCPlugin *p):
 248         VLCInterface<VLCPlaylistItems,IVLCPlaylistItems>(p) { }
 249
 250     // IVLCPlaylistItems methods
 251     STDMETHODIMP get_count(long*);
 252     STDMETHODIMP clear();
 253     STDMETHODIMP remove(long);
 254 };
 255
 256 class VLCPlaylist: public VLCInterface<VLCPlaylist,IVLCPlaylist>
 257 {
 258 public:
 259     VLCPlaylist(VLCPlugin *p):
 260         VLCInterface<VLCPlaylist,IVLCPlaylist>(p),
 261         _p_vlcplaylistitems(new VLCPlaylistItems(p)) { }
 262     virtual ~VLCPlaylist() { delete _p_vlcplaylistitems; }
 263
 264     // IVLCPlaylist methods
 265     STDMETHODIMP get_itemCount(long*);
 266     STDMETHODIMP get_isPlaying(VARIANT_BOOL*);
 267     STDMETHODIMP add(BSTR, VARIANT, VARIANT, long*);
 268     STDMETHODIMP play();
 269     STDMETHODIMP playItem(long);
 270     STDMETHODIMP togglePause();
 271     STDMETHODIMP stop();
 272     STDMETHODIMP next();
 273     STDMETHODIMP prev();
 274     STDMETHODIMP clear();
 275     STDMETHODIMP removeItem(long);
 276     STDMETHODIMP get_items(IVLCPlaylistItems**);
 277
 278 private:
 279     VLCPlaylistItems*    _p_vlcplaylistitems;
 280 };
 281
 282 class VLCSubtitle: public VLCInterface<VLCSubtitle,IVLCSubtitle>
 283 {
 284 public:
 285     VLCSubtitle(VLCPlugin *p): VLCInterface<VLCSubtitle,IVLCSubtitle>(p) { }
 286
 287     // IVLCSubtitle methods
 288     STDMETHODIMP get_track(long*);
 289     STDMETHODIMP put_track(long);
 290     STDMETHODIMP get_count(long*);
 291     STDMETHODIMP description(long, BSTR*);
 292 };
 293
 294 class VLCVideo: public VLCInterface<VLCVideo,IVLCVideo>
 295 {
 296 public:
 297     VLCVideo(VLCPlugin *p): VLCInterface<VLCVideo,IVLCVideo>(p),
 298         _p_vlcmarquee(new VLCMarquee(p)), _p_vlclogo(new VLCLogo(p)),
 299         _p_vlcdeint(new VLCDeinterlace(p)) { }
 300     virtual ~VLCVideo() {
 301         delete _p_vlcmarquee;
 302         delete _p_vlclogo;
 303         delete _p_vlcdeint;
 304     }
 305
 306     // IVLCVideo methods
 307     STDMETHODIMP get_fullscreen(VARIANT_BOOL*);
 308     STDMETHODIMP put_fullscreen(VARIANT_BOOL);
 309     STDMETHODIMP get_width(long*);
 310     STDMETHODIMP get_height(long*);
 311     STDMETHODIMP get_aspectRatio(BSTR*);
 312     STDMETHODIMP put_aspectRatio(BSTR);
 313     STDMETHODIMP get_subtitle(long*);
 314     STDMETHODIMP put_subtitle(long);
 315     STDMETHODIMP get_crop(BSTR*);
 316     STDMETHODIMP put_crop(BSTR);
 317     STDMETHODIMP get_teletext(long*);
 318     STDMETHODIMP put_teletext(long);
 319     STDMETHODIMP get_marquee(IVLCMarquee**);
 320     STDMETHODIMP get_logo(IVLCLogo**);
 321     STDMETHODIMP get_deinterlace(IVLCDeinterlace**);
 322     STDMETHODIMP takeSnapshot(LPPICTUREDISP*);
 323     STDMETHODIMP toggleFullscreen();
 324     STDMETHODIMP toggleTeletext();
 325
 326 private:
 327     IVLCMarquee     *_p_vlcmarquee;
 328     IVLCLogo        *_p_vlclogo;
 329     IVLCDeinterlace *_p_vlcdeint;
 330 };
 331
 332 class VLCControl2 : public IVLCControl2
 333 {
 334 public:
 335
 336     VLCControl2(VLCPlugin *p_instance);
 337     virtual ~VLCControl2();
 338
 339     // IUnknown methods
 340     STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
 341     {
 342         if( NULL == ppv )
 343           return E_POINTER;
 344         if( (IID_IUnknown == riid)
 345          || (IID_IDispatch == riid)
 346          || (IID_IVLCControl2 == riid) )
 347         {
 348             AddRef();
 349             *ppv = reinterpret_cast<LPVOID>(this);
 350             return NOERROR;
 351         }
 352         return _p_instance->pUnkOuter->QueryInterface(riid, ppv);
 353     };
 354
 355     STDMETHODIMP_(ULONG) AddRef(void) { return _p_instance->pUnkOuter->AddRef(); };
 356     STDMETHODIMP_(ULONG) Release(void) { return _p_instance->pUnkOuter->Release(); };
 357
 358     // IDispatch methods
 359     STDMETHODIMP GetTypeInfoCount(UINT*);
 360     STDMETHODIMP GetTypeInfo(UINT, LCID, LPTYPEINFO*);
 361     STDMETHODIMP GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*);
 362     STDMETHODIMP Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*);
 363
 364     // IVLCControl2 methods
 365     STDMETHODIMP get_AutoLoop(VARIANT_BOOL *autoloop);
 366     STDMETHODIMP put_AutoLoop(VARIANT_BOOL autoloop);
 367     STDMETHODIMP get_AutoPlay(VARIANT_BOOL *autoplay);
 368     STDMETHODIMP put_AutoPlay(VARIANT_BOOL autoplay);
 369     STDMETHODIMP get_BaseURL(BSTR *url);
 370     STDMETHODIMP put_BaseURL(BSTR url);
 371     STDMETHODIMP get_MRL(BSTR *mrl);
 372     STDMETHODIMP put_MRL(BSTR mrl);
 373     STDMETHODIMP get_Toolbar(VARIANT_BOOL *visible);
 374     STDMETHODIMP put_Toolbar(VARIANT_BOOL visible);
 375     STDMETHODIMP get_StartTime(long *seconds);
 376     STDMETHODIMP put_StartTime(long seconds);
 377     STDMETHODIMP get_VersionInfo(BSTR *version);
 378     STDMETHODIMP get_Visible(VARIANT_BOOL *visible);
 379     STDMETHODIMP put_Visible(VARIANT_BOOL visible);
 380     STDMETHODIMP get_Volume(long *volume);
 381     STDMETHODIMP put_Volume(long volume);
 382     STDMETHODIMP get_BackColor(OLE_COLOR *backcolor);
 383     STDMETHODIMP put_BackColor(OLE_COLOR backcolor);
 384
 385     STDMETHODIMP get_audio(IVLCAudio**);
 386     STDMETHODIMP get_input(IVLCInput**);
 387     STDMETHODIMP get_playlist(IVLCPlaylist**);
 388     STDMETHODIMP get_subtitle(IVLCSubtitle**);
 389     STDMETHODIMP get_video(IVLCVideo**);
 390
 391 protected:
 392     HRESULT loadTypeInfo();
 393
 394 private:
 395     VLCPlugin    *_p_instance;
 396     ITypeInfo    *_p_typeinfo;
 397
 398     IVLCAudio    *_p_vlcaudio;
 399     IVLCInput    *_p_vlcinput;
 400     IVLCPlaylist *_p_vlcplaylist;
 401     IVLCSubtitle *_p_vlcsubtitle;
 402     IVLCVideo    *_p_vlcvideo;
 403 };
 404
 405 #endif