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  *
   6  * Authors: Damien Fouilleul <Damien.Fouilleul@laposte.net>
   7  *          Jean-Paul Saman <jpsaman _at_ m2x _dot_ nl>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License along
  20  * with this program; if not, write to the Free Software Foundation, Inc.,
  21  * 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22  *****************************************************************************/
  23
  24 #ifndef _VLCCONTROL2_H_
  25 #define _VLCCONTROL2_H_
  26
  27 #include "axvlc_idl.h"
  28
  29 #include <vlc/libvlc.h>
  30 #include <ole2.h>
  31
  32 class VLCAudio : public IVLCAudio
  33 {
  34 public:
  35     VLCAudio(VLCPlugin *p_instance) :
  36         _p_instance(p_instance), _p_typeinfo(NULL) {};
  37     virtual ~VLCAudio();
  38
  39     // IUnknown methods
  40     STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
  41     {
  42         if( NULL == ppv )
  43           return E_POINTER;
  44         if( (IID_IUnknown == riid)
  45          || (IID_IDispatch == riid)
  46          || (IID_IVLCAudio == riid) )
  47         {
  48             AddRef();
  49             *ppv = reinterpret_cast<LPVOID>(this);
  50             return NOERROR;
  51         }
  52         // behaves as a standalone object
  53         return E_NOINTERFACE;
  54     };
  55
  56     STDMETHODIMP_(ULONG) AddRef(void) { return _p_instance->pUnkOuter->AddRef(); };
  57     STDMETHODIMP_(ULONG) Release(void) { return _p_instance->pUnkOuter->Release(); };
  58
  59     // IDispatch methods
  60     STDMETHODIMP GetTypeInfoCount(UINT*);
  61     STDMETHODIMP GetTypeInfo(UINT, LCID, LPTYPEINFO*);
  62     STDMETHODIMP GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*);
  63     STDMETHODIMP Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*);
  64
  65     // IVLCAudio methods
  66     STDMETHODIMP get_mute(VARIANT_BOOL*);
  67     STDMETHODIMP put_mute(VARIANT_BOOL);
  68     STDMETHODIMP get_volume(long*);
  69     STDMETHODIMP put_volume(long);
  70     STDMETHODIMP get_track(long*);
  71     STDMETHODIMP put_track(long);
  72     STDMETHODIMP get_count(long*);
  73     STDMETHODIMP get_channel(long*);
  74     STDMETHODIMP put_channel(long);
  75     STDMETHODIMP toggleMute();
  76     STDMETHODIMP description(long, BSTR*);
  77
  78 protected:
  79     HRESULT loadTypeInfo();
  80     HRESULT exception_bridge(libvlc_exception_t *ex);
  81
  82 private:
  83     VLCPlugin*      _p_instance;
  84     ITypeInfo*      _p_typeinfo;
  85
  86 };
  87
  88 class VLCInput : public IVLCInput
  89 {
  90 public:
  91
  92     VLCInput(VLCPlugin *p_instance) :
  93         _p_instance(p_instance), _p_typeinfo(NULL) {};
  94     virtual ~VLCInput();
  95
  96     // IUnknown methods
  97     STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
  98     {
  99         if( NULL == ppv )
 100           return E_POINTER;
 101         if( (IID_IUnknown == riid)
 102          || (IID_IDispatch == riid)
 103          || (IID_IVLCInput == riid) )
 104         {
 105             AddRef();
 106             *ppv = reinterpret_cast<LPVOID>(this);
 107             return NOERROR;
 108         }
 109         // behaves as a standalone object
 110         return E_NOINTERFACE;
 111     };
 112
 113     STDMETHODIMP_(ULONG) AddRef(void) { return _p_instance->pUnkOuter->AddRef(); };
 114     STDMETHODIMP_(ULONG) Release(void) { return _p_instance->pUnkOuter->Release(); };
 115
 116     // IDispatch methods
 117     STDMETHODIMP GetTypeInfoCount(UINT*);
 118     STDMETHODIMP GetTypeInfo(UINT, LCID, LPTYPEINFO*);
 119     STDMETHODIMP GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*);
 120     STDMETHODIMP Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*);
 121
 122     // IVLCInput methods
 123     STDMETHODIMP get_length(double*);
 124     STDMETHODIMP get_position(double*);
 125     STDMETHODIMP put_position(double);
 126     STDMETHODIMP get_time(double*);
 127     STDMETHODIMP put_time(double);
 128     STDMETHODIMP get_state(long*);
 129     STDMETHODIMP get_rate(double*);
 130     STDMETHODIMP put_rate(double);
 131     STDMETHODIMP get_fps(double*);
 132     STDMETHODIMP get_hasVout(VARIANT_BOOL*);
 133
 134 protected:
 135     HRESULT loadTypeInfo();
 136     HRESULT exception_bridge(libvlc_exception_t *ex);
 137
 138 private:
 139     VLCPlugin*      _p_instance;
 140     ITypeInfo*      _p_typeinfo;
 141
 142 };
 143
 144 class VLCMessage: public IVLCMessage
 145 {
 146 public:
 147
 148     VLCMessage(VLCPlugin *p_instance, struct libvlc_log_message_t &msg) :
 149         _p_instance(p_instance),
 150         _p_typeinfo(NULL),
 151         _refcount(1),
 152         _msg(msg) {};
 153     virtual ~VLCMessage();
 154
 155     // IUnknown methods
 156     STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
 157     {
 158         if( NULL == ppv )
 159           return E_POINTER;
 160         if( (IID_IUnknown == riid)
 161          || (IID_IDispatch == riid)
 162          || (IID_IVLCMessage == riid) )
 163         {
 164             AddRef();
 165             *ppv = reinterpret_cast<LPVOID>(this);
 166             return NOERROR;
 167         }
 168         // behaves as a standalone object
 169         return E_NOINTERFACE;
 170     };
 171
 172     STDMETHODIMP_(ULONG) AddRef(void) { return InterlockedIncrement(&_refcount); };
 173     STDMETHODIMP_(ULONG) Release(void)
 174     {
 175         ULONG refcount = InterlockedDecrement(&_refcount);
 176         if( 0 == refcount )
 177         {
 178             delete this;
 179             return 0;
 180         }
 181         return refcount;
 182     };
 183
 184     // IDispatch methods
 185     STDMETHODIMP GetTypeInfoCount(UINT*);
 186     STDMETHODIMP GetTypeInfo(UINT, LCID, LPTYPEINFO*);
 187     STDMETHODIMP GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*);
 188     STDMETHODIMP Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*);
 189
 190     // IVLCMessage methods
 191     STDMETHODIMP get__Value(VARIANT *);
 192     STDMETHODIMP get_severity(long *);
 193     STDMETHODIMP get_type(BSTR *);
 194     STDMETHODIMP get_name(BSTR *);
 195     STDMETHODIMP get_header(BSTR *);
 196     STDMETHODIMP get_message(BSTR *);
 197
 198 protected:
 199     HRESULT loadTypeInfo();
 200
 201 private:
 202     VLCPlugin*      _p_instance;
 203     ITypeInfo*      _p_typeinfo;
 204     LONG            _refcount;
 205
 206     struct libvlc_log_message_t _msg;
 207 };
 208
 209 class VLCLog;
 210
 211 class VLCMessageIterator : public IVLCMessageIterator
 212 {
 213 public:
 214
 215     VLCMessageIterator(VLCPlugin *p_instance, VLCLog* p_vlclog);
 216     virtual ~VLCMessageIterator();
 217
 218     // IUnknown methods
 219     STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
 220     {
 221         if( NULL == ppv )
 222           return E_POINTER;
 223         if( (IID_IUnknown == riid)
 224          || (IID_IDispatch == riid)
 225          || (IID_IVLCMessageIterator == riid) )
 226         {
 227             AddRef();
 228             *ppv = reinterpret_cast<LPVOID>(this);
 229             return NOERROR;
 230         }
 231         // behaves as a standalone object
 232         return E_NOINTERFACE;
 233     };
 234
 235     STDMETHODIMP_(ULONG) AddRef(void) { return InterlockedIncrement(&_refcount); };
 236     STDMETHODIMP_(ULONG) Release(void)
 237     {
 238         ULONG refcount = InterlockedDecrement(&_refcount);
 239         if( 0 == refcount )
 240         {
 241             delete this;
 242             return 0;
 243         }
 244         return refcount;
 245     };
 246
 247     // IDispatch methods
 248     STDMETHODIMP GetTypeInfoCount(UINT*);
 249     STDMETHODIMP GetTypeInfo(UINT, LCID, LPTYPEINFO*);
 250     STDMETHODIMP GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*);
 251     STDMETHODIMP Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*);
 252
 253     // IVLCMessageIterator methods
 254     STDMETHODIMP get_hasNext(VARIANT_BOOL*);
 255     STDMETHODIMP next(IVLCMessage**);
 256
 257 protected:
 258     HRESULT loadTypeInfo();
 259     HRESULT exception_bridge(libvlc_exception_t *ex);
 260
 261 private:
 262     VLCPlugin*      _p_instance;
 263     ITypeInfo*      _p_typeinfo;
 264     LONG            _refcount;
 265
 266     VLCLog*                 _p_vlclog;
 267     libvlc_log_iterator_t*  _p_iter;
 268 };
 269
 270 class VLCMessages : public IVLCMessages
 271 {
 272 public:
 273
 274     VLCMessages(VLCPlugin *p_instance, VLCLog *p_vlclog) :
 275         _p_vlclog(p_vlclog),
 276         _p_instance(p_instance),
 277         _p_typeinfo(NULL) {}
 278     virtual ~VLCMessages();
 279
 280     // IUnknown methods
 281     STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
 282     {
 283         if( NULL == ppv )
 284           return E_POINTER;
 285         if( (IID_IUnknown == riid)
 286          || (IID_IDispatch == riid)
 287          || (IID_IVLCMessages == riid) )
 288         {
 289             AddRef();
 290             *ppv = reinterpret_cast<LPVOID>(this);
 291             return NOERROR;
 292         }
 293         // behaves as a standalone object
 294         return E_NOINTERFACE;
 295     };
 296
 297     STDMETHODIMP_(ULONG) AddRef(void) { return _p_instance->pUnkOuter->AddRef(); };
 298     STDMETHODIMP_(ULONG) Release(void) { return _p_instance->pUnkOuter->Release(); };
 299
 300     // IDispatch methods
 301     STDMETHODIMP GetTypeInfoCount(UINT*);
 302     STDMETHODIMP GetTypeInfo(UINT, LCID, LPTYPEINFO*);
 303     STDMETHODIMP GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*);
 304     STDMETHODIMP Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*);
 305
 306     // IVLCMessages methods
 307     STDMETHODIMP get__NewEnum(LPUNKNOWN*);
 308     STDMETHODIMP clear();
 309     STDMETHODIMP get_count(long*);
 310     STDMETHODIMP iterator(IVLCMessageIterator**);
 311
 312 protected:
 313     HRESULT loadTypeInfo();
 314     HRESULT exception_bridge(libvlc_exception_t *ex);
 315
 316     VLCLog*     _p_vlclog;
 317
 318 private:
 319     VLCPlugin*  _p_instance;
 320     ITypeInfo*  _p_typeinfo;
 321 };
 322
 323 class VLCLog : public IVLCLog
 324 {
 325 public:
 326
 327     friend class VLCMessages;
 328     friend class VLCMessageIterator;
 329
 330     VLCLog(VLCPlugin *p_instance) :
 331         _p_log(NULL),
 332         _p_instance(p_instance),
 333         _p_typeinfo(NULL),
 334         _p_vlcmessages(NULL)
 335     {
 336         _p_vlcmessages = new VLCMessages(p_instance, this);
 337     };
 338     virtual ~VLCLog();
 339
 340     // IUnknown methods
 341     STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
 342     {
 343         if( NULL == ppv )
 344           return E_POINTER;
 345         if( (IID_IUnknown == riid)
 346          || (IID_IDispatch == riid)
 347          || (IID_IVLCLog == riid) )
 348         {
 349             AddRef();
 350             *ppv = reinterpret_cast<LPVOID>(this);
 351             return NOERROR;
 352         }
 353         // behaves as a standalone object
 354         return E_NOINTERFACE;
 355     };
 356
 357     STDMETHODIMP_(ULONG) AddRef(void) { return _p_instance->pUnkOuter->AddRef(); };
 358     STDMETHODIMP_(ULONG) Release(void) { return _p_instance->pUnkOuter->Release(); };
 359
 360     // IDispatch methods
 361     STDMETHODIMP GetTypeInfoCount(UINT*);
 362     STDMETHODIMP GetTypeInfo(UINT, LCID, LPTYPEINFO*);
 363     STDMETHODIMP GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*);
 364     STDMETHODIMP Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*);
 365
 366     // IVLCLog methods
 367     STDMETHODIMP get_messages(IVLCMessages**);
 368     STDMETHODIMP get_verbosity(long *);
 369     STDMETHODIMP put_verbosity(long);
 370
 371 protected:
 372     HRESULT loadTypeInfo();
 373     HRESULT exception_bridge(libvlc_exception_t *ex);
 374
 375     libvlc_log_t    *_p_log;
 376
 377 private:
 378     VLCPlugin*      _p_instance;
 379     ITypeInfo*      _p_typeinfo;
 380
 381     VLCMessages*    _p_vlcmessages;
 382 };
 383
 384 class VLCMarquee : public IVLCMarquee
 385 {
 386 public:
 387     VLCMarquee(VLCPlugin *p_instance) :
 388         _p_instance(p_instance), _p_typeinfo(NULL) {};
 389     virtual ~VLCMarquee();
 390
 391     // IUnknown methods
 392     STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
 393     {
 394         if( NULL == ppv )
 395           return E_POINTER;
 396         if( (IID_IUnknown == riid)
 397          || (IID_IDispatch == riid)
 398          || (IID_IVLCMarquee == riid) )
 399         {
 400             AddRef();
 401             *ppv = reinterpret_cast<LPVOID>(this);
 402            return NOERROR;
 403         }
 404         // behaves as a standalone object
 405         return E_NOINTERFACE;
 406     };
 407
 408     STDMETHODIMP_(ULONG) AddRef(void) { return _p_instance->pUnkOuter->AddRef(); };
 409     STDMETHODIMP_(ULONG) Release(void) { return _p_instance->pUnkOuter->Release(); };
 410
 411     // IDispatch methods
 412     STDMETHODIMP GetTypeInfoCount(UINT*);
 413     STDMETHODIMP GetTypeInfo(UINT, LCID, LPTYPEINFO*);
 414     STDMETHODIMP GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*);
 415     STDMETHODIMP Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*);
 416
 417     // IVLCMarquee methods
 418     STDMETHODIMP enable();
 419     STDMETHODIMP disable();
 420     STDMETHODIMP text(BSTR);
 421     STDMETHODIMP color(long);
 422     STDMETHODIMP opacity(long);
 423     STDMETHODIMP position(long);
 424     STDMETHODIMP refresh(long);
 425     STDMETHODIMP size(long);
 426     STDMETHODIMP timeout(long);
 427     STDMETHODIMP x(long);
 428     STDMETHODIMP y(long);
 429
 430 protected:
 431     HRESULT loadTypeInfo();
 432     HRESULT exception_bridge(libvlc_exception_t *ex);
 433
 434 private:
 435     VLCPlugin*      _p_instance;
 436     ITypeInfo*      _p_typeinfo;
 437
 438 };
 439
 440
 441 class VLCLogo : public IVLCLogo
 442 {
 443 public:
 444     VLCLogo(VLCPlugin *p): _p_instance(p), _p_typeinfo(NULL) { }
 445     virtual ~VLCLogo() { if( _p_typeinfo ) _p_typeinfo->Release(); }
 446
 447     // IUnknown methods
 448     STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
 449     {
 450         if( NULL == ppv )
 451           return E_POINTER;
 452         if( (IID_IUnknown == riid)
 453          || (IID_IDispatch == riid)
 454          || (IID_IVLCLogo == riid) )
 455         {
 456             AddRef();
 457             *ppv = reinterpret_cast<LPVOID>(this);
 458             return NOERROR;
 459         }
 460         // behaves as a standalone object
 461         return E_NOINTERFACE;
 462     };
 463
 464     STDMETHODIMP_(ULONG) AddRef(void) { return _p_instance->pUnkOuter->AddRef(); }
 465     STDMETHODIMP_(ULONG) Release(void) { return _p_instance->pUnkOuter->Release(); }
 466
 467     // IDispatch methods
 468     STDMETHODIMP GetTypeInfoCount(UINT*);
 469     STDMETHODIMP GetTypeInfo(UINT, LCID, LPTYPEINFO*);
 470     STDMETHODIMP GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*);
 471     STDMETHODIMP Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*);
 472
 473     STDMETHODIMP enable()  { return do_put_int(libvlc_logo_enable, true); }
 474     STDMETHODIMP disable() { return do_put_int(libvlc_logo_enable, false); }
 475
 476     STDMETHODIMP file(BSTR fname);
 477
 478 #define PROP_INT( a ) \
 479         STDMETHODIMP get_##a(LONG *val) \
 480             { return do_get_int(libvlc_logo_##a,val); } \
 481         STDMETHODIMP put_##a(LONG val) \
 482             { return do_put_int(libvlc_logo_##a,val); }
 483
 484     PROP_INT( delay )
 485     PROP_INT( repeat )
 486     PROP_INT( opacity )
 487     PROP_INT( x )
 488     PROP_INT( y )
 489
 490 #undef  PROP_INT
 491
 492     STDMETHODIMP get_position(BSTR* val);
 493     STDMETHODIMP put_position(BSTR val);
 494
 495 protected:
 496     HRESULT loadTypeInfo();
 497     HRESULT exception_bridge(libvlc_exception_t *ex);
 498
 499 private:
 500     VLCPlugin*      _p_instance;
 501     ITypeInfo*      _p_typeinfo;
 502
 503     HRESULT do_put_int(unsigned idx, LONG val);
 504     HRESULT do_get_int(unsigned idx, LONG *val);
 505 };
 506
 507 class VLCPlaylistItems : public IVLCPlaylistItems
 508 {
 509 public:
 510     VLCPlaylistItems(VLCPlugin *p_instance) :
 511         _p_instance(p_instance), _p_typeinfo(NULL) {};
 512     virtual ~VLCPlaylistItems();
 513
 514     // IUnknown methods
 515     STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
 516     {
 517         if( NULL == ppv )
 518           return E_POINTER;
 519         if( (IID_IUnknown == riid)
 520          || (IID_IDispatch == riid)
 521          || (IID_IVLCPlaylistItems == riid) )
 522         {
 523             AddRef();
 524             *ppv = reinterpret_cast<LPVOID>(this);
 525             return NOERROR;
 526         }
 527         // behaves as a standalone object
 528         return E_NOINTERFACE;
 529     };
 530
 531     STDMETHODIMP_(ULONG) AddRef(void) { return _p_instance->pUnkOuter->AddRef(); };
 532     STDMETHODIMP_(ULONG) Release(void) { return _p_instance->pUnkOuter->Release(); };
 533
 534     // IDispatch methods
 535     STDMETHODIMP GetTypeInfoCount(UINT*);
 536     STDMETHODIMP GetTypeInfo(UINT, LCID, LPTYPEINFO*);
 537     STDMETHODIMP GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*);
 538     STDMETHODIMP Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*);
 539
 540     // IVLCPlaylistItems methods
 541     STDMETHODIMP get_count(long*);
 542     STDMETHODIMP clear();
 543     STDMETHODIMP remove(long);
 544
 545 protected:
 546     HRESULT loadTypeInfo();
 547     HRESULT exception_bridge(libvlc_exception_t *ex);
 548
 549 private:
 550     VLCPlugin*  _p_instance;
 551     ITypeInfo*  _p_typeinfo;
 552
 553 };
 554
 555 class VLCPlaylist : public IVLCPlaylist
 556 {
 557 public:
 558     VLCPlaylist(VLCPlugin *p_instance) :
 559         _p_instance(p_instance),
 560         _p_typeinfo(NULL),
 561         _p_vlcplaylistitems(NULL)
 562     {
 563         _p_vlcplaylistitems = new VLCPlaylistItems(p_instance);
 564     };
 565     virtual ~VLCPlaylist();
 566
 567     // IUnknown methods
 568     STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
 569     {
 570         if( NULL == ppv )
 571           return E_POINTER;
 572         if( (IID_IUnknown == riid)
 573          || (IID_IDispatch == riid)
 574          || (IID_IVLCPlaylist == riid) )
 575         {
 576             AddRef();
 577             *ppv = reinterpret_cast<LPVOID>(this);
 578             return NOERROR;
 579         }
 580         // behaves as a standalone object
 581         return E_NOINTERFACE;
 582     };
 583
 584     STDMETHODIMP_(ULONG) AddRef(void) { return _p_instance->pUnkOuter->AddRef(); };
 585     STDMETHODIMP_(ULONG) Release(void) { return _p_instance->pUnkOuter->Release(); };
 586
 587     // IDispatch methods
 588     STDMETHODIMP GetTypeInfoCount(UINT*);
 589     STDMETHODIMP GetTypeInfo(UINT, LCID, LPTYPEINFO*);
 590     STDMETHODIMP GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*);
 591     STDMETHODIMP Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*);
 592
 593     // IVLCPlaylist methods
 594     STDMETHODIMP get_itemCount(long*);
 595     STDMETHODIMP get_isPlaying(VARIANT_BOOL*);
 596     STDMETHODIMP add(BSTR, VARIANT, VARIANT, long*);
 597     STDMETHODIMP play();
 598     STDMETHODIMP playItem(long);
 599     STDMETHODIMP togglePause();
 600     STDMETHODIMP stop();
 601     STDMETHODIMP next();
 602     STDMETHODIMP prev();
 603     STDMETHODIMP clear();
 604     STDMETHODIMP removeItem(long);
 605     STDMETHODIMP get_items(IVLCPlaylistItems**);
 606
 607 protected:
 608     HRESULT loadTypeInfo();
 609     HRESULT exception_bridge(libvlc_exception_t *ex);
 610
 611 private:
 612     VLCPlugin*  _p_instance;
 613     ITypeInfo*  _p_typeinfo;
 614
 615     VLCPlaylistItems*    _p_vlcplaylistitems;
 616 };
 617
 618 class VLCSubtitle : public IVLCSubtitle
 619 {
 620 public:
 621     VLCSubtitle(VLCPlugin *p_instance) :
 622         _p_instance(p_instance), _p_typeinfo(NULL) {};
 623     virtual ~VLCSubtitle();
 624
 625     // IUnknown methods
 626     STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
 627     {
 628         if( NULL == ppv )
 629           return E_POINTER;
 630         if( (IID_IUnknown == riid)
 631          || (IID_IDispatch == riid)
 632          || (IID_IVLCSubtitle == riid) )
 633         {
 634             AddRef();
 635             *ppv = reinterpret_cast<LPVOID>(this);
 636             return NOERROR;
 637         }
 638         // behaves as a standalone object
 639         return E_NOINTERFACE;
 640     };
 641
 642     STDMETHODIMP_(ULONG) AddRef(void) { return _p_instance->pUnkOuter->AddRef(); };
 643     STDMETHODIMP_(ULONG) Release(void) { return _p_instance->pUnkOuter->Release(); };
 644
 645     // IDispatch methods
 646     STDMETHODIMP GetTypeInfoCount(UINT*);
 647     STDMETHODIMP GetTypeInfo(UINT, LCID, LPTYPEINFO*);
 648     STDMETHODIMP GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*);
 649     STDMETHODIMP Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*);
 650
 651     // IVLCSubtitle methods
 652     STDMETHODIMP get_track(long*);
 653     STDMETHODIMP put_track(long);
 654     STDMETHODIMP get_count(long*);
 655     STDMETHODIMP description(long, BSTR*);
 656
 657 protected:
 658     HRESULT loadTypeInfo();
 659     HRESULT exception_bridge(libvlc_exception_t *ex);
 660
 661 private:
 662     VLCPlugin*      _p_instance;
 663     ITypeInfo*      _p_typeinfo;
 664
 665 };
 666
 667 class VLCVideo : public IVLCVideo
 668 {
 669 public:
 670     VLCVideo(VLCPlugin *p_instance) :
 671         _p_instance(p_instance),
 672         _p_typeinfo(NULL),
 673         _p_vlcmarquee(new VLCMarquee(p_instance)),
 674         _p_vlclogo(new VLCLogo(p_instance)) { }
 675     virtual ~VLCVideo();
 676
 677     // IUnknown methods
 678     STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
 679     {
 680         if( NULL == ppv )
 681           return E_POINTER;
 682         if( (IID_IUnknown == riid)
 683          || (IID_IDispatch == riid)
 684          || (IID_IVLCVideo == riid) )
 685         {
 686             AddRef();
 687             *ppv = reinterpret_cast<LPVOID>(this);
 688             return NOERROR;
 689         }
 690         // behaves as a standalone object
 691         return E_NOINTERFACE;
 692     };
 693
 694     STDMETHODIMP_(ULONG) AddRef(void) { return _p_instance->pUnkOuter->AddRef(); };
 695     STDMETHODIMP_(ULONG) Release(void) { return _p_instance->pUnkOuter->Release(); };
 696
 697     // IDispatch methods
 698     STDMETHODIMP GetTypeInfoCount(UINT*);
 699     STDMETHODIMP GetTypeInfo(UINT, LCID, LPTYPEINFO*);
 700     STDMETHODIMP GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*);
 701     STDMETHODIMP Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*);
 702
 703     // IVLCVideo methods
 704     STDMETHODIMP get_fullscreen(VARIANT_BOOL*);
 705     STDMETHODIMP put_fullscreen(VARIANT_BOOL);
 706     STDMETHODIMP get_width(long*);
 707     STDMETHODIMP get_height(long*);
 708     STDMETHODIMP get_aspectRatio(BSTR*);
 709     STDMETHODIMP put_aspectRatio(BSTR);
 710     STDMETHODIMP get_subtitle(long*);
 711     STDMETHODIMP put_subtitle(long);
 712     STDMETHODIMP get_crop(BSTR*);
 713     STDMETHODIMP put_crop(BSTR);
 714     STDMETHODIMP get_teletext(long*);
 715     STDMETHODIMP put_teletext(long);
 716     STDMETHODIMP get_marquee(IVLCMarquee**);
 717     STDMETHODIMP get_logo(IVLCLogo**);
 718     STDMETHODIMP deinterlaceDisable();
 719     STDMETHODIMP deinterlaceEnable(BSTR);
 720     STDMETHODIMP takeSnapshot(LPPICTUREDISP*);
 721     STDMETHODIMP toggleFullscreen();
 722     STDMETHODIMP toggleTeletext();
 723
 724 protected:
 725     HRESULT loadTypeInfo();
 726     HRESULT exception_bridge(libvlc_exception_t *ex);
 727
 728 private:
 729     VLCPlugin*      _p_instance;
 730     ITypeInfo*      _p_typeinfo;
 731     VLCMarquee*     _p_vlcmarquee;
 732     VLCLogo*        _p_vlclogo;
 733 };
 734
 735 class VLCControl2 : public IVLCControl2
 736 {
 737 public:
 738
 739     VLCControl2(VLCPlugin *p_instance);
 740     virtual ~VLCControl2();
 741
 742     // IUnknown methods
 743     STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
 744     {
 745         if( NULL == ppv )
 746           return E_POINTER;
 747         if( (IID_IUnknown == riid)
 748          || (IID_IDispatch == riid)
 749          || (IID_IVLCControl2 == riid) )
 750         {
 751             AddRef();
 752             *ppv = reinterpret_cast<LPVOID>(this);
 753             return NOERROR;
 754         }
 755         return _p_instance->pUnkOuter->QueryInterface(riid, ppv);
 756     };
 757
 758     STDMETHODIMP_(ULONG) AddRef(void) { return _p_instance->pUnkOuter->AddRef(); };
 759     STDMETHODIMP_(ULONG) Release(void) { return _p_instance->pUnkOuter->Release(); };
 760
 761     // IDispatch methods
 762     STDMETHODIMP GetTypeInfoCount(UINT*);
 763     STDMETHODIMP GetTypeInfo(UINT, LCID, LPTYPEINFO*);
 764     STDMETHODIMP GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*);
 765     STDMETHODIMP Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*);
 766
 767     // IVLCControl2 methods
 768     STDMETHODIMP get_AutoLoop(VARIANT_BOOL *autoloop);
 769     STDMETHODIMP put_AutoLoop(VARIANT_BOOL autoloop);
 770     STDMETHODIMP get_AutoPlay(VARIANT_BOOL *autoplay);
 771     STDMETHODIMP put_AutoPlay(VARIANT_BOOL autoplay);
 772     STDMETHODIMP get_BaseURL(BSTR *url);
 773     STDMETHODIMP put_BaseURL(BSTR url);
 774     STDMETHODIMP get_MRL(BSTR *mrl);
 775     STDMETHODIMP put_MRL(BSTR mrl);
 776     STDMETHODIMP get_Toolbar(VARIANT_BOOL *visible);
 777     STDMETHODIMP put_Toolbar(VARIANT_BOOL visible);
 778     STDMETHODIMP get_StartTime(long *seconds);
 779     STDMETHODIMP put_StartTime(long seconds);
 780     STDMETHODIMP get_VersionInfo(BSTR *version);
 781     STDMETHODIMP get_Visible(VARIANT_BOOL *visible);
 782     STDMETHODIMP put_Visible(VARIANT_BOOL visible);
 783     STDMETHODIMP get_Volume(long *volume);
 784     STDMETHODIMP put_Volume(long volume);
 785     STDMETHODIMP get_BackColor(OLE_COLOR *backcolor);
 786     STDMETHODIMP put_BackColor(OLE_COLOR backcolor);
 787
 788     STDMETHODIMP get_audio(IVLCAudio**);
 789     STDMETHODIMP get_input(IVLCInput**);
 790     STDMETHODIMP get_log(IVLCLog**);
 791     STDMETHODIMP get_playlist(IVLCPlaylist**);
 792     STDMETHODIMP get_subtitle(IVLCSubtitle**);
 793     STDMETHODIMP get_video(IVLCVideo**);
 794
 795 protected:
 796     HRESULT loadTypeInfo();
 797
 798 private:
 799     VLCPlugin*      _p_instance;
 800     ITypeInfo*      _p_typeinfo;
 801
 802     VLCAudio*       _p_vlcaudio;
 803     VLCInput*       _p_vlcinput;
 804     VLCLog  *       _p_vlclog;
 805     VLCPlaylist*    _p_vlcplaylist;
 806     VLCSubtitle*    _p_vlcsubtitle;
 807     VLCVideo*       _p_vlcvideo;
 808 };
 809
 810 #endif