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