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 VLCMarquee : public IVLCMarquee
 384 {
 385 public:
 386     VLCMarquee(VLCPlugin *p_instance) :
 387         _p_instance(p_instance), _p_typeinfo(NULL) {};
 388     virtual ~VLCMarquee();
 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_IVLCMarquee == 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     // IVLCMarquee methods
 417     STDMETHODIMP enable();
 418     STDMETHODIMP disable();
 419     STDMETHODIMP text(BSTR);
 420     STDMETHODIMP color(long);
 421     STDMETHODIMP opacity(long);
 422     STDMETHODIMP position(long);
 423     STDMETHODIMP refresh(long);
 424     STDMETHODIMP size(long);
 425     STDMETHODIMP timeout(long);
 426     STDMETHODIMP x(long);
 427     STDMETHODIMP y(long);
 428
 429 protected:
 430     HRESULT loadTypeInfo();
 431     HRESULT exception_bridge(libvlc_exception_t *ex);
 432
 433 private:
 434     VLCPlugin*      _p_instance;
 435     ITypeInfo*      _p_typeinfo;
 436
 437 };
 438
 439 class VLCPlaylistItems : public IVLCPlaylistItems
 440 {
 441 public:
 442     VLCPlaylistItems(VLCPlugin *p_instance) :
 443         _p_instance(p_instance), _p_typeinfo(NULL) {};
 444     virtual ~VLCPlaylistItems();
 445
 446     // IUnknown methods
 447     STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
 448     {
 449         if( NULL == ppv )
 450           return E_POINTER;
 451         if( (IID_IUnknown == riid)
 452          || (IID_IDispatch == riid)
 453          || (IID_IVLCPlaylistItems == riid) )
 454         {
 455             AddRef();
 456             *ppv = reinterpret_cast<LPVOID>(this);
 457             return NOERROR;
 458         }
 459         // behaves as a standalone object
 460         return E_NOINTERFACE;
 461     };
 462
 463     STDMETHODIMP_(ULONG) AddRef(void) { return _p_instance->pUnkOuter->AddRef(); };
 464     STDMETHODIMP_(ULONG) Release(void) { return _p_instance->pUnkOuter->Release(); };
 465
 466     // IDispatch methods
 467     STDMETHODIMP GetTypeInfoCount(UINT*);
 468     STDMETHODIMP GetTypeInfo(UINT, LCID, LPTYPEINFO*);
 469     STDMETHODIMP GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*);
 470     STDMETHODIMP Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*);
 471
 472     // IVLCPlaylistItems methods
 473     STDMETHODIMP get_count(long*);
 474     STDMETHODIMP clear();
 475     STDMETHODIMP remove(long);
 476
 477 protected:
 478     HRESULT loadTypeInfo();
 479     HRESULT exception_bridge(libvlc_exception_t *ex);
 480
 481 private:
 482     VLCPlugin*  _p_instance;
 483     ITypeInfo*  _p_typeinfo;
 484
 485 };
 486
 487 class VLCPlaylist : public IVLCPlaylist
 488 {
 489 public:
 490     VLCPlaylist(VLCPlugin *p_instance) :
 491         _p_instance(p_instance),
 492         _p_typeinfo(NULL),
 493         _p_vlcplaylistitems(NULL)
 494     {
 495         _p_vlcplaylistitems = new VLCPlaylistItems(p_instance);
 496     };
 497     virtual ~VLCPlaylist();
 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_IVLCPlaylist == 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     // IVLCPlaylist methods
 526     STDMETHODIMP get_itemCount(long*);
 527     STDMETHODIMP get_isPlaying(VARIANT_BOOL*);
 528     STDMETHODIMP add(BSTR, VARIANT, VARIANT, long*);
 529     STDMETHODIMP play();
 530     STDMETHODIMP playItem(long);
 531     STDMETHODIMP togglePause();
 532     STDMETHODIMP stop();
 533     STDMETHODIMP next();
 534     STDMETHODIMP prev();
 535     STDMETHODIMP clear();
 536     STDMETHODIMP removeItem(long);
 537     STDMETHODIMP get_items(IVLCPlaylistItems**);
 538
 539 protected:
 540     HRESULT loadTypeInfo();
 541     HRESULT exception_bridge(libvlc_exception_t *ex);
 542
 543 private:
 544     VLCPlugin*  _p_instance;
 545     ITypeInfo*  _p_typeinfo;
 546
 547     VLCPlaylistItems*    _p_vlcplaylistitems;
 548 };
 549
 550 class VLCSubtitle : public IVLCSubtitle
 551 {
 552 public:
 553     VLCSubtitle(VLCPlugin *p_instance) :
 554         _p_instance(p_instance), _p_typeinfo(NULL) {};
 555     virtual ~VLCSubtitle();
 556
 557     // IUnknown methods
 558     STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
 559     {
 560         if( NULL == ppv )
 561           return E_POINTER;
 562         if( (IID_IUnknown == riid)
 563          || (IID_IDispatch == riid)
 564          || (IID_IVLCSubtitle == riid) )
 565         {
 566             AddRef();
 567             *ppv = reinterpret_cast<LPVOID>(this);
 568             return NOERROR;
 569         }
 570         // behaves as a standalone object
 571         return E_NOINTERFACE;
 572     };
 573
 574     STDMETHODIMP_(ULONG) AddRef(void) { return _p_instance->pUnkOuter->AddRef(); };
 575     STDMETHODIMP_(ULONG) Release(void) { return _p_instance->pUnkOuter->Release(); };
 576
 577     // IDispatch methods
 578     STDMETHODIMP GetTypeInfoCount(UINT*);
 579     STDMETHODIMP GetTypeInfo(UINT, LCID, LPTYPEINFO*);
 580     STDMETHODIMP GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*);
 581     STDMETHODIMP Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*);
 582
 583     // IVLCSubtitle methods
 584     STDMETHODIMP get_track(long*);
 585     STDMETHODIMP put_track(long);
 586     STDMETHODIMP get_count(long*);
 587     STDMETHODIMP description(long, BSTR*);
 588
 589 protected:
 590     HRESULT loadTypeInfo();
 591     HRESULT exception_bridge(libvlc_exception_t *ex);
 592
 593 private:
 594     VLCPlugin*      _p_instance;
 595     ITypeInfo*      _p_typeinfo;
 596
 597 };
 598
 599 class VLCVideo : public IVLCVideo
 600 {
 601 public:
 602     VLCVideo(VLCPlugin *p_instance) :
 603         _p_instance(p_instance),
 604         _p_typeinfo(NULL),
 605         _p_vlcmarquee(NULL)
 606     {
 607         _p_vlcmarquee = new VLCMarquee(p_instance);
 608     };
 609     virtual ~VLCVideo();
 610
 611     // IUnknown methods
 612     STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
 613     {
 614         if( NULL == ppv )
 615           return E_POINTER;
 616         if( (IID_IUnknown == riid)
 617          || (IID_IDispatch == riid)
 618          || (IID_IVLCVideo == riid) )
 619         {
 620             AddRef();
 621             *ppv = reinterpret_cast<LPVOID>(this);
 622             return NOERROR;
 623         }
 624         // behaves as a standalone object
 625         return E_NOINTERFACE;
 626     };
 627
 628     STDMETHODIMP_(ULONG) AddRef(void) { return _p_instance->pUnkOuter->AddRef(); };
 629     STDMETHODIMP_(ULONG) Release(void) { return _p_instance->pUnkOuter->Release(); };
 630
 631     // IDispatch methods
 632     STDMETHODIMP GetTypeInfoCount(UINT*);
 633     STDMETHODIMP GetTypeInfo(UINT, LCID, LPTYPEINFO*);
 634     STDMETHODIMP GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*);
 635     STDMETHODIMP Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*);
 636
 637     // IVLCVideo methods
 638     STDMETHODIMP get_fullscreen(VARIANT_BOOL*);
 639     STDMETHODIMP put_fullscreen(VARIANT_BOOL);
 640     STDMETHODIMP get_width(long*);
 641     STDMETHODIMP get_height(long*);
 642     STDMETHODIMP get_aspectRatio(BSTR*);
 643     STDMETHODIMP put_aspectRatio(BSTR);
 644     STDMETHODIMP get_subtitle(long*);
 645     STDMETHODIMP put_subtitle(long);
 646     STDMETHODIMP get_crop(BSTR*);
 647     STDMETHODIMP put_crop(BSTR);
 648     STDMETHODIMP get_teletext(long*);
 649     STDMETHODIMP put_teletext(long);
 650     STDMETHODIMP get_marquee(IVLCMarquee**);
 651     STDMETHODIMP deinterlaceDisable();
 652     STDMETHODIMP deinterlaceEnable(BSTR);
 653     STDMETHODIMP takeSnapshot(LPPICTUREDISP*);
 654     STDMETHODIMP toggleFullscreen();
 655     STDMETHODIMP toggleTeletext();
 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     VLCMarquee*     _p_vlcmarquee;
 665
 666 };
 667
 668 class VLCControl2 : public IVLCControl2
 669 {
 670 public:
 671
 672     VLCControl2(VLCPlugin *p_instance);
 673     virtual ~VLCControl2();
 674
 675     // IUnknown methods
 676     STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
 677     {
 678         if( NULL == ppv )
 679           return E_POINTER;
 680         if( (IID_IUnknown == riid)
 681          || (IID_IDispatch == riid)
 682          || (IID_IVLCControl2 == riid) )
 683         {
 684             AddRef();
 685             *ppv = reinterpret_cast<LPVOID>(this);
 686             return NOERROR;
 687         }
 688         return _p_instance->pUnkOuter->QueryInterface(riid, ppv);
 689     };
 690
 691     STDMETHODIMP_(ULONG) AddRef(void) { return _p_instance->pUnkOuter->AddRef(); };
 692     STDMETHODIMP_(ULONG) Release(void) { return _p_instance->pUnkOuter->Release(); };
 693
 694     // IDispatch methods
 695     STDMETHODIMP GetTypeInfoCount(UINT*);
 696     STDMETHODIMP GetTypeInfo(UINT, LCID, LPTYPEINFO*);
 697     STDMETHODIMP GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*);
 698     STDMETHODIMP Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*);
 699
 700     // IVLCControl2 methods
 701     STDMETHODIMP get_AutoLoop(VARIANT_BOOL *autoloop);
 702     STDMETHODIMP put_AutoLoop(VARIANT_BOOL autoloop);
 703     STDMETHODIMP get_AutoPlay(VARIANT_BOOL *autoplay);
 704     STDMETHODIMP put_AutoPlay(VARIANT_BOOL autoplay);
 705     STDMETHODIMP get_BaseURL(BSTR *url);
 706     STDMETHODIMP put_BaseURL(BSTR url);
 707     STDMETHODIMP get_MRL(BSTR *mrl);
 708     STDMETHODIMP put_MRL(BSTR mrl);
 709     STDMETHODIMP get_Toolbar(VARIANT_BOOL *visible);
 710     STDMETHODIMP put_Toolbar(VARIANT_BOOL visible);
 711     STDMETHODIMP get_StartTime(long *seconds);
 712     STDMETHODIMP put_StartTime(long seconds);
 713     STDMETHODIMP get_VersionInfo(BSTR *version);
 714     STDMETHODIMP get_Visible(VARIANT_BOOL *visible);
 715     STDMETHODIMP put_Visible(VARIANT_BOOL visible);
 716     STDMETHODIMP get_Volume(long *volume);
 717     STDMETHODIMP put_Volume(long volume);
 718     STDMETHODIMP get_BackColor(OLE_COLOR *backcolor);
 719     STDMETHODIMP put_BackColor(OLE_COLOR backcolor);
 720
 721     STDMETHODIMP get_audio(IVLCAudio**);
 722     STDMETHODIMP get_input(IVLCInput**);
 723     STDMETHODIMP get_log(IVLCLog**);
 724     STDMETHODIMP get_playlist(IVLCPlaylist**);
 725     STDMETHODIMP get_subtitle(IVLCSubtitle**);
 726     STDMETHODIMP get_video(IVLCVideo**);
 727
 728 protected:
 729     HRESULT loadTypeInfo();
 730
 731 private:
 732     VLCPlugin*      _p_instance;
 733     ITypeInfo*      _p_typeinfo;
 734
 735     VLCAudio*       _p_vlcaudio;
 736     VLCInput*       _p_vlcinput;
 737     VLCLog  *       _p_vlclog;
 738     VLCPlaylist*    _p_vlcplaylist;
 739     VLCSubtitle*    _p_vlcsubtitle;
 740     VLCVideo*       _p_vlcvideo;
 741 };
 742
 743 #endif