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()  { return do_put_int(libvlc_marquee_Enable, true); }
 419     STDMETHODIMP disable() { return do_put_int(libvlc_marquee_Enable, false); }
 420
 421     STDMETHODIMP get_text(BSTR *);
 422     STDMETHODIMP put_text(BSTR);
 423     STDMETHODIMP get_position(BSTR *);
 424     STDMETHODIMP put_position(BSTR);
 425
 426 #define PROP_INT( a, b ) \
 427         STDMETHODIMP get_##a(LONG *val) { return do_get_int(b,val); } \
 428         STDMETHODIMP put_##a(LONG val)  { return do_put_int(b,val); }
 429
 430     PROP_INT( color,    libvlc_marquee_Color )
 431     PROP_INT( opacity,  libvlc_marquee_Opacity )
 432     PROP_INT( refresh,  libvlc_marquee_Refresh )
 433     PROP_INT( size,     libvlc_marquee_Size )
 434     PROP_INT( timeout,  libvlc_marquee_Timeout )
 435     PROP_INT( x,        libvlc_marquee_X )
 436     PROP_INT( y,        libvlc_marquee_Y )
 437
 438 #undef  PROP_INT
 439
 440 protected:
 441     HRESULT loadTypeInfo();
 442     HRESULT exception_bridge(libvlc_exception_t *ex);
 443 private:
 444     VLCPlugin*      _p_instance;
 445     ITypeInfo*      _p_typeinfo;
 446
 447     HRESULT do_put_int(unsigned idx, LONG val);
 448     HRESULT do_get_int(unsigned idx, LONG *val);
 449 };
 450
 451
 452 class VLCLogo : public IVLCLogo
 453 {
 454 public:
 455     VLCLogo(VLCPlugin *p): _p_instance(p), _p_typeinfo(NULL) { }
 456     virtual ~VLCLogo() { if( _p_typeinfo ) _p_typeinfo->Release(); }
 457
 458     // IUnknown methods
 459     STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
 460     {
 461         if( NULL == ppv )
 462           return E_POINTER;
 463         if( (IID_IUnknown == riid)
 464          || (IID_IDispatch == riid)
 465          || (IID_IVLCLogo == riid) )
 466         {
 467             AddRef();
 468             *ppv = reinterpret_cast<LPVOID>(this);
 469             return NOERROR;
 470         }
 471         // behaves as a standalone object
 472         return E_NOINTERFACE;
 473     };
 474
 475     STDMETHODIMP_(ULONG) AddRef(void) { return _p_instance->pUnkOuter->AddRef(); }
 476     STDMETHODIMP_(ULONG) Release(void) { return _p_instance->pUnkOuter->Release(); }
 477
 478     // IDispatch methods
 479     STDMETHODIMP GetTypeInfoCount(UINT*);
 480     STDMETHODIMP GetTypeInfo(UINT, LCID, LPTYPEINFO*);
 481     STDMETHODIMP GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*);
 482     STDMETHODIMP Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*);
 483
 484     STDMETHODIMP enable()  { return do_put_int(libvlc_logo_enable, true); }
 485     STDMETHODIMP disable() { return do_put_int(libvlc_logo_enable, false); }
 486
 487     STDMETHODIMP file(BSTR fname);
 488
 489 #define PROP_INT( a ) \
 490         STDMETHODIMP get_##a(LONG *val) \
 491             { return do_get_int(libvlc_logo_##a,val); } \
 492         STDMETHODIMP put_##a(LONG val) \
 493             { return do_put_int(libvlc_logo_##a,val); }
 494
 495     PROP_INT( delay )
 496     PROP_INT( repeat )
 497     PROP_INT( opacity )
 498     PROP_INT( x )
 499     PROP_INT( y )
 500
 501 #undef  PROP_INT
 502
 503     STDMETHODIMP get_position(BSTR* val);
 504     STDMETHODIMP put_position(BSTR val);
 505
 506 protected:
 507     HRESULT loadTypeInfo();
 508     HRESULT exception_bridge(libvlc_exception_t *ex);
 509
 510 private:
 511     VLCPlugin*      _p_instance;
 512     ITypeInfo*      _p_typeinfo;
 513
 514     HRESULT do_put_int(unsigned idx, LONG val);
 515     HRESULT do_get_int(unsigned idx, LONG *val);
 516 };
 517
 518 class VLCPlaylistItems : public IVLCPlaylistItems
 519 {
 520 public:
 521     VLCPlaylistItems(VLCPlugin *p_instance) :
 522         _p_instance(p_instance), _p_typeinfo(NULL) {};
 523     virtual ~VLCPlaylistItems();
 524
 525     // IUnknown methods
 526     STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
 527     {
 528         if( NULL == ppv )
 529           return E_POINTER;
 530         if( (IID_IUnknown == riid)
 531          || (IID_IDispatch == riid)
 532          || (IID_IVLCPlaylistItems == riid) )
 533         {
 534             AddRef();
 535             *ppv = reinterpret_cast<LPVOID>(this);
 536             return NOERROR;
 537         }
 538         // behaves as a standalone object
 539         return E_NOINTERFACE;
 540     };
 541
 542     STDMETHODIMP_(ULONG) AddRef(void) { return _p_instance->pUnkOuter->AddRef(); };
 543     STDMETHODIMP_(ULONG) Release(void) { return _p_instance->pUnkOuter->Release(); };
 544
 545     // IDispatch methods
 546     STDMETHODIMP GetTypeInfoCount(UINT*);
 547     STDMETHODIMP GetTypeInfo(UINT, LCID, LPTYPEINFO*);
 548     STDMETHODIMP GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*);
 549     STDMETHODIMP Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*);
 550
 551     // IVLCPlaylistItems methods
 552     STDMETHODIMP get_count(long*);
 553     STDMETHODIMP clear();
 554     STDMETHODIMP remove(long);
 555
 556 protected:
 557     HRESULT loadTypeInfo();
 558     HRESULT exception_bridge(libvlc_exception_t *ex);
 559
 560 private:
 561     VLCPlugin*  _p_instance;
 562     ITypeInfo*  _p_typeinfo;
 563
 564 };
 565
 566 class VLCPlaylist : public IVLCPlaylist
 567 {
 568 public:
 569     VLCPlaylist(VLCPlugin *p_instance) :
 570         _p_instance(p_instance),
 571         _p_typeinfo(NULL),
 572         _p_vlcplaylistitems(NULL)
 573     {
 574         _p_vlcplaylistitems = new VLCPlaylistItems(p_instance);
 575     };
 576     virtual ~VLCPlaylist();
 577
 578     // IUnknown methods
 579     STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
 580     {
 581         if( NULL == ppv )
 582           return E_POINTER;
 583         if( (IID_IUnknown == riid)
 584          || (IID_IDispatch == riid)
 585          || (IID_IVLCPlaylist == riid) )
 586         {
 587             AddRef();
 588             *ppv = reinterpret_cast<LPVOID>(this);
 589             return NOERROR;
 590         }
 591         // behaves as a standalone object
 592         return E_NOINTERFACE;
 593     };
 594
 595     STDMETHODIMP_(ULONG) AddRef(void) { return _p_instance->pUnkOuter->AddRef(); };
 596     STDMETHODIMP_(ULONG) Release(void) { return _p_instance->pUnkOuter->Release(); };
 597
 598     // IDispatch methods
 599     STDMETHODIMP GetTypeInfoCount(UINT*);
 600     STDMETHODIMP GetTypeInfo(UINT, LCID, LPTYPEINFO*);
 601     STDMETHODIMP GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*);
 602     STDMETHODIMP Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*);
 603
 604     // IVLCPlaylist methods
 605     STDMETHODIMP get_itemCount(long*);
 606     STDMETHODIMP get_isPlaying(VARIANT_BOOL*);
 607     STDMETHODIMP add(BSTR, VARIANT, VARIANT, long*);
 608     STDMETHODIMP play();
 609     STDMETHODIMP playItem(long);
 610     STDMETHODIMP togglePause();
 611     STDMETHODIMP stop();
 612     STDMETHODIMP next();
 613     STDMETHODIMP prev();
 614     STDMETHODIMP clear();
 615     STDMETHODIMP removeItem(long);
 616     STDMETHODIMP get_items(IVLCPlaylistItems**);
 617
 618 protected:
 619     HRESULT loadTypeInfo();
 620     HRESULT exception_bridge(libvlc_exception_t *ex);
 621
 622 private:
 623     VLCPlugin*  _p_instance;
 624     ITypeInfo*  _p_typeinfo;
 625
 626     VLCPlaylistItems*    _p_vlcplaylistitems;
 627 };
 628
 629 class VLCSubtitle : public IVLCSubtitle
 630 {
 631 public:
 632     VLCSubtitle(VLCPlugin *p_instance) :
 633         _p_instance(p_instance), _p_typeinfo(NULL) {};
 634     virtual ~VLCSubtitle();
 635
 636     // IUnknown methods
 637     STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
 638     {
 639         if( NULL == ppv )
 640           return E_POINTER;
 641         if( (IID_IUnknown == riid)
 642          || (IID_IDispatch == riid)
 643          || (IID_IVLCSubtitle == riid) )
 644         {
 645             AddRef();
 646             *ppv = reinterpret_cast<LPVOID>(this);
 647             return NOERROR;
 648         }
 649         // behaves as a standalone object
 650         return E_NOINTERFACE;
 651     };
 652
 653     STDMETHODIMP_(ULONG) AddRef(void) { return _p_instance->pUnkOuter->AddRef(); };
 654     STDMETHODIMP_(ULONG) Release(void) { return _p_instance->pUnkOuter->Release(); };
 655
 656     // IDispatch methods
 657     STDMETHODIMP GetTypeInfoCount(UINT*);
 658     STDMETHODIMP GetTypeInfo(UINT, LCID, LPTYPEINFO*);
 659     STDMETHODIMP GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*);
 660     STDMETHODIMP Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*);
 661
 662     // IVLCSubtitle methods
 663     STDMETHODIMP get_track(long*);
 664     STDMETHODIMP put_track(long);
 665     STDMETHODIMP get_count(long*);
 666     STDMETHODIMP description(long, BSTR*);
 667
 668 protected:
 669     HRESULT loadTypeInfo();
 670     HRESULT exception_bridge(libvlc_exception_t *ex);
 671
 672 private:
 673     VLCPlugin*      _p_instance;
 674     ITypeInfo*      _p_typeinfo;
 675
 676 };
 677
 678 class VLCVideo : public IVLCVideo
 679 {
 680 public:
 681     VLCVideo(VLCPlugin *p_instance) :
 682         _p_instance(p_instance),
 683         _p_typeinfo(NULL),
 684         _p_vlcmarquee(new VLCMarquee(p_instance)),
 685         _p_vlclogo(new VLCLogo(p_instance)) { }
 686     virtual ~VLCVideo();
 687
 688     // IUnknown methods
 689     STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
 690     {
 691         if( NULL == ppv )
 692           return E_POINTER;
 693         if( (IID_IUnknown == riid)
 694          || (IID_IDispatch == riid)
 695          || (IID_IVLCVideo == riid) )
 696         {
 697             AddRef();
 698             *ppv = reinterpret_cast<LPVOID>(this);
 699             return NOERROR;
 700         }
 701         // behaves as a standalone object
 702         return E_NOINTERFACE;
 703     };
 704
 705     STDMETHODIMP_(ULONG) AddRef(void) { return _p_instance->pUnkOuter->AddRef(); };
 706     STDMETHODIMP_(ULONG) Release(void) { return _p_instance->pUnkOuter->Release(); };
 707
 708     // IDispatch methods
 709     STDMETHODIMP GetTypeInfoCount(UINT*);
 710     STDMETHODIMP GetTypeInfo(UINT, LCID, LPTYPEINFO*);
 711     STDMETHODIMP GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*);
 712     STDMETHODIMP Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*);
 713
 714     // IVLCVideo methods
 715     STDMETHODIMP get_fullscreen(VARIANT_BOOL*);
 716     STDMETHODIMP put_fullscreen(VARIANT_BOOL);
 717     STDMETHODIMP get_width(long*);
 718     STDMETHODIMP get_height(long*);
 719     STDMETHODIMP get_aspectRatio(BSTR*);
 720     STDMETHODIMP put_aspectRatio(BSTR);
 721     STDMETHODIMP get_subtitle(long*);
 722     STDMETHODIMP put_subtitle(long);
 723     STDMETHODIMP get_crop(BSTR*);
 724     STDMETHODIMP put_crop(BSTR);
 725     STDMETHODIMP get_teletext(long*);
 726     STDMETHODIMP put_teletext(long);
 727     STDMETHODIMP get_marquee(IVLCMarquee**);
 728     STDMETHODIMP get_logo(IVLCLogo**);
 729     STDMETHODIMP deinterlaceDisable();
 730     STDMETHODIMP deinterlaceEnable(BSTR);
 731     STDMETHODIMP takeSnapshot(LPPICTUREDISP*);
 732     STDMETHODIMP toggleFullscreen();
 733     STDMETHODIMP toggleTeletext();
 734
 735 protected:
 736     HRESULT loadTypeInfo();
 737     HRESULT exception_bridge(libvlc_exception_t *ex);
 738
 739 private:
 740     VLCPlugin*      _p_instance;
 741     ITypeInfo*      _p_typeinfo;
 742     VLCMarquee*     _p_vlcmarquee;
 743     VLCLogo*        _p_vlclogo;
 744 };
 745
 746 class VLCControl2 : public IVLCControl2
 747 {
 748 public:
 749
 750     VLCControl2(VLCPlugin *p_instance);
 751     virtual ~VLCControl2();
 752
 753     // IUnknown methods
 754     STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
 755     {
 756         if( NULL == ppv )
 757           return E_POINTER;
 758         if( (IID_IUnknown == riid)
 759          || (IID_IDispatch == riid)
 760          || (IID_IVLCControl2 == riid) )
 761         {
 762             AddRef();
 763             *ppv = reinterpret_cast<LPVOID>(this);
 764             return NOERROR;
 765         }
 766         return _p_instance->pUnkOuter->QueryInterface(riid, ppv);
 767     };
 768
 769     STDMETHODIMP_(ULONG) AddRef(void) { return _p_instance->pUnkOuter->AddRef(); };
 770     STDMETHODIMP_(ULONG) Release(void) { return _p_instance->pUnkOuter->Release(); };
 771
 772     // IDispatch methods
 773     STDMETHODIMP GetTypeInfoCount(UINT*);
 774     STDMETHODIMP GetTypeInfo(UINT, LCID, LPTYPEINFO*);
 775     STDMETHODIMP GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*);
 776     STDMETHODIMP Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*);
 777
 778     // IVLCControl2 methods
 779     STDMETHODIMP get_AutoLoop(VARIANT_BOOL *autoloop);
 780     STDMETHODIMP put_AutoLoop(VARIANT_BOOL autoloop);
 781     STDMETHODIMP get_AutoPlay(VARIANT_BOOL *autoplay);
 782     STDMETHODIMP put_AutoPlay(VARIANT_BOOL autoplay);
 783     STDMETHODIMP get_BaseURL(BSTR *url);
 784     STDMETHODIMP put_BaseURL(BSTR url);
 785     STDMETHODIMP get_MRL(BSTR *mrl);
 786     STDMETHODIMP put_MRL(BSTR mrl);
 787     STDMETHODIMP get_Toolbar(VARIANT_BOOL *visible);
 788     STDMETHODIMP put_Toolbar(VARIANT_BOOL visible);
 789     STDMETHODIMP get_StartTime(long *seconds);
 790     STDMETHODIMP put_StartTime(long seconds);
 791     STDMETHODIMP get_VersionInfo(BSTR *version);
 792     STDMETHODIMP get_Visible(VARIANT_BOOL *visible);
 793     STDMETHODIMP put_Visible(VARIANT_BOOL visible);
 794     STDMETHODIMP get_Volume(long *volume);
 795     STDMETHODIMP put_Volume(long volume);
 796     STDMETHODIMP get_BackColor(OLE_COLOR *backcolor);
 797     STDMETHODIMP put_BackColor(OLE_COLOR backcolor);
 798
 799     STDMETHODIMP get_audio(IVLCAudio**);
 800     STDMETHODIMP get_input(IVLCInput**);
 801     STDMETHODIMP get_log(IVLCLog**);
 802     STDMETHODIMP get_playlist(IVLCPlaylist**);
 803     STDMETHODIMP get_subtitle(IVLCSubtitle**);
 804     STDMETHODIMP get_video(IVLCVideo**);
 805
 806 protected:
 807     HRESULT loadTypeInfo();
 808
 809 private:
 810     VLCPlugin*      _p_instance;
 811     ITypeInfo*      _p_typeinfo;
 812
 813     VLCAudio*       _p_vlcaudio;
 814     VLCInput*       _p_vlcinput;
 815     VLCLog  *       _p_vlclog;
 816     VLCPlaylist*    _p_vlcplaylist;
 817     VLCSubtitle*    _p_vlcsubtitle;
 818     VLCVideo*       _p_vlcvideo;
 819 };
 820
 821 #endif