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
  31 class VLCAudio : public IVLCAudio
  32 {
  33 public:
  34     VLCAudio(VLCPlugin *p_instance) :
  35         _p_instance(p_instance), _p_typeinfo(NULL) {};
  36     virtual ~VLCAudio();
  37
  38     // IUnknown methods
  39     STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
  40     {
  41         if( NULL == ppv )
  42           return E_POINTER;
  43         if( (IID_IUnknown == riid)
  44          || (IID_IDispatch == riid)
  45          || (IID_IVLCAudio == riid) )
  46         {
  47             AddRef();
  48             *ppv = reinterpret_cast<LPVOID>(this);
  49             return NOERROR;
  50         }
  51         // behaves as a standalone object
  52         return E_NOINTERFACE;
  53     };
  54
  55     STDMETHODIMP_(ULONG) AddRef(void) { return _p_instance->pUnkOuter->AddRef(); };
  56     STDMETHODIMP_(ULONG) Release(void) { return _p_instance->pUnkOuter->Release(); };
  57
  58     // IDispatch methods
  59     STDMETHODIMP GetTypeInfoCount(UINT*);
  60     STDMETHODIMP GetTypeInfo(UINT, LCID, LPTYPEINFO*);
  61     STDMETHODIMP GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*);
  62     STDMETHODIMP Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*);
  63
  64     // IVLCAudio methods
  65     STDMETHODIMP get_mute(VARIANT_BOOL*);
  66     STDMETHODIMP put_mute(VARIANT_BOOL);
  67     STDMETHODIMP get_volume(long*);
  68     STDMETHODIMP put_volume(long);
  69     STDMETHODIMP get_track(long*);
  70     STDMETHODIMP put_track(long);
  71     STDMETHODIMP get_channel(long*);
  72     STDMETHODIMP put_channel(long);
  73     STDMETHODIMP toggleMute();
  74
  75 protected:
  76     HRESULT loadTypeInfo();
  77     HRESULT exception_bridge(libvlc_exception_t *ex);
  78
  79 private:
  80     VLCPlugin*      _p_instance;
  81     ITypeInfo*      _p_typeinfo;
  82
  83 };
  84
  85 class VLCInput : public IVLCInput
  86 {
  87 public:
  88
  89     VLCInput(VLCPlugin *p_instance) :
  90         _p_instance(p_instance), _p_typeinfo(NULL) {};
  91     virtual ~VLCInput();
  92
  93     // IUnknown methods
  94     STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
  95     {
  96         if( NULL == ppv )
  97           return E_POINTER;
  98         if( (IID_IUnknown == riid)
  99          || (IID_IDispatch == riid)
 100          || (IID_IVLCInput == riid) )
 101         {
 102             AddRef();
 103             *ppv = reinterpret_cast<LPVOID>(this);
 104             return NOERROR;
 105         }
 106         // behaves as a standalone object
 107         return E_NOINTERFACE;
 108     };
 109
 110     STDMETHODIMP_(ULONG) AddRef(void) { return _p_instance->pUnkOuter->AddRef(); };
 111     STDMETHODIMP_(ULONG) Release(void) { return _p_instance->pUnkOuter->Release(); };
 112
 113     // IDispatch methods
 114     STDMETHODIMP GetTypeInfoCount(UINT*);
 115     STDMETHODIMP GetTypeInfo(UINT, LCID, LPTYPEINFO*);
 116     STDMETHODIMP GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*);
 117     STDMETHODIMP Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*);
 118
 119     // IVLCInput methods
 120     STDMETHODIMP get_length(double*);
 121     STDMETHODIMP get_position(double*);
 122     STDMETHODIMP put_position(double);
 123     STDMETHODIMP get_time(double*);
 124     STDMETHODIMP put_time(double);
 125     STDMETHODIMP get_state(long*);
 126     STDMETHODIMP get_rate(double*);
 127     STDMETHODIMP put_rate(double);
 128     STDMETHODIMP get_fps(double*);
 129     STDMETHODIMP get_hasVout(VARIANT_BOOL*);
 130
 131 protected:
 132     HRESULT loadTypeInfo();
 133     HRESULT exception_bridge(libvlc_exception_t *ex);
 134
 135 private:
 136     VLCPlugin*      _p_instance;
 137     ITypeInfo*      _p_typeinfo;
 138
 139 };
 140
 141 class VLCMessage: public IVLCMessage
 142 {
 143 public:
 144
 145     VLCMessage(VLCPlugin *p_instance, struct libvlc_log_message_t &msg) :
 146         _p_instance(p_instance),
 147         _p_typeinfo(NULL),
 148         _refcount(1),
 149         _msg(msg) {};
 150     virtual ~VLCMessage();
 151
 152     // IUnknown methods
 153     STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
 154     {
 155         if( NULL == ppv )
 156           return E_POINTER;
 157         if( (IID_IUnknown == riid)
 158          || (IID_IDispatch == riid)
 159          || (IID_IVLCMessage == riid) )
 160         {
 161             AddRef();
 162             *ppv = reinterpret_cast<LPVOID>(this);
 163             return NOERROR;
 164         }
 165         // behaves as a standalone object
 166         return E_NOINTERFACE;
 167     };
 168
 169     STDMETHODIMP_(ULONG) AddRef(void) { return InterlockedIncrement(&_refcount); };
 170     STDMETHODIMP_(ULONG) Release(void)
 171     {
 172         ULONG refcount = InterlockedDecrement(&_refcount);
 173         if( 0 == refcount )
 174         {
 175             delete this;
 176             return 0;
 177         }
 178         return refcount;
 179     };
 180
 181     // IDispatch methods
 182     STDMETHODIMP GetTypeInfoCount(UINT*);
 183     STDMETHODIMP GetTypeInfo(UINT, LCID, LPTYPEINFO*);
 184     STDMETHODIMP GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*);
 185     STDMETHODIMP Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*);
 186
 187     // IVLCMessage methods
 188     STDMETHODIMP get__Value(VARIANT *);
 189     STDMETHODIMP get_severity(long *);
 190     STDMETHODIMP get_type(BSTR *);
 191     STDMETHODIMP get_name(BSTR *);
 192     STDMETHODIMP get_header(BSTR *);
 193     STDMETHODIMP get_message(BSTR *);
 194
 195 protected:
 196     HRESULT loadTypeInfo();
 197
 198 private:
 199     VLCPlugin*      _p_instance;
 200     ITypeInfo*      _p_typeinfo;
 201     LONG            _refcount;
 202
 203     struct libvlc_log_message_t _msg;
 204 };
 205
 206 class VLCLog;
 207
 208 class VLCMessageIterator : public IVLCMessageIterator
 209 {
 210 public:
 211
 212     VLCMessageIterator(VLCPlugin *p_instance, VLCLog* p_vlclog);
 213     virtual ~VLCMessageIterator();
 214
 215     // IUnknown methods
 216     STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
 217     {
 218         if( NULL == ppv )
 219           return E_POINTER;
 220         if( (IID_IUnknown == riid)
 221          || (IID_IDispatch == riid)
 222          || (IID_IVLCMessageIterator == riid) )
 223         {
 224             AddRef();
 225             *ppv = reinterpret_cast<LPVOID>(this);
 226             return NOERROR;
 227         }
 228         // behaves as a standalone object
 229         return E_NOINTERFACE;
 230     };
 231
 232     STDMETHODIMP_(ULONG) AddRef(void) { return InterlockedIncrement(&_refcount); };
 233     STDMETHODIMP_(ULONG) Release(void)
 234     {
 235         ULONG refcount = InterlockedDecrement(&_refcount);
 236         if( 0 == refcount )
 237         {
 238             delete this;
 239             return 0;
 240         }
 241         return refcount;
 242     };
 243
 244     // IDispatch methods
 245     STDMETHODIMP GetTypeInfoCount(UINT*);
 246     STDMETHODIMP GetTypeInfo(UINT, LCID, LPTYPEINFO*);
 247     STDMETHODIMP GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*);
 248     STDMETHODIMP Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*);
 249
 250     // IVLCMessageIterator methods
 251     STDMETHODIMP get_hasNext(VARIANT_BOOL*);
 252     STDMETHODIMP next(IVLCMessage**);
 253
 254 protected:
 255     HRESULT loadTypeInfo();
 256     HRESULT exception_bridge(libvlc_exception_t *ex);
 257
 258 private:
 259     VLCPlugin*      _p_instance;
 260     ITypeInfo*      _p_typeinfo;
 261     LONG            _refcount;
 262
 263     VLCLog*                 _p_vlclog;
 264     libvlc_log_iterator_t*  _p_iter;
 265 };
 266
 267 class VLCMessages : public IVLCMessages
 268 {
 269 public:
 270
 271     VLCMessages(VLCPlugin *p_instance, VLCLog *p_vlclog) :
 272         _p_vlclog(p_vlclog),
 273         _p_instance(p_instance),
 274         _p_typeinfo(NULL) {}
 275     virtual ~VLCMessages();
 276
 277     // IUnknown methods
 278     STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
 279     {
 280         if( NULL == ppv )
 281           return E_POINTER;
 282         if( (IID_IUnknown == riid)
 283          || (IID_IDispatch == riid)
 284          || (IID_IVLCMessages == riid) )
 285         {
 286             AddRef();
 287             *ppv = reinterpret_cast<LPVOID>(this);
 288             return NOERROR;
 289         }
 290         // behaves as a standalone object
 291         return E_NOINTERFACE;
 292     };
 293
 294     STDMETHODIMP_(ULONG) AddRef(void) { return _p_instance->pUnkOuter->AddRef(); };
 295     STDMETHODIMP_(ULONG) Release(void) { return _p_instance->pUnkOuter->Release(); };
 296
 297     // IDispatch methods
 298     STDMETHODIMP GetTypeInfoCount(UINT*);
 299     STDMETHODIMP GetTypeInfo(UINT, LCID, LPTYPEINFO*);
 300     STDMETHODIMP GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*);
 301     STDMETHODIMP Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*);
 302
 303     // IVLCMessages methods
 304     STDMETHODIMP get__NewEnum(LPUNKNOWN*);
 305     STDMETHODIMP clear();
 306     STDMETHODIMP get_count(long*);
 307     STDMETHODIMP iterator(IVLCMessageIterator**);
 308
 309 protected:
 310     HRESULT loadTypeInfo();
 311     HRESULT exception_bridge(libvlc_exception_t *ex);
 312
 313     VLCLog*     _p_vlclog;
 314
 315 private:
 316     VLCPlugin*  _p_instance;
 317     ITypeInfo*  _p_typeinfo;
 318 };
 319
 320 class VLCLog : public IVLCLog
 321 {
 322 public:
 323
 324     friend class VLCMessages;
 325     friend class VLCMessageIterator;
 326
 327     VLCLog(VLCPlugin *p_instance) :
 328         _p_log(NULL),
 329         _p_instance(p_instance),
 330         _p_typeinfo(NULL),
 331         _p_vlcmessages(NULL)
 332     {
 333         _p_vlcmessages = new VLCMessages(p_instance, this);
 334     };
 335     virtual ~VLCLog();
 336
 337     // IUnknown methods
 338     STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
 339     {
 340         if( NULL == ppv )
 341           return E_POINTER;
 342         if( (IID_IUnknown == riid)
 343          || (IID_IDispatch == riid)
 344          || (IID_IVLCLog == riid) )
 345         {
 346             AddRef();
 347             *ppv = reinterpret_cast<LPVOID>(this);
 348             return NOERROR;
 349         }
 350         // behaves as a standalone object
 351         return E_NOINTERFACE;
 352     };
 353
 354     STDMETHODIMP_(ULONG) AddRef(void) { return _p_instance->pUnkOuter->AddRef(); };
 355     STDMETHODIMP_(ULONG) Release(void) { return _p_instance->pUnkOuter->Release(); };
 356
 357     // IDispatch methods
 358     STDMETHODIMP GetTypeInfoCount(UINT*);
 359     STDMETHODIMP GetTypeInfo(UINT, LCID, LPTYPEINFO*);
 360     STDMETHODIMP GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*);
 361     STDMETHODIMP Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*);
 362
 363     // IVLCLog methods
 364     STDMETHODIMP get_messages(IVLCMessages**);
 365     STDMETHODIMP get_verbosity(long *);
 366     STDMETHODIMP put_verbosity(long);
 367
 368 protected:
 369     HRESULT loadTypeInfo();
 370     HRESULT exception_bridge(libvlc_exception_t *ex);
 371
 372     libvlc_log_t    *_p_log;
 373
 374 private:
 375     VLCPlugin*      _p_instance;
 376     ITypeInfo*      _p_typeinfo;
 377
 378     VLCMessages*    _p_vlcmessages;
 379 };
 380
 381 class VLCPlaylistItems : public IVLCPlaylistItems
 382 {
 383 public:
 384     VLCPlaylistItems(VLCPlugin *p_instance) :
 385         _p_instance(p_instance), _p_typeinfo(NULL) {};
 386     virtual ~VLCPlaylistItems();
 387
 388     // IUnknown methods
 389     STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
 390     {
 391         if( NULL == ppv )
 392           return E_POINTER;
 393         if( (IID_IUnknown == riid)
 394          || (IID_IDispatch == riid)
 395          || (IID_IVLCPlaylistItems == riid) )
 396         {
 397             AddRef();
 398             *ppv = reinterpret_cast<LPVOID>(this);
 399             return NOERROR;
 400         }
 401         // behaves as a standalone object
 402         return E_NOINTERFACE;
 403     };
 404
 405     STDMETHODIMP_(ULONG) AddRef(void) { return _p_instance->pUnkOuter->AddRef(); };
 406     STDMETHODIMP_(ULONG) Release(void) { return _p_instance->pUnkOuter->Release(); };
 407
 408     // IDispatch methods
 409     STDMETHODIMP GetTypeInfoCount(UINT*);
 410     STDMETHODIMP GetTypeInfo(UINT, LCID, LPTYPEINFO*);
 411     STDMETHODIMP GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*);
 412     STDMETHODIMP Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*);
 413
 414     // IVLCPlaylistItems methods
 415     STDMETHODIMP get_count(long*);
 416     STDMETHODIMP clear();
 417     STDMETHODIMP remove(long);
 418
 419 protected:
 420     HRESULT loadTypeInfo();
 421     HRESULT exception_bridge(libvlc_exception_t *ex);
 422
 423 private:
 424     VLCPlugin*  _p_instance;
 425     ITypeInfo*  _p_typeinfo;
 426
 427 };
 428
 429 class VLCPlaylist : public IVLCPlaylist
 430 {
 431 public:
 432     VLCPlaylist(VLCPlugin *p_instance) :
 433         _p_instance(p_instance),
 434         _p_typeinfo(NULL),
 435         _p_vlcplaylistitems(NULL)
 436     {
 437         _p_vlcplaylistitems = new VLCPlaylistItems(p_instance);
 438     };
 439     virtual ~VLCPlaylist();
 440
 441     // IUnknown methods
 442     STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
 443     {
 444         if( NULL == ppv )
 445           return E_POINTER;
 446         if( (IID_IUnknown == riid)
 447          || (IID_IDispatch == riid)
 448          || (IID_IVLCPlaylist == riid) )
 449         {
 450             AddRef();
 451             *ppv = reinterpret_cast<LPVOID>(this);
 452             return NOERROR;
 453         }
 454         // behaves as a standalone object
 455         return E_NOINTERFACE;
 456     };
 457
 458     STDMETHODIMP_(ULONG) AddRef(void) { return _p_instance->pUnkOuter->AddRef(); };
 459     STDMETHODIMP_(ULONG) Release(void) { return _p_instance->pUnkOuter->Release(); };
 460
 461     // IDispatch methods
 462     STDMETHODIMP GetTypeInfoCount(UINT*);
 463     STDMETHODIMP GetTypeInfo(UINT, LCID, LPTYPEINFO*);
 464     STDMETHODIMP GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*);
 465     STDMETHODIMP Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*);
 466
 467     // IVLCPlaylist methods
 468     STDMETHODIMP get_itemCount(long*);
 469     STDMETHODIMP get_isPlaying(VARIANT_BOOL*);
 470     STDMETHODIMP add(BSTR, VARIANT, VARIANT, long*);
 471     STDMETHODIMP play();
 472     STDMETHODIMP playItem(long);
 473     STDMETHODIMP togglePause();
 474     STDMETHODIMP stop();
 475     STDMETHODIMP next();
 476     STDMETHODIMP prev();
 477     STDMETHODIMP clear();
 478     STDMETHODIMP removeItem(long);
 479     STDMETHODIMP get_items(IVLCPlaylistItems**);
 480
 481 protected:
 482     HRESULT loadTypeInfo();
 483     HRESULT exception_bridge(libvlc_exception_t *ex);
 484
 485 private:
 486     VLCPlugin*  _p_instance;
 487     ITypeInfo*  _p_typeinfo;
 488
 489     VLCPlaylistItems*    _p_vlcplaylistitems;
 490 };
 491
 492 class VLCVideo : public IVLCVideo
 493 {
 494 public:
 495     VLCVideo(VLCPlugin *p_instance) :
 496         _p_instance(p_instance), _p_typeinfo(NULL) {};
 497     virtual ~VLCVideo();
 498
 499     // IUnknown methods
 500     STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
 501     {
 502         if( NULL == ppv )
 503           return E_POINTER;
 504         if( (IID_IUnknown == riid)
 505          || (IID_IDispatch == riid)
 506          || (IID_IVLCVideo == riid) )
 507         {
 508             AddRef();
 509             *ppv = reinterpret_cast<LPVOID>(this);
 510             return NOERROR;
 511         }
 512         // behaves as a standalone object
 513         return E_NOINTERFACE;
 514     };
 515
 516     STDMETHODIMP_(ULONG) AddRef(void) { return _p_instance->pUnkOuter->AddRef(); };
 517     STDMETHODIMP_(ULONG) Release(void) { return _p_instance->pUnkOuter->Release(); };
 518
 519     // IDispatch methods
 520     STDMETHODIMP GetTypeInfoCount(UINT*);
 521     STDMETHODIMP GetTypeInfo(UINT, LCID, LPTYPEINFO*);
 522     STDMETHODIMP GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*);
 523     STDMETHODIMP Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*);
 524
 525     // IVLCVideo methods
 526     STDMETHODIMP get_fullscreen(VARIANT_BOOL*);
 527     STDMETHODIMP put_fullscreen(VARIANT_BOOL);
 528     STDMETHODIMP get_width(long*);
 529     STDMETHODIMP get_height(long*);
 530     STDMETHODIMP get_aspectRatio(BSTR*);
 531     STDMETHODIMP put_aspectRatio(BSTR);
 532     STDMETHODIMP get_subtitle(long*);
 533     STDMETHODIMP put_subtitle(long);
 534     STDMETHODIMP get_crop(BSTR*);
 535     STDMETHODIMP put_crop(BSTR);
 536     STDMETHODIMP get_teletext(long*);
 537     STDMETHODIMP put_teletext(long);
 538     STDMETHODIMP takeSnapshot(LPPICTUREDISP*);
 539     STDMETHODIMP toggleFullscreen();
 540     STDMETHODIMP toggleTeletext();
 541
 542 protected:
 543     HRESULT loadTypeInfo();
 544     HRESULT exception_bridge(libvlc_exception_t *ex);
 545
 546 private:
 547     VLCPlugin*      _p_instance;
 548     ITypeInfo*      _p_typeinfo;
 549
 550 };
 551
 552 class VLCControl2 : public IVLCControl2
 553 {
 554 public:
 555
 556     VLCControl2(VLCPlugin *p_instance);
 557     virtual ~VLCControl2();
 558
 559     // IUnknown methods
 560     STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
 561     {
 562         if( NULL == ppv )
 563           return E_POINTER;
 564         if( (IID_IUnknown == riid)
 565          || (IID_IDispatch == riid)
 566          || (IID_IVLCControl2 == riid) )
 567         {
 568             AddRef();
 569             *ppv = reinterpret_cast<LPVOID>(this);
 570             return NOERROR;
 571         }
 572         return _p_instance->pUnkOuter->QueryInterface(riid, ppv);
 573     };
 574
 575     STDMETHODIMP_(ULONG) AddRef(void) { return _p_instance->pUnkOuter->AddRef(); };
 576     STDMETHODIMP_(ULONG) Release(void) { return _p_instance->pUnkOuter->Release(); };
 577
 578     // IDispatch methods
 579     STDMETHODIMP GetTypeInfoCount(UINT*);
 580     STDMETHODIMP GetTypeInfo(UINT, LCID, LPTYPEINFO*);
 581     STDMETHODIMP GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*);
 582     STDMETHODIMP Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*);
 583
 584     // IVLCControl2 methods
 585     STDMETHODIMP get_AutoLoop(VARIANT_BOOL *autoloop);
 586     STDMETHODIMP put_AutoLoop(VARIANT_BOOL autoloop);
 587     STDMETHODIMP get_AutoPlay(VARIANT_BOOL *autoplay);
 588     STDMETHODIMP put_AutoPlay(VARIANT_BOOL autoplay);
 589     STDMETHODIMP get_BaseURL(BSTR *url);
 590     STDMETHODIMP put_BaseURL(BSTR url);
 591     STDMETHODIMP get_MRL(BSTR *mrl);
 592     STDMETHODIMP put_MRL(BSTR mrl);
 593     STDMETHODIMP get_Toolbar(VARIANT_BOOL *visible);
 594     STDMETHODIMP put_Toolbar(VARIANT_BOOL visible);
 595     STDMETHODIMP get_StartTime(long *seconds);
 596     STDMETHODIMP put_StartTime(long seconds);
 597     STDMETHODIMP get_VersionInfo(BSTR *version);
 598     STDMETHODIMP get_Visible(VARIANT_BOOL *visible);
 599     STDMETHODIMP put_Visible(VARIANT_BOOL visible);
 600     STDMETHODIMP get_Volume(long *volume);
 601     STDMETHODIMP put_Volume(long volume);
 602     STDMETHODIMP get_BackColor(OLE_COLOR *backcolor);
 603     STDMETHODIMP put_BackColor(OLE_COLOR backcolor);
 604
 605     STDMETHODIMP get_audio(IVLCAudio**);
 606     STDMETHODIMP get_input(IVLCInput**);
 607     STDMETHODIMP get_log(IVLCLog**);
 608     STDMETHODIMP get_playlist(IVLCPlaylist**);
 609     STDMETHODIMP get_video(IVLCVideo**);
 610
 611 protected:
 612     HRESULT loadTypeInfo();
 613
 614 private:
 615     VLCPlugin*      _p_instance;
 616     ITypeInfo*      _p_typeinfo;
 617
 618     VLCAudio*       _p_vlcaudio;
 619     VLCInput*       _p_vlcinput;
 620     VLCLog  *       _p_vlclog;
 621     VLCPlaylist*    _p_vlcplaylist;
 622     VLCVideo*       _p_vlcvideo;
 623 };
 624
 625 #endif