Commit 3d831e04 authored by Steve Lhomme's avatar Steve Lhomme

Avoid \r\n problems between platforms

parent cb1f0667
/* this file contains the actual definitions of */ /* this file contains the actual definitions of */
/* the IIDs and CLSIDs */ /* the IIDs and CLSIDs */
/* link this file in with the server and any clients */ /* link this file in with the server and any clients */
/* File created by MIDL compiler version 5.01.0164 */ /* File created by MIDL compiler version 5.01.0164 */
/* at Thu Feb 17 09:25:54 2005 /* at Thu Feb 17 09:25:54 2005
*/ */
/* Compiler settings for axvlc.idl: /* Compiler settings for axvlc.idl:
Oicf (OptLev=i2), W1, Zp8, env=Win32, ms_ext, c_ext Oicf (OptLev=i2), W1, Zp8, env=Win32, ms_ext, c_ext
error checks: allocation ref bounds_check enum stub_data error checks: allocation ref bounds_check enum stub_data
*/ */
//@@MIDL_FILE_HEADING( ) //@@MIDL_FILE_HEADING( )
#ifdef __cplusplus #ifdef __cplusplus
extern "C"{ extern "C"{
#endif #endif
#ifndef __IID_DEFINED__ #ifndef __IID_DEFINED__
#define __IID_DEFINED__ #define __IID_DEFINED__
typedef struct _IID typedef struct _IID
{ {
unsigned long x; unsigned long x;
unsigned short s1; unsigned short s1;
unsigned short s2; unsigned short s2;
unsigned char c[8]; unsigned char c[8];
} IID; } IID;
#endif // __IID_DEFINED__ #endif // __IID_DEFINED__
#ifndef CLSID_DEFINED #ifndef CLSID_DEFINED
#define CLSID_DEFINED #define CLSID_DEFINED
typedef IID CLSID; typedef IID CLSID;
#endif // CLSID_DEFINED #endif // CLSID_DEFINED
const IID LIBID_AXVLC = {0xDF2BBE39,0x40A8,0x433b,{0xA2,0x79,0x07,0x3F,0x48,0xDA,0x94,0xB6}}; const IID LIBID_AXVLC = {0xDF2BBE39,0x40A8,0x433b,{0xA2,0x79,0x07,0x3F,0x48,0xDA,0x94,0xB6}};
const IID IID_IVLCControl = {0xC2FA41D0,0xB113,0x476e,{0xAC,0x8C,0x9B,0xD1,0x49,0x99,0xC1,0xC1}}; const IID IID_IVLCControl = {0xC2FA41D0,0xB113,0x476e,{0xAC,0x8C,0x9B,0xD1,0x49,0x99,0xC1,0xC1}};
const IID DIID_DVLCEvents = {0xDF48072F,0x5EF8,0x434e,{0x9B,0x40,0xE2,0xF3,0xAE,0x75,0x9B,0x5F}}; const IID DIID_DVLCEvents = {0xDF48072F,0x5EF8,0x434e,{0x9B,0x40,0xE2,0xF3,0xAE,0x75,0x9B,0x5F}};
const CLSID CLSID_VLCPlugin = {0xE23FE9C6,0x778E,0x49D4,{0xB5,0x37,0x38,0xFC,0xDE,0x48,0x87,0xD8}}; const CLSID CLSID_VLCPlugin = {0xE23FE9C6,0x778E,0x49D4,{0xB5,0x37,0x38,0xFC,0xDE,0x48,0x87,0xD8}};
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
This diff is collapsed.
/***************************************************************************** /*****************************************************************************
* connectioncontainer.cpp: ActiveX control for VLC * connectioncontainer.cpp: ActiveX control for VLC
***************************************************************************** *****************************************************************************
* Copyright (C) 2005 VideoLAN * Copyright (C) 2005 VideoLAN
* *
* Authors: Damien Fouilleul <Damien.Fouilleul@laposte.net> * Authors: Damien Fouilleul <Damien.Fouilleul@laposte.net>
* *
* This program is free software; you can redistribute it and/or modify * This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by * it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or * the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version. * (at your option) any later version.
* *
* This program is distributed in the hope that it will be useful, * This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details. * GNU General Public License for more details.
* *
* You should have received a copy of the GNU General Public License * You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software * along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA. * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA.
*****************************************************************************/ *****************************************************************************/
#include "plugin.h" #include "plugin.h"
#include "connectioncontainer.h" #include "connectioncontainer.h"
#include "utils.h" #include "utils.h"
using namespace std; using namespace std;
//////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////
class VLCEnumConnections : public IEnumConnections class VLCEnumConnections : public IEnumConnections
{ {
public: public:
VLCEnumConnections(vector<CONNECTDATA> &v) : VLCEnumConnections(vector<CONNECTDATA> &v) :
e(VLCEnum<CONNECTDATA>(IID_IEnumConnections, v)) e(VLCEnum<CONNECTDATA>(IID_IEnumConnections, v))
{ e.setRetainOperation((VLCEnum<CONNECTDATA>::retainer)&retain); }; { e.setRetainOperation((VLCEnum<CONNECTDATA>::retainer)&retain); };
VLCEnumConnections(const VLCEnumConnections &vlcEnum) : e(vlcEnum.e) {}; VLCEnumConnections(const VLCEnumConnections &vlcEnum) : e(vlcEnum.e) {};
virtual ~VLCEnumConnections() {}; virtual ~VLCEnumConnections() {};
// IUnknown methods // IUnknown methods
STDMETHODIMP QueryInterface(REFIID riid, void **ppv) STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
{ return e.QueryInterface(riid, ppv); }; { return e.QueryInterface(riid, ppv); };
STDMETHODIMP_(ULONG) AddRef(void) STDMETHODIMP_(ULONG) AddRef(void)
{ return e.AddRef(); }; { return e.AddRef(); };
STDMETHODIMP_(ULONG) Release(void) STDMETHODIMP_(ULONG) Release(void)
{return e.Release(); }; {return e.Release(); };
//IEnumConnectionPoints //IEnumConnectionPoints
STDMETHODIMP Next(ULONG celt, LPCONNECTDATA rgelt, ULONG *pceltFetched) STDMETHODIMP Next(ULONG celt, LPCONNECTDATA rgelt, ULONG *pceltFetched)
{ return e.Next(celt, rgelt, pceltFetched); }; { return e.Next(celt, rgelt, pceltFetched); };
STDMETHODIMP Skip(ULONG celt) STDMETHODIMP Skip(ULONG celt)
{ return e.Skip(celt);}; { return e.Skip(celt);};
STDMETHODIMP Reset(void) STDMETHODIMP Reset(void)
{ return e.Reset();}; { return e.Reset();};
STDMETHODIMP Clone(LPENUMCONNECTIONS *ppenum) STDMETHODIMP Clone(LPENUMCONNECTIONS *ppenum)
{ if( NULL == ppenum ) return E_POINTER; { if( NULL == ppenum ) return E_POINTER;
*ppenum = dynamic_cast<LPENUMCONNECTIONS>(new VLCEnumConnections(*this)); *ppenum = dynamic_cast<LPENUMCONNECTIONS>(new VLCEnumConnections(*this));
return (NULL != *ppenum) ? S_OK : E_OUTOFMEMORY; return (NULL != *ppenum) ? S_OK : E_OUTOFMEMORY;
}; };
private: private:
static void retain(CONNECTDATA cd) static void retain(CONNECTDATA cd)
{ {
cd.pUnk->AddRef(); cd.pUnk->AddRef();
}; };
VLCEnum<CONNECTDATA> e; VLCEnum<CONNECTDATA> e;
}; };
//////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////
STDMETHODIMP VLCConnectionPoint::GetConnectionInterface(IID *iid) STDMETHODIMP VLCConnectionPoint::GetConnectionInterface(IID *iid)
{ {
if( NULL == iid ) if( NULL == iid )
return E_POINTER; return E_POINTER;
*iid = _iid; *iid = _iid;
return S_OK; return S_OK;
}; };
STDMETHODIMP VLCConnectionPoint::GetConnectionPointContainer(LPCONNECTIONPOINTCONTAINER *ppCPC) STDMETHODIMP VLCConnectionPoint::GetConnectionPointContainer(LPCONNECTIONPOINTCONTAINER *ppCPC)
{ {
if( NULL == ppCPC ) if( NULL == ppCPC )
return E_POINTER; return E_POINTER;
_p_cpc->AddRef(); _p_cpc->AddRef();
*ppCPC = _p_cpc; *ppCPC = _p_cpc;
return S_OK; return S_OK;
}; };
STDMETHODIMP VLCConnectionPoint::Advise(IUnknown *pUnk, DWORD *pdwCookie) STDMETHODIMP VLCConnectionPoint::Advise(IUnknown *pUnk, DWORD *pdwCookie)
{ {
if( (NULL == pUnk) || (NULL == pdwCookie) ) if( (NULL == pUnk) || (NULL == pdwCookie) )
return E_POINTER; return E_POINTER;
CONNECTDATA cd; CONNECTDATA cd;
pUnk->AddRef(); pUnk->AddRef();
cd.pUnk = pUnk; cd.pUnk = pUnk;
*pdwCookie = cd.dwCookie = _connections.size(); *pdwCookie = cd.dwCookie = _connections.size();
_connections.push_back(cd); _connections.push_back(cd);
return S_OK; return S_OK;
}; };
STDMETHODIMP VLCConnectionPoint::Unadvise(DWORD pdwCookie) STDMETHODIMP VLCConnectionPoint::Unadvise(DWORD pdwCookie)
{ {
if( pdwCookie < _connections.size() ) if( pdwCookie < _connections.size() )
{ {
CONNECTDATA cd = _connections[pdwCookie]; CONNECTDATA cd = _connections[pdwCookie];
if( NULL != cd.pUnk ) if( NULL != cd.pUnk )
{ {
cd.pUnk->Release(); cd.pUnk->Release();
cd.pUnk = NULL; cd.pUnk = NULL;
return S_OK; return S_OK;
} }
} }
return CONNECT_E_NOCONNECTION; return CONNECT_E_NOCONNECTION;
}; };
STDMETHODIMP VLCConnectionPoint::EnumConnections(IEnumConnections **ppEnum) STDMETHODIMP VLCConnectionPoint::EnumConnections(IEnumConnections **ppEnum)
{ {
if( NULL == ppEnum ) if( NULL == ppEnum )
return E_POINTER; return E_POINTER;
*ppEnum = dynamic_cast<LPENUMCONNECTIONS>(new VLCEnumConnections(_connections)); *ppEnum = dynamic_cast<LPENUMCONNECTIONS>(new VLCEnumConnections(_connections));
return (NULL != *ppEnum ) ? S_OK : E_OUTOFMEMORY; return (NULL != *ppEnum ) ? S_OK : E_OUTOFMEMORY;
}; };
void VLCConnectionPoint::fireEvent(DISPID dispId, DISPPARAMS* pDispParams) void VLCConnectionPoint::fireEvent(DISPID dispId, DISPPARAMS* pDispParams)
{ {
vector<CONNECTDATA>::iterator end = _connections.end(); vector<CONNECTDATA>::iterator end = _connections.end();
vector<CONNECTDATA>::iterator iter = _connections.begin(); vector<CONNECTDATA>::iterator iter = _connections.begin();
while( iter != end ) while( iter != end )
{ {
CONNECTDATA cd = *iter; CONNECTDATA cd = *iter;
if( NULL != cd.pUnk ) if( NULL != cd.pUnk )
{ {
IDispatch *pDisp; IDispatch *pDisp;
if( SUCCEEDED(cd.pUnk->QueryInterface(IID_IDispatch, (LPVOID *)&pDisp)) ) if( SUCCEEDED(cd.pUnk->QueryInterface(IID_IDispatch, (LPVOID *)&pDisp)) )
{ {
pDisp->Invoke(dispId, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, pDispParams, NULL, NULL, NULL); pDisp->Invoke(dispId, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, pDispParams, NULL, NULL, NULL);
pDisp->Release(); pDisp->Release();
} }
} }
++iter; ++iter;
} }
}; };
void VLCConnectionPoint::firePropChangedEvent(DISPID dispId) void VLCConnectionPoint::firePropChangedEvent(DISPID dispId)
{ {
vector<CONNECTDATA>::iterator end = _connections.end(); vector<CONNECTDATA>::iterator end = _connections.end();
vector<CONNECTDATA>::iterator iter = _connections.begin(); vector<CONNECTDATA>::iterator iter = _connections.begin();
while( iter != end ) while( iter != end )
{ {
CONNECTDATA cd = *iter; CONNECTDATA cd = *iter;
if( NULL != cd.pUnk ) if( NULL != cd.pUnk )
{ {
IPropertyNotifySink *pPropSink; IPropertyNotifySink *pPropSink;
if( SUCCEEDED(cd.pUnk->QueryInterface(IID_IPropertyNotifySink, (LPVOID *)&pPropSink)) ) if( SUCCEEDED(cd.pUnk->QueryInterface(IID_IPropertyNotifySink, (LPVOID *)&pPropSink)) )
{ {
pPropSink->OnChanged(dispId); pPropSink->OnChanged(dispId);
pPropSink->Release(); pPropSink->Release();
} }
} }
++iter; ++iter;
} }
}; };
//////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////
class VLCEnumConnectionPoints : public IEnumConnectionPoints class VLCEnumConnectionPoints : public IEnumConnectionPoints
{ {
public: public:
VLCEnumConnectionPoints(vector<LPCONNECTIONPOINT> &v) : VLCEnumConnectionPoints(vector<LPCONNECTIONPOINT> &v) :
e(VLCEnum<LPCONNECTIONPOINT>(IID_IEnumConnectionPoints, v)) e(VLCEnum<LPCONNECTIONPOINT>(IID_IEnumConnectionPoints, v))
{ e.setRetainOperation((VLCEnum<LPCONNECTIONPOINT>::retainer)&retain); }; { e.setRetainOperation((VLCEnum<LPCONNECTIONPOINT>::retainer)&retain); };
VLCEnumConnectionPoints(const VLCEnumConnectionPoints &vlcEnum) : e(vlcEnum.e) {}; VLCEnumConnectionPoints(const VLCEnumConnectionPoints &vlcEnum) : e(vlcEnum.e) {};
virtual ~VLCEnumConnectionPoints() {}; virtual ~VLCEnumConnectionPoints() {};
// IUnknown methods // IUnknown methods
STDMETHODIMP QueryInterface(REFIID riid, void **ppv) STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
{ return e.QueryInterface(riid, ppv); }; { return e.QueryInterface(riid, ppv); };
STDMETHODIMP_(ULONG) AddRef(void) STDMETHODIMP_(ULONG) AddRef(void)
{ return e.AddRef(); }; { return e.AddRef(); };
STDMETHODIMP_(ULONG) Release(void) STDMETHODIMP_(ULONG) Release(void)
{return e.Release(); }; {return e.Release(); };
//IEnumConnectionPoints //IEnumConnectionPoints
STDMETHODIMP Next(ULONG celt, LPCONNECTIONPOINT *rgelt, ULONG *pceltFetched) STDMETHODIMP Next(ULONG celt, LPCONNECTIONPOINT *rgelt, ULONG *pceltFetched)
{ return e.Next(celt, rgelt, pceltFetched); }; { return e.Next(celt, rgelt, pceltFetched); };
STDMETHODIMP Skip(ULONG celt) STDMETHODIMP Skip(ULONG celt)
{ return e.Skip(celt);}; { return e.Skip(celt);};
STDMETHODIMP Reset(void) STDMETHODIMP Reset(void)
{ return e.Reset();}; { return e.Reset();};
STDMETHODIMP Clone(LPENUMCONNECTIONPOINTS *ppenum) STDMETHODIMP Clone(LPENUMCONNECTIONPOINTS *ppenum)
{ if( NULL == ppenum ) return E_POINTER; { if( NULL == ppenum ) return E_POINTER;
*ppenum = dynamic_cast<LPENUMCONNECTIONPOINTS>(new VLCEnumConnectionPoints(*this)); *ppenum = dynamic_cast<LPENUMCONNECTIONPOINTS>(new VLCEnumConnectionPoints(*this));
return (NULL != *ppenum) ? S_OK : E_OUTOFMEMORY; return (NULL != *ppenum) ? S_OK : E_OUTOFMEMORY;
}; };
private: private:
static void retain(LPCONNECTIONPOINT cp) static void retain(LPCONNECTIONPOINT cp)
{ {
cp->AddRef(); cp->AddRef();
}; };
VLCEnum<LPCONNECTIONPOINT> e; VLCEnum<LPCONNECTIONPOINT> e;
}; };
//////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////
VLCConnectionPointContainer::VLCConnectionPointContainer(VLCPlugin *p_instance) : VLCConnectionPointContainer::VLCConnectionPointContainer(VLCPlugin *p_instance) :
_p_instance(p_instance) _p_instance(p_instance)
{ {
_p_events = new VLCConnectionPoint(dynamic_cast<LPCONNECTIONPOINTCONTAINER>(this), _p_events = new VLCConnectionPoint(dynamic_cast<LPCONNECTIONPOINTCONTAINER>(this),
_p_instance->getDispEventID()); _p_instance->getDispEventID());
_v_cps.push_back(dynamic_cast<LPCONNECTIONPOINT>(_p_events)); _v_cps.push_back(dynamic_cast<LPCONNECTIONPOINT>(_p_events));
_p_props = new VLCConnectionPoint(dynamic_cast<LPCONNECTIONPOINTCONTAINER>(this), _p_props = new VLCConnectionPoint(dynamic_cast<LPCONNECTIONPOINTCONTAINER>(this),
IID_IPropertyNotifySink); IID_IPropertyNotifySink);
_v_cps.push_back(dynamic_cast<LPCONNECTIONPOINT>(_p_props)); _v_cps.push_back(dynamic_cast<LPCONNECTIONPOINT>(_p_props));
}; };
VLCConnectionPointContainer::~VLCConnectionPointContainer() VLCConnectionPointContainer::~VLCConnectionPointContainer()
{ {
_v_cps.clear(); _v_cps.clear();
delete _p_props; delete _p_props;
delete _p_events; delete _p_events;
}; };
STDMETHODIMP VLCConnectionPointContainer::EnumConnectionPoints(LPENUMCONNECTIONPOINTS *ppEnum) STDMETHODIMP VLCConnectionPointContainer::EnumConnectionPoints(LPENUMCONNECTIONPOINTS *ppEnum)
{ {
if( NULL == ppEnum ) if( NULL == ppEnum )
return E_POINTER; return E_POINTER;
*ppEnum = dynamic_cast<LPENUMCONNECTIONPOINTS>(new VLCEnumConnectionPoints(_v_cps)); *ppEnum = dynamic_cast<LPENUMCONNECTIONPOINTS>(new VLCEnumConnectionPoints(_v_cps));
return (NULL != *ppEnum ) ? S_OK : E_OUTOFMEMORY; return (NULL != *ppEnum ) ? S_OK : E_OUTOFMEMORY;
}; };
STDMETHODIMP VLCConnectionPointContainer::FindConnectionPoint(REFIID riid, IConnectionPoint **ppCP) STDMETHODIMP VLCConnectionPointContainer::FindConnectionPoint(REFIID riid, IConnectionPoint **ppCP)
{ {
if( NULL == ppCP ) if( NULL == ppCP )
return E_POINTER; return E_POINTER;
*ppCP = NULL; *ppCP = NULL;
if( IID_IPropertyNotifySink == riid ) if( IID_IPropertyNotifySink == riid )
{ {
_p_props->AddRef(); _p_props->AddRef();
*ppCP = dynamic_cast<LPCONNECTIONPOINT>(_p_props); *ppCP = dynamic_cast<LPCONNECTIONPOINT>(_p_props);
} }
else if( _p_instance->getDispEventID() == riid ) else if( _p_instance->getDispEventID() == riid )
{ {
_p_events->AddRef(); _p_events->AddRef();
*ppCP = dynamic_cast<LPCONNECTIONPOINT>(_p_events); *ppCP = dynamic_cast<LPCONNECTIONPOINT>(_p_events);
} }
else else
return CONNECT_E_NOCONNECTION; return CONNECT_E_NOCONNECTION;
return NOERROR; return NOERROR;
}; };
void VLCConnectionPointContainer::fireEvent(DISPID dispId, DISPPARAMS* pDispParams) void VLCConnectionPointContainer::fireEvent(DISPID dispId, DISPPARAMS* pDispParams)
{ {
_p_events->fireEvent(dispId, pDispParams); _p_events->fireEvent(dispId, pDispParams);
}; };
void VLCConnectionPointContainer::firePropChangedEvent(DISPID dispId) void VLCConnectionPointContainer::firePropChangedEvent(DISPID dispId)
{ {
_p_props->firePropChangedEvent(dispId); _p_props->firePropChangedEvent(dispId);
}; };
/***************************************************************************** /*****************************************************************************
* connectioncontainer.h: ActiveX control for VLC * connectioncontainer.h: ActiveX control for VLC
***************************************************************************** *****************************************************************************
* Copyright (C) 2005 VideoLAN * Copyright (C) 2005 VideoLAN
* *
* Authors: Damien Fouilleul <Damien.Fouilleul@laposte.net> * Authors: Damien Fouilleul <Damien.Fouilleul@laposte.net>
* *
* This program is free software; you can redistribute it and/or modify * This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by * it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or * the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version. * (at your option) any later version.
* *
* This program is distributed in the hope that it will be useful, * This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details. * GNU General Public License for more details.
* *
* You should have received a copy of the GNU General Public License * You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software * along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA. * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA.
*****************************************************************************/ *****************************************************************************/
#ifndef __CONNECTIONCONTAINER_H__ #ifndef __CONNECTIONCONTAINER_H__
#define __CONNECTIONCONTAINER_H__ #define __CONNECTIONCONTAINER_H__
#include <ocidl.h> #include <ocidl.h>
#include <vector> #include <vector>
using namespace std; using namespace std;
class VLCConnectionPoint : public IConnectionPoint class VLCConnectionPoint : public IConnectionPoint
{ {
public: public:
VLCConnectionPoint(IConnectionPointContainer *p_cpc, REFIID iid) : VLCConnectionPoint(IConnectionPointContainer *p_cpc, REFIID iid) :
_iid(iid), _p_cpc(p_cpc) {}; _iid(iid), _p_cpc(p_cpc) {};
virtual ~VLCConnectionPoint() {}; virtual ~VLCConnectionPoint() {};