Initial version of ActiveX plugin for VLC

Makefile.am

@@ -11,7 +11,7 @@ NULL =
 #  - modules should come before . because vlc needs the builtins
 #  - . should come before mozilla because the plugin needs libvlc_pic.a
 #  - po should come before . because VLC.app needs the pofiles
-SUBDIRS = intl modules po . mozilla share m4 doc
+SUBDIRS = intl modules po . mozilla activex share m4 doc
 DIST_SUBDIRS = $(SUBDIRS) src debian ipkg lib
 
 EXTRA_DIST = \

activex/Makefile.am

+###############################################################################
+# Building the Activex plugin
+###############################################################################
+
+noinst_LIBRARIES = $(noinst_LIBRARIES_activex)
+
+MOSTLYCLEANFILES = $(LIBRARIES_activex)
+EXTRA_DIST = $(SOURCES_activex) $(DIST_rsrc) 
+BUILT_SOURCES = $(BUILT_SOURCES_activex)
+
+SOURCES_activex = \
+    main.cpp \
+    utils.cpp \
+    utils.h \
+    olecontrol.cpp \
+    olecontrol.h \
+    oleinplaceactiveobject.cpp \
+    oleinplaceactiveobject.h \
+    oleinplaceobject.cpp \
+    oleinplaceobject.h \
+    oleobject.cpp \
+    oleobject.h \
+    persistpropbag.cpp \
+    persistpropbag.h \
+    persiststorage.cpp \
+    persiststorage.h \
+    persiststreaminit.cpp \
+    persiststreaminit.h \
+    provideclassinfo.cpp \
+    provideclassinfo.h \
+    connectioncontainer.cpp \
+    connectioncontainer.h \
+    objectsafety.cpp \
+    objectsafety.h \
+    vlccontrol.cpp \
+    vlccontrol.h \
+    plugin.cpp \
+    plugin.h \
+    axvlc_idl.c \
+    axvlc_idl.h \
+	$(NULL)
+
+DIST_rsrc = \
+	axvlc_rc.rc \
+	$(NULL)
+
+LIBRARIES_libvlc = $(top_builddir)/lib/libvlc.a
+
+noinst_LIBRARIES_activex = libaxvlc.a
+axvlc_DATA = axvlc$(LIBEXT)
+axvlcdir = $(libdir)
+
+LDFLAGS_activex = `$(VLC_CONFIG) --libs vlc activex builtin`
+
+libaxvlc_a_SOURCES = $(SOURCES_activex) $(SOURCE_dll)
+libaxvlc_a_CFLAGS = `$(VLC_CONFIG) --cflags activex`
+libaxvlc_a_CXXFLAGS = `$(VLC_CONFIG) --cxxflags activex`
+libaxvlc_a_DEPENDENCIES = axvlc.def $(DATA_axvlc_rc)
+
+axvlc$(LIBEXT): $(libaxvlc_a_OBJECTS) \
+	              $(libaxvlc_a_DEPENDENCIES) stamp-pic
+	$(CXXLINK) $(libaxvlc_a_OBJECTS) $(DATA_axvlc_rc) -Wl,--enable-stdcall-fixup axvlc.def \
+	  $(LIBRARIES_libvlc) -shared $(LDFLAGS_activex)
+
+
+DATA_axvlc_tlb = $(axvlc_tlb_DATA)
+noinst_axvlc_tlb_DATA = axvlc.tlb
+noinst_axvlc_tlbdir = $(libdir)
+
+if HAS_MIDL_COMPILER
+
+axvlc.tlb axvlc_idl.c axvlc_idl.h: axvlc.idl
+	$(MIDL) -Oicf -error all -env win32 -tlb axvlc.tlb -iid axvlc_idl.c -h axvlc_idl.h axvlc.idl
+
+clean-tlb:
+	-rm axvlc.tlb axvlc_idl.c axvlc_idl.h
+
+else
+
+clean-tlb:
+
+endif
+
+DATA_axvlc_rc = $(noinst_axvlc_rc_DATA)
+noinst_axvlc_rc_DATA = axvlc_rc.$(OBJEXT)
+noinst_axvlc_rcdir = $(libdir)
+axvlc_rc.$(OBJEXT): axvlc_rc.rc inplace.bmp $(axvlc_tlb_DATA)
+	$(WINDRES) -DVERSION=$(VERSION) -DVERSION_NUMBER=`echo $(VERSION).0.0.0 | sed 's/\([0-9]*\)[^.]*\.*\([0-9]*\)[^.]*\.*\([0-9]*\)[^.]*\.*\([0-9]*\).*/\1,\2,\3,\4/'` --include-dir $(srcdir) -i $< -o $@
+
+###############################################################################
+# Stamp rules
+###############################################################################
+
+clean-stamp:
+	rm -f stamp-pic
+
+stamp-pic: FORCE
+	@for dep in "" `$(VLC_CONFIG) --target builtin`; do \
+	  if test "$${dep}" -nt "$(LIBRARIES_activex)"; then \
+	    rm -f $@; \
+	    break; \
+	  fi; \
+	done
+	@if test ! -f $@; then printf "" > $@; fi
+
+###############################################################################
+# Clean rules
+###############################################################################
+
+clean-local: clean-stamp clean-tlb
+	-rm axvlc$(LIBEXT)
+
+###############################################################################
+# Force rule
+###############################################################################
+FORCE:
+

activex/README.TXT

+== ACTIVEX Control for VLC ==
+
+The VLC ActiveX Control has been primary designed to work with Internet Explorer.
+however it may also work with Visual Basic and/or .NET
+Please note, that this code does not rely upon MFC/ATL, hence good compatibility
+is not guaranteed
+
+== Compiling ==
+
+In order to script the ActiveX Control on Internet Explorer, a type library is required.
+This type library is usually generated from an IDL file using Microsoft MIDL compiler.
+However, for convenience I have checked in the output of the MIDL compiler in the
+repository so that you will only need the MIDL compiler if you change axvlc.idl.
+the generated files are as follow:
+
+axvlc_idl.c
+axvlc_idl.h
+axvlc.tlb
+
+To use the MIDL compiler on cygwin, you will need to set some environment variables
+before configuring vlc. If you have a copy of 'Microsoft Visual C++ 6.0' installed,
+the following settings are correct:
+
+export PATH=$PATH:"/cygdrive/c/Program Files/Microsoft Visual Studio/COMMON/MSDev98/Bin":"/cygdrive/c/Program Files/Microsoft Visual Studio/VC98/Bin"
+export INCLUDE='C:\Program Files\Microsoft Visual Studio\VC98\Include'
+export MIDL="midl"
+
+if you are cross-compiling on Linux, you may be able to use 'widl' which is part of
+the WINE project (http://www.winehq.com), however I have not tested it.
+
+== Installing ==
+
+The ActiveX control is built as axvlc.dll, which is the only file that needs be
+distributed and it may be installed anywhere on the target machine as long as 
+its path is correct within the registry.
+the necessary registry settings are stored in axvlc.reg
+
+in order to use the plugin, you will need to VLC properly installed on your system
+otherwise make sure that the plugin path is set in the registry as indicated below
+
+[HKEY_LOCAL_MACHINE\Software\VideoLAN\VLC]
+InstallDir="path\\dir\\"
+
+regards,
+    Damien Fouilleul <Damien dot Fouilleul at laposte dot net>

activex/axvlc.def

+LIBRARY AXVLC.DLL
+EXPORTS
+    CLSID_VLCPlugin data
+    DllMain DllMain@12
+    DllCanUnloadNow DllCanUnloadNow@0
+    DllGetClassObject DllGetClassObject@12
+    DllRegisterServer DllRegisterServer@0
+    DllUnregisterServer DllUnregisterServer@0

activex/axvlc.idl

+/*****************************************************************************
+ * axvlc.idl: ActiveX control for VLC
+ *****************************************************************************
+ * Copyright (C) 2005 VideoLAN
+ *
+ * Authors: Damien Fouilleul <Damien.Fouilleul@laposte.net>
+ *
+ * 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
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ *****************************************************************************/
+
+[
+  uuid(DF2BBE39-40A8-433b-A279-073F48DA94B6),
+  version(1.0),
+  helpstring("VideoLAN VLC ActiveX Plugin"),
+]
+library AXVLC
+{
+    importlib("stdole2.tlb");
+
+    // Forward declare all types defined in this typelib
+    interface IVLCControl;
+    dispinterface DVLCEvents;
+
+    enum VLCPlaylistMode {
+        VLCPlayListInsert      =  1,
+        VLCPlayListReplace     =  2,
+        VLCPlayListAppend      =  4,
+        VLCPlayListGo          =  8,
+        VLCPlayListCheckInsert = 16
+    };
+
+    // playlist target position
+    const int VLCPlayListEnd = -666;
+
+    [
+      odl,
+      uuid(C2FA41D0-B113-476e-AC8C-9BD14999C1C1),
+      helpstring("VLC Control"),
+      dual,
+      hidden,
+      oleautomation
+    ]
+    interface IVLCControl : IDispatch {
+        [id(0), bindable, defaultbind, propget, helpstring("Specifies current target in playlist")]
+        HRESULT Value([out, retval] VARIANT* pvarValue);
+        [id(0), bindable, defaultbind, propput, helpstring("Specifies current target in playlist")]
+        HRESULT Value([in] VARIANT pvarValue);
+        [propget, bindable, helpstring("Shows or hides plugin.")]
+        HRESULT Visible([out, retval] VARIANT_BOOL* visible);
+        [propput, bindable, helpstring("Shows or hides plugin.")]
+        HRESULT Visible([in] VARIANT_BOOL visible);
+        [helpstring("Play current target in playlist.")]
+        HRESULT play();
+        [helpstring("Pause playback.")]
+        HRESULT pause();
+        [helpstring("Stop playback.")]
+        HRESULT stop();
+        [propget, helpstring("Specifies whether VLC is playing.")]
+        HRESULT Playing([out, retval] VARIANT_BOOL* isPlaying);
+        [propput, helpstring("Specifies whether VLC is playing.")]
+        HRESULT Playing([in] VARIANT_BOOL isPlaying);
+        [propget, helpstring("Specifies playback position within current target in playlist, position is a relative value ranging from 0.0 to 1.0.")]
+        HRESULT Position([out, retval] float* position);
+        [propput, helpstring("Specifies playback position within current target in playlist, position is a relative value ranging from 0.0 to 1.0.")]
+        HRESULT Position([in] float position);
+        [propget, helpstring("Specifies playback time relative to the start of current target in playlist.")]
+        HRESULT Time([out, retval] int* seconds);
+        [propput, helpstring("Specifies playback time relative to the start of current target in playlist.")]
+        HRESULT Time([in] int seconds);
+        [helpstring("Advance or backtrack playback time, relative to current time.")]
+        HRESULT shuttle([in] int seconds);
+        [helpstring("Switch between normal and fullscreen video.")]
+        HRESULT fullscreen();
+        [propget, helpstring("Returns total length in seconds of current target in playlist, may be unknown.")]
+        HRESULT Length([out, retval] int* seconds);
+        [helpstring("Increases playback speed, one of 1x, 2x, 4x, 8x.")]
+        HRESULT playFaster();
+        [helpstring("Decreases playback speed, one of 1x, 2x, 4x, 8x.")]
+        HRESULT playSlower();
+        [propget, helpstring("Specifies playback sound volume, ranges from 0 to 200%.")]
+        HRESULT Volume([out, retval] int* volume);
+        [propput, helpstring("Specifies playback sound volume, ranges from 0 to 200%.")]
+        HRESULT Volume([in] int volume);
+        [helpstring("Mute/unmute playback sound volume.")]
+        HRESULT toggleMute();
+        [helpstring("Add a target to the current playlist.")]
+
+/*
+** use VARIANT rather than a SAFEARRAY as argument type
+** for compatibility with some scripting language (JScript)
+*/
+
+        HRESULT addTarget([in] BSTR uri, [in] VARIANT options, [in] enum VLCPlaylistMode mode, [in] int position);
+        [propget, helpstring("Returns index of current target in playlist.")]
+        HRESULT PlaylistIndex([out, retval] int* index);
+        [propget, helpstring("Returns number of items in playlist.")]
+        HRESULT PlaylistCount([out, retval] int* index);
+        [helpstring("Advance to next item in playlist.")]
+        HRESULT playlistNext();
+        [helpstring("Advance to previous item in playlist.")]
+        HRESULT playlistPrev();
+        [helpstring("Remove all items from playlist.")]
+        HRESULT playlistClear();
+        [propget, helpstring("Returns VLC Version.")]
+        HRESULT VersionInfo([out, retval] BSTR* version);
+    };
+
+    [
+      uuid(DF48072F-5EF8-434e-9B40-E2F3AE759B5F),
+      helpstring("Event interface for VLC control"),
+      hidden
+    ]
+    dispinterface DVLCEvents {
+        properties:
+        methods:
+            [id(1), helpstring("Playback in progress")]
+            void OnPlay();
+            [id(2), helpstring("Playback has paused")]
+            void OnPause();
+            [id(3), helpstring("Playback has stopped")]
+            void OnStop();
+    };
+
+    [
+      uuid(E23FE9C6-778E-49D4-B537-38FCDE4887D8),
+      helpstring("VLC control"),
+      control
+    ]
+    coclass VLCPlugin {
+        [default] interface IVLCControl;
+        [default, source] dispinterface DVLCEvents;
+    };
+};

activex/axvlc.reg

+REGEDIT4
+
+[HKEY_CLASSES_ROOT\VideoLAN.VLCPlugin]
+@="VideoLAN VLC ActiveX Plugin"
+
+[HKEY_CLASSES_ROOT\VideoLAN.VLCPlugin\CLSID]
+@="{E23FE9C6-778E-49d4-B537-38FCDE4887D8}"
+
+[HKEY_CLASSES_ROOT\VideoLAN.VLCPlugin.1]
+@="VideoLAN VLC ActiveX Plugin"
+
+[HKEY_CLASSES_ROOT\VideoLAN.VLCPlugin.1\CLSID]
+@="{E23FE9C6-778E-49d4-B537-38FCDE4887D8}"
+
+[HKEY_CLASSES_ROOT\AppID\{E23FE9C6-778E-49d4-B537-38FCDE4887D8}]
+@="VideoLAN VLC ActiveX Plugin"
+
+[HKEY_CLASSES_ROOT\CLSID\{E23FE9C6-778E-49d4-B537-38FCDE4887D8}]
+@="VideoLAN VLC ActiveX Plugin"
+"AppID"="{E23FE9C6-778E-49d4-B537-38FCDE4887D8}"
+
+[HKEY_CLASSES_ROOT\CLSID\{E23FE9C6-778E-49d4-B537-38FCDE4887D8}\ProgID]
+@="VideoLAN.VLCPlugin.1"
+
+[HKEY_CLASSES_ROOT\CLSID\{E23FE9C6-778E-49d4-B537-38FCDE4887D8}\VersionIndependentProgID]
+@="VideoLAN.VLCPlugin"
+
+[HKEY_CLASSES_ROOT\CLSID\{E23FE9C6-778E-49d4-B537-38FCDE4887D8}\InprocServer32]
+@="axvlc.dll"
+"ThreadingModel"="Both"
+
+[HKEY_CLASSES_ROOT\CLSID\{E23FE9C6-778E-49d4-B537-38FCDE4887D8}\Implemented Categories\{40FC6ED4-2438-11CF-A3DB-080036F12502}]
+[HKEY_CLASSES_ROOT\CLSID\{E23FE9C6-778E-49d4-B537-38FCDE4887D8}\Implemented Categories\{40FC6ED5-2438-11CF-A3DB-080036F12502}]
+[HKEY_CLASSES_ROOT\CLSID\{E23FE9C6-778E-49d4-B537-38FCDE4887D8}\Implemented Categories\{7DD95801-9882-11CF-9FA9-00AA006C42C4}]
+[HKEY_CLASSES_ROOT\CLSID\{E23FE9C6-778E-49d4-B537-38FCDE4887D8}\Implemented Categories\{7DD95802-9882-11CF-9FA9-00AA006C42C4}]
+
+[HKEY_CLASSES_ROOT\CLSID\{E23FE9C6-778E-49d4-B537-38FCDE4887D8}\Version]
+@="1.0"
+
+[HKEY_CLASSES_ROOT\CLSID\{E23FE9C6-778E-49d4-B537-38FCDE4887D8}\Control]
+@=""
+
+[HKEY_CLASSES_ROOT\CLSID\{E23FE9C6-778E-49d4-B537-38FCDE4887D8}\Insertable]
+@=""
+
+[HKEY_CLASSES_ROOT\CLSID\{E23FE9C6-778E-49d4-B537-38FCDE4887D8}\MiscStatus]
+@="0"
+
+[HKEY_CLASSES_ROOT\CLSID\{E23FE9C6-778E-49d4-B537-38FCDE4887D8}\MiscStatus\1]
+@="131473"
+
+[HKEY_CLASSES_ROOT\CLSID\{E23FE9C6-778E-49d4-B537-38FCDE4887D8}\TypeLib]
+@="{DF2BBE39-40A8-433b-A279-073F48DA94B6}"
+
+[HKEY_CLASSES_ROOT\TypeLib\{DF2BBE39-40A8-433b-A279-073F48DA94B6}\1.0]
+@="VideoLAN VLC ActiveX Plugin"
+
+[HKEY_CLASSES_ROOT\TypeLib\{DF2BBE39-40A8-433b-A279-073F48DA94B6}\1.0\0\win32]
+@="axvlc.dll"
+
+[HKEY_CLASSES_ROOT\TypeLib\{DF2BBE39-40A8-433b-A279-073F48DA94B6}\1.0\FLAGS]
+@="2"

activex/axvlc_idl.c

+/*****************************************************************************
+ * axvlc_idl.c: ActiveX control for VLC
+ *****************************************************************************
+ * Copyright (C) 2005 VideoLAN
+ *
+ * Authors: Damien Fouilleul <Damien.Fouilleul@laposte.net>
+ *
+ * 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
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ *****************************************************************************/
+
+#ifdef __cplusplus
+extern "C"{
+#endif 
+
+
+#ifndef __IID_DEFINED__
+#define __IID_DEFINED__
+
+typedef struct _IID
+{
+    unsigned long x;
+    unsigned short s1;
+    unsigned short s2;
+    unsigned char  c[8];
+} IID;
+
+#endif // __IID_DEFINED__
+
+#ifndef CLSID_DEFINED
+#define CLSID_DEFINED
+typedef IID CLSID;
+#endif // CLSID_DEFINED
+
+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 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}};
+
+
+#ifdef __cplusplus
+}
+#endif
+

activex/axvlc_rc.rc

+#ifndef VERSION_NUMBER
+#define VERSION_NUMBER 0,0,0,0
+#endif
+#ifndef VERSION
+#define VERSION 0.0.0
+#endif
+
+#define STRINGIFY( z ) UGLY_KLUDGE( z )
+#define UGLY_KLUDGE( z ) #z
+
+1 VERSIONINFO
+FILETYPE 1
+FILEOS 4
+PRODUCTVERSION VERSION_NUMBER
+FILEVERSION VERSION_NUMBER
+BEGIN
+  BLOCK "StringFileInfo"
+  BEGIN
+    BLOCK "040904E4"
+    BEGIN
+      VALUE "CompanyName", "VideoLAN Team"
+      VALUE "FileVersion", STRINGIFY( VERSION )
+      VALUE "FileDescription", "VLC media player"
+      VALUE "LegalCopyright", "(c) 1996-2003 VideoLAN"
+    END
+  END
+  BLOCK "VarFileInfo"
+  BEGIN
+    VALUE "Translation", 0x409, 1200
+  END
+END
+
+INPLACE-PICT BITMAP DISCARDABLE "inplace.bmp"
+
+1 TYPELIB "axvlc.tlb"
+

activex/connectioncontainer.cpp

+/*****************************************************************************
+ * connectioncontainer.cpp: ActiveX control for VLC
+ *****************************************************************************
+ * Copyright (C) 2005 VideoLAN
+ *
+ * Authors: Damien Fouilleul <Damien.Fouilleul@laposte.net>
+ *
+ * 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
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ *****************************************************************************/
+
+#include "plugin.h"
+#include "connectioncontainer.h"
+
+#include "utils.h"
+
+using namespace std;
+
+////////////////////////////////////////////////////////////////////////////////////////////////
+
+class VLCEnumConnections : public IEnumConnections
+{
+public:
+    VLCEnumConnections(vector<CONNECTDATA> &v) :
+        e(VLCEnum<CONNECTDATA>(IID_IEnumConnections, v))
+    { e.setRetainOperation((VLCEnum<CONNECTDATA>::retainer)&retain); };
+
+    VLCEnumConnections(const VLCEnumConnections &vlcEnum) : e(vlcEnum.e) {};
+
+    virtual ~VLCEnumConnections() {};
+
+    // IUnknown methods
+    STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
+        { return e.QueryInterface(riid, ppv); };
+    STDMETHODIMP_(ULONG) AddRef(void)
+        { return e.AddRef(); };
+    STDMETHODIMP_(ULONG) Release(void)
+        {return e.Release(); };
+
+    //IEnumConnectionPoints
+    STDMETHODIMP Next(ULONG celt, LPCONNECTDATA rgelt, ULONG *pceltFetched)
+        { return e.Next(celt, rgelt, pceltFetched); };
+    STDMETHODIMP Skip(ULONG celt)
+        { return e.Skip(celt);};
+    STDMETHODIMP Reset(void)
+        { return e.Reset();};
+    STDMETHODIMP Clone(LPENUMCONNECTIONS *ppenum)
+        { if( NULL == ppenum ) return E_POINTER;
+          *ppenum = dynamic_cast<LPENUMCONNECTIONS>(new VLCEnumConnections(*this));
+          return (NULL != *ppenum) ? S_OK : E_OUTOFMEMORY;
+        };
+
+private:
+
+    static void retain(CONNECTDATA cd)
+    {
+        cd.pUnk->AddRef();
+    };
+
+    VLCEnum<CONNECTDATA> e;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////
+
+STDMETHODIMP VLCConnectionPoint::GetConnectionInterface(IID *iid)
+{
+    if( NULL == iid )
+        return E_POINTER;
+
+    *iid = _iid;
+    return S_OK;
+};
+
+STDMETHODIMP VLCConnectionPoint::GetConnectionPointContainer(LPCONNECTIONPOINTCONTAINER *ppCPC)
+{
+    if( NULL == ppCPC )
+        return E_POINTER;
+
+    _p_cpc->AddRef();
+    *ppCPC = _p_cpc;
+    return S_OK;
+};
+
+STDMETHODIMP VLCConnectionPoint::Advise(IUnknown *pUnk, DWORD *pdwCookie)
+{
+    if( (NULL == pUnk) || (NULL == pdwCookie) )
+        return E_POINTER;
+
+    CONNECTDATA cd;
+
+    pUnk->AddRef();
+    cd.pUnk = pUnk;
+    *pdwCookie = cd.dwCookie = _connections.size();
+
+    _connections.push_back(cd);
+
+    return S_OK;
+};
+
+STDMETHODIMP VLCConnectionPoint::Unadvise(DWORD pdwCookie)
+{
+    if( pdwCookie < _connections.size() )
+    {
+        CONNECTDATA cd = _connections[pdwCookie];
+        if( NULL != cd.pUnk )
+        {
+            cd.pUnk->Release();
+            cd.pUnk = NULL;
+            return S_OK;
+        }
+    }
+    return CONNECT_E_NOCONNECTION;
+};
+
+STDMETHODIMP VLCConnectionPoint::EnumConnections(IEnumConnections **ppEnum)
+{
+    if( NULL == ppEnum )
+        return E_POINTER;
+
+    *ppEnum = dynamic_cast<LPENUMCONNECTIONS>(new VLCEnumConnections(_connections));
+
+    return (NULL != *ppEnum ) ? S_OK : E_OUTOFMEMORY;
+};
+
+void VLCConnectionPoint::fireEvent(DISPID dispId, LCID lcid, DISPPARAMS* pDispParams)
+{
+    vector<CONNECTDATA>::iterator end = _connections.end();
+    vector<CONNECTDATA>::iterator iter = _connections.begin();
+
+    while( iter != end )
+    {
+        CONNECTDATA cd = *iter;
+        if( NULL != cd.pUnk )
+        {
+            IDispatch *pDisp;
+            if( SUCCEEDED(cd.pUnk->QueryInterface(IID_IDispatch, (LPVOID *)&pDisp)) )
+            {
+                unsigned int puArgErr;
+                VARIANT vRes;
+
+                if( SUCCEEDED(pDisp->Invoke(dispId, IID_NULL, lcid, DISPATCH_METHOD, pDispParams, &vRes, NULL, &puArgErr)) )
+                {
+                    VariantClear(&vRes);
+                }
+                pDisp->Release();
+            }
+        }
+        ++iter;
+    }
+};
+
+void VLCConnectionPoint::firePropChangedEvent(DISPID dispId)
+{
+    vector<CONNECTDATA>::iterator end = _connections.end();
+    vector<CONNECTDATA>::iterator iter = _connections.begin();
+
+    while( iter != end )
+    {
+        CONNECTDATA cd = *iter;
+        if( NULL != cd.pUnk )
+        {
+            IPropertyNotifySink *pPropSink;
+            if( SUCCEEDED(cd.pUnk->QueryInterface(IID_IPropertyNotifySink, (LPVOID *)&pPropSink)) )
+            {
+                pPropSink->OnChanged(dispId);
+                pPropSink->Release();
+            }
+        }
+        ++iter;
+    }
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////
+
+class VLCEnumConnectionPoints : public IEnumConnectionPoints
+{
+public:
+    VLCEnumConnectionPoints(vector<LPCONNECTIONPOINT> &v) :
+        e(VLCEnum<LPCONNECTIONPOINT>(IID_IEnumConnectionPoints, v))
+    { e.setRetainOperation((VLCEnum<LPCONNECTIONPOINT>::retainer)&retain); };
+
+    VLCEnumConnectionPoints(const VLCEnumConnectionPoints &vlcEnum) : e(vlcEnum.e) {};
+
+    virtual ~VLCEnumConnectionPoints() {};
+
+    // IUnknown methods
+    STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
+        { return e.QueryInterface(riid, ppv); };
+    STDMETHODIMP_(ULONG) AddRef(void)
+        { return e.AddRef(); };
+    STDMETHODIMP_(ULONG) Release(void)
+        {return e.Release(); };
+
+    //IEnumConnectionPoints
+    STDMETHODIMP Next(ULONG celt, LPCONNECTIONPOINT *rgelt, ULONG *pceltFetched)
+        { return e.Next(celt, rgelt, pceltFetched); };
+    STDMETHODIMP Skip(ULONG celt)
+        { return e.Skip(celt);};
+    STDMETHODIMP Reset(void)
+        { return e.Reset();};
+    STDMETHODIMP Clone(LPENUMCONNECTIONPOINTS *ppenum)
+        { if( NULL == ppenum ) return E_POINTER;
+          *ppenum = dynamic_cast<LPENUMCONNECTIONPOINTS>(new VLCEnumConnectionPoints(*this));
+          return (NULL != *ppenum) ? S_OK : E_OUTOFMEMORY;
+        };
+
+private:
+
+    static void retain(LPCONNECTIONPOINT cp)
+    {
+        cp->AddRef();
+    };
+
+    VLCEnum<LPCONNECTIONPOINT> e;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////
+
+VLCConnectionPointContainer::VLCConnectionPointContainer(VLCPlugin *p_instance) :
+    _p_instance(p_instance)
+{
+    _p_events = new VLCConnectionPoint(dynamic_cast<LPCONNECTIONPOINTCONTAINER>(this),
+            _p_instance->getDispEventID());
+
+    _v_cps.push_back(dynamic_cast<LPCONNECTIONPOINT>(_p_events));
+
+    _p_props = new VLCConnectionPoint(dynamic_cast<LPCONNECTIONPOINTCONTAINER>(this),
+            IID_IPropertyNotifySink);
+
+    _v_cps.push_back(dynamic_cast<LPCONNECTIONPOINT>(_p_props));
+};
+
+VLCConnectionPointContainer::~VLCConnectionPointContainer()
+{
+    _v_cps.clear();
+    delete _p_props;
+    delete _p_events;
+};
+
+STDMETHODIMP VLCConnectionPointContainer::EnumConnectionPoints(LPENUMCONNECTIONPOINTS *ppEnum)
+{
+    if( NULL == ppEnum )
+        return E_POINTER;
+
+    *ppEnum = dynamic_cast<LPENUMCONNECTIONPOINTS>(new VLCEnumConnectionPoints(_v_cps));
+
+    return (NULL != *ppEnum ) ? S_OK : E_OUTOFMEMORY;
+};
+
+STDMETHODIMP VLCConnectionPointContainer::FindConnectionPoint(REFIID riid, IConnectionPoint **ppCP)
+{
+    if( NULL == ppCP )
+        return E_POINTER;
+
+    *ppCP = NULL;
+
+    if( IID_IPropertyNotifySink == riid )
+    {
+        _p_props->AddRef();
+        *ppCP = dynamic_cast<LPCONNECTIONPOINT>(_p_props);
+    }
+    else if( _p_instance->getDispEventID() == riid )
+    {
+        _p_events->AddRef();
+        *ppCP = dynamic_cast<LPCONNECTIONPOINT>(_p_events);
+    }
+    else
+        return CONNECT_E_NOCONNECTION;
+
+    return NOERROR;
+};
+
+void VLCConnectionPointContainer::fireEvent(DISPID dispId, LCID lcid, DISPPARAMS* pDispParams)
+{
+    _p_events->fireEvent(dispId,lcid, pDispParams);
+};
+
+void VLCConnectionPointContainer::firePropChangedEvent(DISPID dispId)
+{
+    _p_props->firePropChangedEvent(dispId);
+};
+

activex/connectioncontainer.h

+/*****************************************************************************
+ * connectioncontainer.h: ActiveX control for VLC
+ *****************************************************************************
+ * Copyright (C) 2005 VideoLAN
+ *
+ * Authors: Damien Fouilleul <Damien.Fouilleul@laposte.net>
+ *
+ * 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
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ *****************************************************************************/
+
+#ifndef __CONNECTIONCONTAINER_H__
+#define __CONNECTIONCONTAINER_H__
+
+#include <ocidl.h>
+#include <vector>
+
+using namespace std;
+
+class VLCConnectionPoint : public IConnectionPoint
+{
+
+public:
+
+    VLCConnectionPoint(IConnectionPointContainer *p_cpc, REFIID iid) :
+        _iid(iid), _p_cpc(p_cpc) {};
+    virtual ~VLCConnectionPoint() {};
+
+    // IUnknown methods
+    STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
+    {
+        if( NULL == ppv ) return E_POINTER;
+        if( (IID_IUnknown == riid) 
+         && (IID_IConnectionPoint == riid) ) {
+            AddRef();
+            *ppv = reinterpret_cast<LPVOID>(this);
+            return NOERROR;
+        }
+        // must be a standalone object
+        return E_NOINTERFACE;
+    };
+
+    STDMETHODIMP_(ULONG) AddRef(void) { return _p_cpc->AddRef(); };
+    STDMETHODIMP_(ULONG) Release(void) { return _p_cpc->Release(); };
+
+    // IConnectionPoint methods
+    STDMETHODIMP GetConnectionInterface(IID *);
+    STDMETHODIMP GetConnectionPointContainer(LPCONNECTIONPOINTCONTAINER *);
+    STDMETHODIMP Advise(IUnknown *, DWORD *);
+    STDMETHODIMP Unadvise(DWORD);
+    STDMETHODIMP EnumConnections(LPENUMCONNECTIONS *);
+
+    void fireEvent(DISPID dispIdMember, LCID lcid, DISPPARAMS* pDispParams);
+    void firePropChangedEvent(DISPID dispId);
+
+private:
+
+    REFIID _iid;
+    IConnectionPointContainer *_p_cpc;
+    vector<CONNECTDATA> _connections;
+};
+
+//////////////////////////////////////////////////////////////////////////
+
+class VLCConnectionPointContainer : public IConnectionPointContainer
+{
+
+public:
+
+    VLCConnectionPointContainer(VLCPlugin *p_instance);
+    virtual ~VLCConnectionPointContainer();
+
+    // IUnknown methods
+    STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
+    {
+        if( (NULL != ppv)
+         && (IID_IUnknown == riid) 
+         && (IID_IConnectionPointContainer == riid) ) {
+            AddRef();
+            *ppv = reinterpret_cast<LPVOID>(this);
+            return NOERROR;
+        }
+        return _p_instance->QueryInterface(riid, ppv);
+    };
+
+    STDMETHODIMP_(ULONG) AddRef(void) { return _p_instance->AddRef(); };
+    STDMETHODIMP_(ULONG) Release(void) { return _p_instance->Release(); };
+
+    // IConnectionPointContainer methods
+    STDMETHODIMP EnumConnectionPoints(LPENUMCONNECTIONPOINTS *);
+    STDMETHODIMP FindConnectionPoint(REFIID, LPCONNECTIONPOINT *);
+
+    void fireEvent(DISPID, LCID, DISPPARAMS*);
+    void firePropChangedEvent(DISPID dispId);
+
+private:
+
+    VLCPlugin *_p_instance;
+    VLCConnectionPoint *_p_events;
+    VLCConnectionPoint *_p_props;
+    vector<LPCONNECTIONPOINT> _v_cps;
+};
+
+#endif
+

activex/main.cpp

+/*****************************************************************************
+ * main.cpp: ActiveX control for VLC
+ *****************************************************************************
+ * Copyright (C) 2005 VideoLAN
+ *
+ * Authors: Damien Fouilleul <Damien.Fouilleul@laposte.net>
+ *
+ * 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
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ *****************************************************************************/
+
+#include "plugin.h"
+
+#include <comcat.h>
+
+using namespace std;
+
+static LONG i_class_ref= 0;
+static HINSTANCE h_instance= 0;
+
+STDAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv)
+{
+    HRESULT hr = CLASS_E_CLASSNOTAVAILABLE;
+
+    *ppv = NULL;
+
+    if( CLSID_VLCPlugin == rclsid )
+    {
+        VLCPluginClass *plugin = new VLCPluginClass(&i_class_ref, h_instance);
+        hr = plugin->QueryInterface(riid, ppv);
+        plugin->Release();
+    }
+    return hr;
+};
+
+STDAPI DllCanUnloadNow(VOID)
+{
+    return (0 == i_class_ref) ? S_OK: S_FALSE;
+};
+
+STDAPI DllRegisterServer(VOID)
+{
+    return S_OK;
+};
+
+STDAPI DllUnregisterServer(VOID)
+{
+    return S_OK;
+};
+
+#ifdef BUILD_LOCALSERVER
+
+/*
+** easier to debug an application than a DLL on cygwin GDB :)
+*/
+
+#include <iostream>
+
+STDAPI_(int) WinMain(HINSTANCE hInst, HINSTANCE hPrev, LPSTR szCmdLine, int sw)
+{
+    MSG msg;
+
+    if( FAILED(OleInitialize(NULL)) )
+    {
+        cerr << "cannot initialize OLE" << endl;
+        return 1;
+    }
+
+    IUnknown *classProc = NULL;
+
+    if( FAILED(DllGetClassObject(CLSID_VLCPlugin, IID_IUnknown, (LPVOID *)&classProc)) )
+        return 0;
+ 
+    DWORD dwRegisterClassObject;
+
+    if( FAILED(CoRegisterClassObject(CLSID_VLCPlugin, classProc,
+        CLSCTX_LOCAL_SERVER, REGCLS_MULTIPLEUSE, &dwRegisterClassObject)) )
+        return 0;
+
+    DWORD dwRegisterActiveObject;
+
+    if( FAILED(RegisterActiveObject(classProc, CLSID_VLCPlugin,
+                    ACTIVEOBJECT_WEAK, &dwRegisterActiveObject)) )
+        return 0;
+
+    classProc->Release();
+
+    /*
+    * Polling messages from event queue
+    */
+    while( S_FALSE == DllCanUnloadNow() )
+    {
+        while( PeekMessage(&msg, NULL, 0, 0, PM_REMOVE) )
+        {
+            if( msg.message == WM_QUIT )
+                break;  // Leave the PeekMessage while() loop
+
+            /*if(TranslateAccelerator(ghwndApp, ghAccel, &msg))
+                continue;*/
+
+            TranslateMessage(&msg);
+            DispatchMessage(&msg);
+        }
+
+        if(msg.message == WM_QUIT)
+            break;  // Leave the for() loop
+
+        WaitMessage();
+    }
+
+    if( SUCCEEDED(RevokeActiveObject(dwRegisterActiveObject, NULL)) )
+        CoRevokeClassObject(dwRegisterClassObject);
+
+    // Reached on WM_QUIT message
+    CoUninitialize();
+    return ((int) msg.wParam);
+};
+
+#else
+
+STDAPI_(BOOL) DllMain(HANDLE hModule, DWORD fdwReason, LPVOID lpReserved )
+{
+    switch( fdwReason )
+    {
+        case DLL_PROCESS_ATTACH:
+            h_instance = (HINSTANCE)hModule;
+            break;
+
+        default:
+            break;
+    }
+    return TRUE;
+};
+
+#endif
+

activex/objectsafety.cpp

+/*****************************************************************************
+ * objectsafety.cpp: ActiveX control for VLC
+ *****************************************************************************
+ * Copyright (C) 2005 VideoLAN
+ *
+ * Authors: Damien Fouilleul <Damien.Fouilleul@laposte.net>
+ *
+ * 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
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ *****************************************************************************/
+
+#include "plugin.h"
+#include "objectsafety.h"
+
+#include "axvlc_idl.h"
+
+#if 0
+const GUID IID_IObjectSafety = 
+    {0xCB5BDC81,0x93C1,0x11cf,{0x8F,0x20,0x00,0x80,0x5F,0x2C,0xD0,0x64}}; 
+#endif
+
+STDMETHODIMP VLCObjectSafety::GetInterfaceSafetyOptions(      
+    REFIID riid,
+    DWORD *pdwSupportedOptions,
+    DWORD *pdwEnabledOptions
+)
+{
+    if( (NULL == pdwSupportedOptions) || (NULL == pdwEnabledOptions) )
+        return E_POINTER;
+
+    *pdwSupportedOptions = INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACESAFE_FOR_UNTRUSTED_CALLER;
+
+    if( (IID_IDispatch == riid)
+     || (IID_IVLCControl == riid) )
+    {
+        *pdwEnabledOptions = INTERFACESAFE_FOR_UNTRUSTED_CALLER;
+        return NOERROR;
+    }
+    else if( (IID_IPersist == riid)
+          || (IID_IPersistStreamInit == riid)
+          || (IID_IPersistStorage == riid)
+          || (IID_IPersistPropertyBag == riid) )
+    {
+        *pdwEnabledOptions = INTERFACESAFE_FOR_UNTRUSTED_DATA;
+        return NOERROR;
+    }
+    *pdwEnabledOptions = 0;
+    return E_NOINTERFACE;
+};
+
+STDMETHODIMP VLCObjectSafety::SetInterfaceSafetyOptions(      
+    REFIID riid,
+    DWORD dwOptionSetMask,
+    DWORD dwEnabledOptions
+)
+{
+    if( (IID_IDispatch == riid)
+     || (IID_IVLCControl == riid) )
+    {
+        if( (INTERFACESAFE_FOR_UNTRUSTED_CALLER == dwOptionSetMask)
+         && (INTERFACESAFE_FOR_UNTRUSTED_CALLER == dwEnabledOptions) )
+        {
+            return NOERROR;
+        }
+        return E_FAIL;
+    }
+    else if( (IID_IPersist == riid)
+          || (IID_IPersistStreamInit == riid)
+          || (IID_IPersistStorage == riid)
+          || (IID_IPersistPropertyBag == riid) )
+    {
+        if( (INTERFACESAFE_FOR_UNTRUSTED_DATA == dwOptionSetMask)
+         && (INTERFACESAFE_FOR_UNTRUSTED_DATA == dwEnabledOptions) )
+        {
+            return NOERROR;
+        }
+        return E_FAIL;
+    }
+    return E_FAIL;
+};
+

activex/objectsafety.h

+/*****************************************************************************
+ * objectsafety.h: ActiveX control for VLC
+ *****************************************************************************
+ * Copyright (C) 2005 VideoLAN
+ *
+ * Authors: Damien Fouilleul <Damien.Fouilleul@laposte.net>
+ *
+ * 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
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ *****************************************************************************/
+
+#ifndef __OBJECTSAFETY_H__
+#define __OBJECTSAFETY_H__
+
+#if HAVE_OBJSAFE_HEADER
+/*
+** at last, a version of mingw that supports this header
+*/
+#include <objsafe.h>
+
+#else
+
+// {CB5BDC81-93C1-11cf-8F20-00805F2CD064}
+extern "C" const IID IID_IObjectSafety;
+
+#define INTERFACESAFE_FOR_UNTRUSTED_CALLER 1L
+#define INTERFACESAFE_FOR_UNTRUSTED_DATA   2L
+
+struct IObjectSafety : public IUnknown
+{
+    virtual STDMETHODIMP GetInterfaceSafetyOptions(      
+        REFIID riid,
+        DWORD __RPC_FAR *pdwSupportedOptions,
+        DWORD __RPC_FAR *pdwEnabledOptions
+    ) = 0;
+
+    virtual STDMETHODIMP SetInterfaceSafetyOptions(      
+        REFIID riid,
+        DWORD dwSupportedOptions,
+        DWORD dwOptionSetMask
+    ) = 0;
+};
+
+#endif
+
+class VLCObjectSafety : public IObjectSafety
+{
+public:
+
+    VLCObjectSafety(VLCPlugin *p_instance) : _p_instance(p_instance) {};
+    virtual ~VLCObjectSafety() {};
+
+    // IUnknown methods
+    STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
+    {
+        if( (NULL != ppv)
+         && (IID_IUnknown == riid)
+         && (IID_IObjectSafety == riid) ) 
+        {
+            AddRef();
+            *ppv = reinterpret_cast<LPVOID>(this);
+            return NOERROR;
+        }
+        return _p_instance->QueryInterface(riid, ppv);
+    };
+
+    STDMETHODIMP_(ULONG) AddRef(void) { return _p_instance->AddRef(); };
+    STDMETHODIMP_(ULONG) Release(void) { return _p_instance->Release(); };
+
+    // IUnknown methods
+    STDMETHODIMP GetInterfaceSafetyOptions(      
+        REFIID riid,
+        DWORD *pdwSupportedOptions,
+        DWORD *pdwEnabledOptions
+    );
+
+    STDMETHODIMP SetInterfaceSafetyOptions(      
+        REFIID riid,
+        DWORD dwOptionSetMask,
+        DWORD dwEnabledOptions
+    );
+
+private: 
+
+    VLCPlugin *_p_instance;
+};
+
+#endif

activex/olecontrol.cpp

+/*****************************************************************************
+ * olecontrol.cpp: ActiveX control for VLC
+ *****************************************************************************
+ * Copyright (C) 2005 VideoLAN
+ *
+ * Authors: Damien Fouilleul <Damien.Fouilleul@laposte.net>
+ *
+ * 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
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ *****************************************************************************/
+
+#include "plugin.h"
+#include "olecontrol.h"
+
+#include "utils.h"
+
+using namespace std;
+
+STDMETHODIMP VLCOleControl::GetControlInfo(CONTROLINFO *pCI)
+{
+    if( NULL == pCI )
+        return E_POINTER;
+
+    pCI->cb      = sizeof(CONTROLINFO);
+    pCI->hAccel  = NULL;
+    pCI->cAccel  = 0;
+    pCI->dwFlags = 0;
+
+    return S_OK;
+};
+
+STDMETHODIMP VLCOleControl::OnMnemonic(LPMSG pMsg)
+{
+    return E_NOTIMPL;
+};
+
+static HRESULT getAmbientProperty(VLCPlugin& instance, DISPID dispID, VARIANT& v)
+{
+    HRESULT hr;
+    IOleObject *oleObj;
+
+    hr = instance.QueryInterface(IID_IOleObject, (LPVOID *)&oleObj);
+    if( SUCCEEDED(hr) )
+    {
+        IOleClientSite *clientSite;
+
+        hr = oleObj->GetClientSite(&clientSite);
+        if( SUCCEEDED(hr) && (NULL != clientSite) )
+        {
+            hr = GetObjectProperty(clientSite, dispID, v);
+            clientSite->Release();
+        }
+        oleObj->Release();
+    }
+    return hr;
+};
+
+STDMETHODIMP VLCOleControl::OnAmbientPropertyChange(DISPID dispID)
+{
+    switch( dispID )
+    {
+        case DISPID_AMBIENT_BACKCOLOR:
+            break;
+        case DISPID_AMBIENT_DISPLAYNAME:
+            break;
+        case DISPID_AMBIENT_FONT:
+            break;
+        case DISPID_AMBIENT_FORECOLOR:
+            break;
+        case DISPID_AMBIENT_LOCALEID:
+            break;
+        case DISPID_AMBIENT_MESSAGEREFLECT:
+            break;
+        case DISPID_AMBIENT_SCALEUNITS:
+            break;
+        case DISPID_AMBIENT_TEXTALIGN:
+            break;
+        case DISPID_AMBIENT_USERMODE:
+            break;
+        case DISPID_AMBIENT_UIDEAD:
+            break;
+        case DISPID_AMBIENT_SHOWGRABHANDLES:
+            break;
+        case DISPID_AMBIENT_SHOWHATCHING:
+            break;
+        case DISPID_AMBIENT_DISPLAYASDEFAULT:
+            break;
+        case DISPID_AMBIENT_SUPPORTSMNEMONICS:
+            break;
+        case DISPID_AMBIENT_AUTOCLIP:
+            break;
+        case DISPID_AMBIENT_APPEARANCE:
+            break;
+        case DISPID_AMBIENT_CODEPAGE:
+            VARIANT v;
+            VariantInit(&v);
+            V_VT(&v) = VT_I4;
+            if( SUCCEEDED(getAmbientProperty(*_p_instance, dispID, v)) )
+            {
+                _p_instance->setCodePage(V_I4(&v));
+            }
+            break;
+        case DISPID_AMBIENT_PALETTE:
+            break;
+        case DISPID_AMBIENT_CHARSET:
+            break;
+        case DISPID_AMBIENT_RIGHTTOLEFT:
+            break;
+        case DISPID_AMBIENT_TOPTOBOTTOM:
+            break;
+        default:
+            break;
+    }
+    return S_OK;
+};
+
+STDMETHODIMP VLCOleControl::FreezeEvents(BOOL bFreeze)
+{
+    _p_instance->setSendEvents(! bFreeze);
+    return S_OK;
+};
+

activex/olecontrol.h

+/*****************************************************************************
+ * olecontrol.h: ActiveX control for VLC
+ *****************************************************************************
+ * Copyright (C) 2005 VideoLAN
+ *
+ * Authors: Damien Fouilleul <Damien.Fouilleul@laposte.net>
+ *
+ * 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
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ *****************************************************************************/
+
+#ifndef __OLECONTROL_H__
+#define __OLECONTROL_H__
+
+#include <olectl.h>
+
+class VLCOleControl : public IOleControl
+{
+
+public:
+
+    VLCOleControl(VLCPlugin *p_instance) : _p_instance(p_instance) {};
+    virtual ~VLCOleControl() {};
+
+    // IUnknown methods
+    STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
+    {
+        if( (NULL != ppv)
+         && (IID_IUnknown == riid)
+         && (IID_IOleControl == riid) ) 
+        {
+            AddRef();
+            *ppv = reinterpret_cast<LPVOID>(this);
+            return NOERROR;
+        }
+        return _p_instance->QueryInterface(riid, ppv);
+    };
+
+    STDMETHODIMP_(ULONG) AddRef(void) { return _p_instance->AddRef(); };
+    STDMETHODIMP_(ULONG) Release(void) { return _p_instance->Release(); };
+
+    // IOleControl methods
+    STDMETHODIMP GetControlInfo(CONTROLINFO *pCI);
+    STDMETHODIMP OnMnemonic(LPMSG pMsg);
+    STDMETHODIMP OnAmbientPropertyChange(DISPID dispID);
+    STDMETHODIMP FreezeEvents(BOOL bFreeze);
+
+private:
+
+    VLCPlugin *_p_instance;
+};
+
+#endif
+

activex/oleinplaceactiveobject.cpp

+/*****************************************************************************
+ * oleinplaceactiveobject.cpp: ActiveX control for VLC
+ *****************************************************************************
+ * Copyright (C) 2005 VideoLAN
+ *
+ * Authors: Damien Fouilleul <Damien.Fouilleul@laposte.net>
+ *
+ * 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
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ *****************************************************************************/
+
+#include "plugin.h"
+#include "oleinplaceactiveobject.h"
+
+using namespace std;
+
+STDMETHODIMP VLCOleInPlaceActiveObject::GetWindow(HWND *pHwnd)
+{
+    if( NULL == pHwnd )
+        return E_INVALIDARG;
+
+    if( _p_instance->isInPlaceActive() )
+    {
+        if( NULL != (*pHwnd = _p_instance->getInPlaceWindow()) )
+            return S_OK;
+
+        return E_FAIL;
+    }
+    *pHwnd = NULL;
+
+    return E_UNEXPECTED;
+};
+
+STDMETHODIMP VLCOleInPlaceActiveObject::EnableModeless(BOOL fEnable)
+{
+    return E_NOTIMPL;
+};
+
+STDMETHODIMP VLCOleInPlaceActiveObject::ContextSensitiveHelp(BOOL fEnterMode)
+{
+    return E_NOTIMPL;
+};
+
+STDMETHODIMP VLCOleInPlaceActiveObject::TranslateAccelerator(LPMSG lpmsg)
+{
+    return E_NOTIMPL;
+};
+
+STDMETHODIMP VLCOleInPlaceActiveObject::OnFrameWindowActivate(BOOL fActivate)
+{
+    return E_NOTIMPL;
+};
+
+STDMETHODIMP VLCOleInPlaceActiveObject::OnDocWindowActivate(BOOL fActivate)
+{
+    return E_NOTIMPL;
+};
+
+STDMETHODIMP VLCOleInPlaceActiveObject::ResizeBorder(LPCRECT prcBorder, LPOLEINPLACEUIWINDOW pUIWindow, BOOL fFrameWindow)
+{
+    return E_NOTIMPL;
+};
+

activex/oleinplaceactiveobject.h

+/*****************************************************************************
+ * oleinplaceactiveobject.h: ActiveX control for VLC
+ *****************************************************************************
+ * Copyright (C) 2005 VideoLAN
+ *
+ * Authors: Damien Fouilleul <Damien.Fouilleul@laposte.net>
+ *
+ * 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
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ *****************************************************************************/
+
+#ifndef __OLEINPLACEACTIVEOBJECT_H__
+#define __OLEINPLACEACTIVEOBJECT_H__
+
+#include "oleidl.h"
+
+class VLCOleInPlaceActiveObject : public IOleInPlaceActiveObject
+{
+
+public:
+
+    VLCOleInPlaceActiveObject(VLCPlugin *p_instance) : _p_instance(p_instance) {};
+    virtual ~VLCOleInPlaceActiveObject() {};
+
+    // IUnknown methods
+    STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
+    {
+        if( (NULL != ppv)
+         && (IID_IUnknown == riid) 
+         && (IID_IOleWindow == riid) 
+         && (IID_IOleInPlaceActiveObject == riid) )
+        {
+            AddRef();
+            *ppv = reinterpret_cast<LPVOID>(this);
+            return NOERROR;
+        }
+        return _p_instance->QueryInterface(riid, ppv);
+    };
+
+    STDMETHODIMP_(ULONG) AddRef(void) { return _p_instance->AddRef(); };
+    STDMETHODIMP_(ULONG) Release(void) { return _p_instance->Release(); };
+
+    // IOleWindow methods
+    STDMETHODIMP GetWindow(HWND *);
+    STDMETHODIMP ContextSensitiveHelp(BOOL);
+
+    // IOleInPlaceActiveObject methods
+    STDMETHODIMP EnableModeless(BOOL);
+    STDMETHODIMP TranslateAccelerator(LPMSG);
+    STDMETHODIMP OnFrameWindowActivate(BOOL);
+    STDMETHODIMP OnDocWindowActivate(BOOL);
+    STDMETHODIMP ResizeBorder(LPCRECT, LPOLEINPLACEUIWINDOW, BOOL);
+
+private:
+
+    VLCPlugin *_p_instance;
+};
+
+#endif
+

activex/oleinplaceobject.cpp

+/*****************************************************************************
+ * oleinplaceobject.cpp: ActiveX control for VLC
+ *****************************************************************************
+ * Copyright (C) 2005 VideoLAN
+ *
+ * Authors: Damien Fouilleul <Damien.Fouilleul@laposte.net>
+ *
+ * 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
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ *****************************************************************************/
+
+#include "plugin.h"
+#include "oleinplaceobject.h"
+
+#include <docobj.h>
+
+using namespace std;
+
+STDMETHODIMP VLCOleInPlaceObject::GetWindow(HWND *pHwnd)
+{
+    if( NULL == pHwnd )
+        return E_INVALIDARG;
+
+    if( _p_instance->isInPlaceActive() )
+    {
+        if( NULL != (*pHwnd = _p_instance->getInPlaceWindow()) )
+            return S_OK;
+
+        return E_FAIL;
+    }
+    *pHwnd = NULL;
+
+    return E_UNEXPECTED;
+};
+
+STDMETHODIMP VLCOleInPlaceObject::ContextSensitiveHelp(BOOL fEnterMode)
+{
+    return E_NOTIMPL;
+};
+
+STDMETHODIMP VLCOleInPlaceObject::InPlaceDeactivate(void)
+{
+    if( _p_instance->isInPlaceActive() )
+    {
+        UIDeactivate();
+        _p_instance->onInPlaceDeactivate();
+
+        LPOLEOBJECT p_oleObject;
+        if( SUCCEEDED(QueryInterface(IID_IOleObject, (void**)&p_oleObject)) ) 
+        {
+            LPOLECLIENTSITE p_clientSite;
+            if( SUCCEEDED(p_oleObject->GetClientSite(&p_clientSite)) )
+            {
+                LPOLEINPLACESITE p_inPlaceSite;
+
+                if( SUCCEEDED(p_clientSite->QueryInterface(IID_IOleInPlaceSite, (void**)&p_inPlaceSite)) )
+                {
+                    p_inPlaceSite->OnInPlaceDeactivate();
+                    p_inPlaceSite->Release();
+                }
+                p_clientSite->Release();
+            }
+            p_oleObject->Release();
+        }
+        return S_OK;
+    }
+    return E_UNEXPECTED;
+};
+
+STDMETHODIMP VLCOleInPlaceObject::UIDeactivate(void)
+{
+    if( _p_instance->isInPlaceActive() )
+    {
+        if( _p_instance->hasFocus() )
+        {
+            _p_instance->setFocus(FALSE);
+
+            LPOLEOBJECT p_oleObject;
+            if( SUCCEEDED(QueryInterface(IID_IOleObject, (void**)&p_oleObject)) ) 
+            {
+                LPOLECLIENTSITE p_clientSite;
+                if( SUCCEEDED(p_oleObject->GetClientSite(&p_clientSite)) )
+                {
+                    LPOLEINPLACESITE p_inPlaceSite;
+
+                    if( SUCCEEDED(p_clientSite->QueryInterface(IID_IOleInPlaceSite, (void**)&p_inPlaceSite)) )
+                    {
+                        p_inPlaceSite->OnUIDeactivate(FALSE);
+                        p_inPlaceSite->Release();
+                    }
+                    p_clientSite->Release();
+                }
+                p_oleObject->Release();
+            }
+            return S_OK;
+        }
+    }
+    return E_UNEXPECTED;
+};
+
+STDMETHODIMP VLCOleInPlaceObject::SetObjectRects(LPCRECT lprcPosRect, LPCRECT lprcClipRect)
+{
+    if( _p_instance->isInPlaceActive() )
+    {
+        _p_instance->onPositionChange(lprcPosRect, lprcClipRect);
+        return S_OK;
+    }
+    return E_UNEXPECTED;
+};
+
+STDMETHODIMP VLCOleInPlaceObject::ReactivateAndUndo(void)
+{
+    return INPLACE_E_NOTUNDOABLE;
+};
+

activex/oleinplaceobject.h

+/*****************************************************************************
+ * oleinplaceobject.h: ActiveX control for VLC
+ *****************************************************************************
+ * Copyright (C) 2005 VideoLAN
+ *
+ * Authors: Damien Fouilleul <Damien.Fouilleul@laposte.net>
+ *
+ * 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
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ *****************************************************************************/
+
+#ifndef __OLEINPLACEOBJECT_H__
+#define __OLEINPLACEOBJECT_H__
+
+class VLCOleInPlaceObject : public IOleInPlaceObject
+{
+
+public:
+
+    VLCOleInPlaceObject(VLCPlugin *p_instance) : _p_instance(p_instance) {};
+    virtual ~VLCOleInPlaceObject() {};
+
+    // IUnknown methods
+    STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
+    {
+        if( (NULL != ppv)
+         && (IID_IUnknown == riid)
+         && (IID_IOleWindow == riid)
+         && (IID_IOleInPlaceObject == riid) ) 
+        {
+            AddRef();
+            *ppv = reinterpret_cast<LPVOID>(this);
+            return NOERROR;
+        }
+        return _p_instance->QueryInterface(riid, ppv);
+    };
+
+    STDMETHODIMP_(ULONG) AddRef(void) { return _p_instance->AddRef(); };
+    STDMETHODIMP_(ULONG) Release(void) { return _p_instance->Release(); };
+
+    // IOleWindow methods
+    STDMETHODIMP GetWindow(HWND *);
+    STDMETHODIMP ContextSensitiveHelp(BOOL);
+
+    // IOleInPlaceObject methods
+    STDMETHODIMP InPlaceDeactivate(void);
+    STDMETHODIMP UIDeactivate(void);
+    STDMETHODIMP SetObjectRects(LPCRECT, LPCRECT);
+    STDMETHODIMP ReactivateAndUndo(void);
+
+private:
+
+    VLCPlugin *_p_instance;
+};
+
+#endif
+

activex/oleobject.cpp

+/*****************************************************************************
+ * oleobject.cpp: ActiveX control for VLC
+ *****************************************************************************
+ * Copyright (C) 2005 VideoLAN
+ *
+ * Authors: Damien Fouilleul <Damien.Fouilleul@laposte.net>
+ *
+ * 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
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ *****************************************************************************/
+
+#include "plugin.h"
+#include "oleobject.h"
+
+#include "utils.h"
+
+#include <docobj.h>
+
+using namespace std;
+
+VLCOleObject::VLCOleObject(VLCPlugin *p_instance) :
+_p_clientsite(NULL), _p_instance(p_instance) 
+{
+    CreateOleAdviseHolder(&_p_advise_holder);
+};
+
+VLCOleObject::~VLCOleObject()
+{
+    _p_advise_holder->Release();
+    SetClientSite(NULL); 
+};
+
+STDMETHODIMP VLCOleObject::Advise(IAdviseSink *pAdvSink, DWORD *dwConnection)
+{
+    return _p_advise_holder->Advise(pAdvSink, dwConnection);
+};
+
+STDMETHODIMP VLCOleObject::Close(DWORD dwSaveOption)
+{
+    _p_advise_holder->SendOnClose();
+    OleFlushClipboard();
+    return _p_instance->onClose(dwSaveOption);
+};
+
+STDMETHODIMP VLCOleObject::DoVerb(LONG iVerb, LPMSG lpMsg, LPOLECLIENTSITE pActiveSite,
+                                    LONG lIndex, HWND hwndParent, LPCRECT lprcPosRect)
+{
+    if( 0 != lIndex )
+        return DV_E_LINDEX;
+
+    switch( iVerb )
+    {
+        case OLEIVERB_PRIMARY:
+        case OLEIVERB_SHOW:
+        case OLEIVERB_OPEN:
+        case OLEIVERB_INPLACEACTIVATE:
+            if( NULL == hwndParent )
+                return OLEOBJ_S_INVALIDHWND;
+
+            if( SUCCEEDED(doInPlaceActivate(lpMsg, pActiveSite, hwndParent, lprcPosRect)) )
+                return S_OK;
+
+            return OLEOBJ_S_CANNOT_DOVERB_NOW;
+
+        case OLEIVERB_HIDE:
+            _p_instance->setVisible(FALSE);
+            return S_OK;
+
+        case OLEIVERB_UIACTIVATE:
+            return doUIActivate(lpMsg, pActiveSite, hwndParent, lprcPosRect);
+
+        case OLEIVERB_DISCARDUNDOSTATE:
+            return S_OK;
+
+        default:
+            if( NULL == hwndParent )
+                return OLEOBJ_S_INVALIDHWND;
+
+            if( SUCCEEDED(doInPlaceActivate(lpMsg, pActiveSite, hwndParent, lprcPosRect)) )
+                return OLEOBJ_S_INVALIDVERB;
+
+            return OLEOBJ_S_CANNOT_DOVERB_NOW;
+    }
+};
+
+HRESULT VLCOleObject::doInPlaceActivate(LPMSG lpMsg, LPOLECLIENTSITE pActiveSite, HWND hwndParent, LPCRECT lprcPosRect)
+{
+    RECT posRect;
+    RECT clipRect;
+    LPCRECT lprcClipRect = lprcPosRect;
+
+    if( NULL != pActiveSite )
+    {
+        // check if already activated
+        if( _p_instance->isInPlaceActive() )
+        {
+            // just attempt to show object then
+            pActiveSite->ShowObject();
+            _p_instance->setVisible(TRUE);
+            return S_OK;
+        }
+
+        LPOLEINPLACESITE p_inPlaceSite;
+
+        if( SUCCEEDED(pActiveSite->QueryInterface(IID_IOleInPlaceSite, (void**)&p_inPlaceSite)) )
+        {
+            if( S_OK != p_inPlaceSite->CanInPlaceActivate() )
+                return E_FAIL;
+
+            LPOLEINPLACEFRAME p_inPlaceFrame;
+            LPOLEINPLACEUIWINDOW p_inPlaceUIWindow;
+            OLEINPLACEFRAMEINFO oleFrameInfo;
+
+            if( SUCCEEDED(p_inPlaceSite->GetWindowContext(&p_inPlaceFrame, &p_inPlaceUIWindow, &posRect, &clipRect, &oleFrameInfo)) )
+            {
+                lprcPosRect = &posRect;
+                lprcClipRect = &clipRect;
+
+                if( NULL != p_inPlaceFrame )
+                    p_inPlaceFrame->Release();
+                if( NULL != p_inPlaceUIWindow )
+                    p_inPlaceUIWindow->Release();
+            }
+        }
+
+        if( FAILED(_p_instance->onActivateInPlace(lpMsg, hwndParent, lprcPosRect, lprcClipRect)) )
+            return E_FAIL;
+
+        if( NULL != p_inPlaceSite )
+            p_inPlaceSite->OnPosRectChange(lprcPosRect);
+
+        pActiveSite->ShowObject();
+        _p_instance->setVisible(TRUE);
+
+        if( NULL != p_inPlaceSite )
+        {
+            p_inPlaceSite->OnInPlaceActivate();
+            p_inPlaceSite->Release();
+        }
+
+        if( NULL != lpMsg )
+        {
+            switch( lpMsg->message )
+            {
+                case WM_LBUTTONDOWN:
+                case WM_LBUTTONDBLCLK:
+                    doUIActivate(lpMsg, pActiveSite, hwndParent, lprcPosRect);
+                    break;
+                default:
+                    break;
+            }
+        }
+        return S_OK;
+    }
+    return E_FAIL;
+};
+
+HRESULT VLCOleObject::doUIActivate(LPMSG lpMsg, LPOLECLIENTSITE pActiveSite, HWND hwndParent, LPCRECT lprcPosRect)
+{
+    if( NULL != pActiveSite )
+    {
+        // check if already activated
+        if( ! _p_instance->isInPlaceActive() )
+            return OLE_E_NOT_INPLACEACTIVE;
+
+        LPOLEINPLACESITE p_inPlaceSite;
+
+        if( SUCCEEDED(pActiveSite->QueryInterface(IID_IOleInPlaceSite, (void**)&p_inPlaceSite)) )
+        {
+            p_inPlaceSite->OnUIActivate();
+
+            if( NULL != lprcPosRect )
+            {
+                p_inPlaceSite->OnPosRectChange(lprcPosRect);
+            }
+            p_inPlaceSite->Release();
+        }
+
+        pActiveSite->ShowObject();
+        _p_instance->setVisible(TRUE);
+        _p_instance->setFocus(TRUE);
+
+        return S_OK;
+    }
+    return E_FAIL;
+};
+
+STDMETHODIMP VLCOleObject::EnumAdvise(IEnumSTATDATA **ppEnumAdvise)
+{
+    return _p_advise_holder->EnumAdvise(ppEnumAdvise);
+};
+
+STDMETHODIMP VLCOleObject::EnumVerbs(IEnumOleVerb **ppEnumOleVerb)
+{
+    return OLE_S_USEREG;
+};
+
+STDMETHODIMP VLCOleObject::GetClientSite(LPOLECLIENTSITE *ppClientSite)
+{
+    if( NULL == ppClientSite )
+        return E_POINTER;
+ 
+    if( NULL != _p_clientsite )
+        _p_clientsite->AddRef(); 
+
+    *ppClientSite= _p_clientsite;
+    return S_OK;
+};
+
+STDMETHODIMP VLCOleObject::GetClipboardData(DWORD dwReserved, LPDATAOBJECT *ppDataObject)
+{
+    return E_NOTIMPL;
+};
+
+STDMETHODIMP VLCOleObject::GetExtent(DWORD dwDrawAspect, SIZEL *pSizel)
+{
+    return E_NOTIMPL;
+};
+
+STDMETHODIMP VLCOleObject::GetMiscStatus(DWORD dwAspect, DWORD *pdwStatus)
+{
+    if( NULL != pdwStatus )
+        return E_POINTER;
+ 
+    *pdwStatus = OLEMISC_RECOMPOSEONRESIZE
+        | OLEMISC_CANTLINKINSIDE
+        | OLEMISC_INSIDEOUT
+        | OLEMISC_ACTIVATEWHENVISIBLE
+        | OLEMISC_SETCLIENTSITEFIRST;
+    return S_OK;
+};
+
+STDMETHODIMP VLCOleObject::GetMoniker(DWORD dwAssign, DWORD dwWhichMoniker, LPMONIKER *ppMoniker)
+{
+    if( NULL != _p_clientsite )
+        return _p_clientsite->GetMoniker(dwAssign,dwWhichMoniker, ppMoniker);
+ 
+    return E_UNEXPECTED;
+};
+
+STDMETHODIMP VLCOleObject::GetUserClassID(LPCLSID pClsid)
+{
+    if( NULL == pClsid )
+        return E_POINTER;
+ 
+    pClsid = const_cast<LPCLSID>(&_p_instance->getClassID()); 
+    return S_OK;
+};
+
+STDMETHODIMP VLCOleObject::GetUserType(DWORD dwFormOfType, LPOLESTR *pszUserType)
+{
+    return OLE_S_USEREG;
+};
+
+STDMETHODIMP VLCOleObject::InitFromData(LPDATAOBJECT pDataObject, BOOL fCreation, DWORD dwReserved)
+{
+    return E_NOTIMPL;
+};
+
+STDMETHODIMP VLCOleObject::IsUpToDate(void)
+{
+    return S_OK;
+};
+
+STDMETHODIMP VLCOleObject::SetClientSite(LPOLECLIENTSITE pClientSite)
+{
+    if( NULL != _p_clientsite )
+        _p_clientsite->Release(); 
+ 
+    if( NULL != pClientSite )
+    {
+        pClientSite->AddRef();
+
+        /*
+        ** retrieve container ambient properties
+        */
+        VARIANT v;
+        VariantInit(&v);
+        V_VT(&v) = VT_I4;
+        if( SUCCEEDED(GetObjectProperty(pClientSite, DISPID_AMBIENT_CODEPAGE, v)) )
+        {
+            _p_instance->setCodePage(V_I4(&v));
+            VariantClear(&v);
+        }
+    }
+
+    _p_clientsite = pClientSite;
+    return S_OK;
+};
+
+STDMETHODIMP VLCOleObject::SetColorScheme(LOGPALETTE *pLogpal)
+{
+    return E_NOTIMPL;
+};
+
+STDMETHODIMP VLCOleObject::SetExtent(DWORD dwDrawAspect, SIZEL *pSizel)
+{
+    return E_NOTIMPL;
+};
+
+STDMETHODIMP VLCOleObject::SetHostNames(LPCOLESTR szContainerApp, LPCOLESTR szContainerObj)
+{
+    return S_OK;
+};
+
+STDMETHODIMP VLCOleObject::SetMoniker(DWORD dwWhichMoniker, LPMONIKER pMoniker)
+{
+    return _p_advise_holder->SendOnRename(pMoniker);
+};
+
+STDMETHODIMP VLCOleObject::Unadvise(DWORD dwConnection)
+{
+    return _p_advise_holder->Unadvise(dwConnection);
+};
+
+STDMETHODIMP VLCOleObject::Update(void)
+{
+    return S_OK;
+};
+

activex/oleobject.h

+/*****************************************************************************
+ * oleobject.h: ActiveX control for VLC
+ *****************************************************************************
+ * Copyright (C) 2005 VideoLAN
+ *
+ * Authors: Damien Fouilleul <Damien.Fouilleul@laposte.net>
+ *
+ * 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
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ *****************************************************************************/
+
+#ifndef __OLEOBJECT_H__
+#define __OLEOBJECT_H__
+
+class VLCOleObject : public IOleObject
+{
+
+public:
+
+    VLCOleObject(VLCPlugin *p_instance);
+    virtual ~VLCOleObject();
+
+    // IUnknown methods
+    STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
+    {
+        if( (NULL != ppv)
+         && (IID_IUnknown == riid)
+         && (IID_IOleObject == riid) ) 
+        {
+            AddRef();
+            *ppv = reinterpret_cast<LPVOID>(this);
+            return NOERROR;
+        }
+        return _p_instance->QueryInterface(riid, ppv);
+    };
+
+    STDMETHODIMP_(ULONG) AddRef(void) { return _p_instance->AddRef(); };
+    STDMETHODIMP_(ULONG) Release(void) { return _p_instance->Release(); };
+
+    // IOleObject methods
+    STDMETHODIMP Advise(IAdviseSink *, LPDWORD);
+    STDMETHODIMP Close(DWORD);
+    STDMETHODIMP DoVerb(LONG, LPMSG, LPOLECLIENTSITE, LONG, HWND, LPCRECT);
+    STDMETHODIMP EnumAdvise(IEnumSTATDATA **);
+    STDMETHODIMP EnumVerbs(IEnumOleVerb **);
+    STDMETHODIMP GetClientSite(LPOLECLIENTSITE *);
+    STDMETHODIMP GetClipboardData(DWORD, LPDATAOBJECT *);
+    STDMETHODIMP GetExtent(DWORD, SIZEL *);
+    STDMETHODIMP GetMiscStatus(DWORD, DWORD *);
+    STDMETHODIMP GetMoniker(DWORD, DWORD, LPMONIKER *);
+    STDMETHODIMP GetUserClassID(CLSID *);
+    STDMETHODIMP GetUserType(DWORD, LPOLESTR *);
+    STDMETHODIMP InitFromData(IDataObject *, BOOL, DWORD);
+    STDMETHODIMP IsUpToDate(void);
+    STDMETHODIMP SetClientSite(LPOLECLIENTSITE);
+    STDMETHODIMP SetColorScheme(LOGPALETTE *);
+    STDMETHODIMP SetExtent(DWORD, SIZEL *);
+    STDMETHODIMP SetHostNames(LPCOLESTR, LPCOLESTR) ;
+    STDMETHODIMP SetMoniker(DWORD, LPMONIKER);
+    STDMETHODIMP Unadvise(DWORD);
+    STDMETHODIMP Update(void);
+
+private:
+
+    HRESULT doInPlaceActivate(LPMSG lpMsg, LPOLECLIENTSITE pActiveSite, HWND hwndParent, LPCRECT lprcPosRect);
+    HRESULT doUIActivate(LPMSG lpMsg, LPOLECLIENTSITE pActiveSite, HWND hwndParent, LPCRECT lprcPosRect);
+
+    IOleAdviseHolder *_p_advise_holder;
+    IOleClientSite *_p_clientsite;
+
+    VLCPlugin *_p_instance;
+};
+
+#endif
+

activex/persistpropbag.cpp

+/*****************************************************************************
+ * persistpropbag.cpp: ActiveX control for VLC
+ *****************************************************************************
+ * Copyright (C) 2005 VideoLAN
+ *
+ * Authors: Damien Fouilleul <Damien.Fouilleul@laposte.net>
+ *
+ * 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
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ *****************************************************************************/
+
+#include "plugin.h"
+#include "persistpropbag.h"
+
+#include "utils.h"
+
+using namespace std;
+
+STDMETHODIMP VLCPersistPropertyBag::GetClassID(LPCLSID pClsID)
+{
+    if( NULL == pClsID )
+        return E_POINTER;
+
+    *pClsID = _p_instance->getClassID();
+
+    return S_OK;
+};
+
+STDMETHODIMP VLCPersistPropertyBag::InitNew(void)
+{
+    return _p_instance->onInitNew();
+};
+
+STDMETHODIMP VLCPersistPropertyBag::Load(LPPROPERTYBAG pPropBag, LPERRORLOG pErrorLog)
+{
+    if( NULL == pPropBag )
+        return E_POINTER;
+
+    HRESULT hr = _p_instance->onInitNew();
+    if( FAILED(hr) )
+        return hr;
+
+    VARIANT value;
+
+    V_VT(&value) = VT_BSTR;
+    if( S_OK == pPropBag->Read(OLESTR("filename"), &value, pErrorLog) )
+    {
+        char *src = CStrFromBSTR(_p_instance->getCodePage(), V_BSTR(&value));
+        if( NULL != src )
+        {
+            _p_instance->setSourceURL(src);
+            free(src);
+        }
+        VariantClear(&value);
+    }
+
+    V_VT(&value) = VT_BSTR;
+    if( S_OK == pPropBag->Read(OLESTR("src"), &value, pErrorLog) )
+    {
+        char *src = CStrFromBSTR(_p_instance->getCodePage(), V_BSTR(&value));
+        if( NULL != src )
+        {
+            _p_instance->setSourceURL(src);
+            free(src);
+        }
+        VariantClear(&value);
+    }
+
+    V_VT(&value) = VT_BOOL;
+    if( S_OK == pPropBag->Read(OLESTR("autoplay"), &value, pErrorLog) )
+    {
+        _p_instance->setAutoStart(V_BOOL(&value) != VARIANT_FALSE);
+        VariantClear(&value);
+    }
+
+    V_VT(&value) = VT_BOOL;
+    if( S_OK == pPropBag->Read(OLESTR("autostart"), &value, pErrorLog) )
+    {
+        _p_instance->setAutoStart(V_BOOL(&value) != VARIANT_FALSE);
+        VariantClear(&value);
+    }
+
+    V_VT(&value) = VT_BOOL;
+    if( S_OK == pPropBag->Read(OLESTR("loop"), &value, pErrorLog) )
+    {
+        _p_instance->setLoopMode(V_BOOL(&value) != VARIANT_FALSE);
+        VariantClear(&value);
+    }
+
+    V_VT(&value) = VT_BOOL;
+    if( S_OK == pPropBag->Read(OLESTR("mute"), &value, pErrorLog) )
+    {
+        _p_instance->setMute(V_BOOL(&value) != VARIANT_FALSE);
+        VariantClear(&value);
+    }
+
+    V_VT(&value) = VT_BOOL;
+    if( S_OK == pPropBag->Read(OLESTR("showdisplay"), &value, pErrorLog) )
+    {
+        _p_instance->setShowDisplay(V_BOOL(&value) != VARIANT_FALSE);
+        VariantClear(&value);
+    }
+
+    return S_OK;
+};
+
+STDMETHODIMP VLCPersistPropertyBag::Save(LPPROPERTYBAG pPropBag, BOOL fClearDiry, BOOL fSaveAllProperties)
+{
+    if( NULL == pPropBag )
+        return E_POINTER;
+
+    return S_OK;
+};
+

activex/persistpropbag.h

+/*****************************************************************************
+ * persistpropbag.h: ActiveX control for VLC
+ *****************************************************************************
+ * Copyright (C) 2005 VideoLAN
+ *
+ * Authors: Damien Fouilleul <Damien.Fouilleul@laposte.net>
+ *
+ * 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
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ *****************************************************************************/
+
+#ifndef __PERSISTPROPBAG_H__
+#define __PERSISTPROPBAG_H__
+
+#include <ocidl.h>
+
+class VLCPersistPropertyBag : public IPersistPropertyBag
+{
+
+public:
+
+    VLCPersistPropertyBag(VLCPlugin *p_instance) : _p_instance(p_instance) {};
+    virtual ~VLCPersistPropertyBag() {};
+
+    // IUnknown methods
+    STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
+    {
+        if( (NULL != ppv)
+         && (IID_IUnknown == riid) 
+         && (IID_IPersist == riid) 
+         && (IID_IPersistPropertyBag == riid) ) {
+            AddRef();
+            *ppv = reinterpret_cast<LPVOID>(this);
+            return NOERROR;
+        }
+        return _p_instance->QueryInterface(riid, ppv);
+    };
+
+    STDMETHODIMP_(ULONG) AddRef(void) { return _p_instance->AddRef(); };
+    STDMETHODIMP_(ULONG) Release(void) { return _p_instance->Release(); };
+
+    // IPersist methods
+    STDMETHODIMP GetClassID(LPCLSID);
+
+    // IPersistPropertyBag methods
+    STDMETHODIMP InitNew(void);
+    STDMETHODIMP Load(LPPROPERTYBAG, LPERRORLOG);
+    STDMETHODIMP Save(LPPROPERTYBAG, BOOL, BOOL);
+
+private:
+
+    VLCPlugin *_p_instance;
+};
+
+#endif
+

activex/persiststorage.cpp

+/*****************************************************************************
+ * persiststorage.cpp: ActiveX control for VLC
+ *****************************************************************************
+ * Copyright (C) 2005 VideoLAN
+ *
+ * Authors: Damien Fouilleul <Damien.Fouilleul@laposte.net>
+ *
+ * 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
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ *****************************************************************************/
+
+#include "plugin.h"
+#include "persiststorage.h"
+
+using namespace std;
+
+STDMETHODIMP VLCPersistStorage::GetClassID(LPCLSID pClsID)
+{
+    if( NULL == pClsID )
+        return E_POINTER;
+
+    *pClsID = _p_instance->getClassID();
+
+    return S_OK;
+};
+
+STDMETHODIMP VLCPersistStorage::IsDirty(void)
+{
+    return S_FALSE;
+};
+
+STDMETHODIMP VLCPersistStorage::InitNew(IStorage *pStg)
+{
+    if( NULL == pStg )
+        return E_POINTER;
+
+    return _p_instance->onInitNew();
+};
+
+STDMETHODIMP VLCPersistStorage::Load(IStorage *pStg)
+{
+    if( NULL == pStg )
+        return E_POINTER;
+
+    return _p_instance->onInitNew();
+};
+
+STDMETHODIMP VLCPersistStorage::Save(IStorage *pStg, BOOL fSameAsLoad)
+{
+    if( NULL == pStg )
+        return E_POINTER;
+
+    return S_OK;
+};
+
+STDMETHODIMP VLCPersistStorage::SaveCompleted(IStorage *pStg)
+{
+    if( NULL == pStg )
+        return E_POINTER;
+
+    return S_OK;
+};
+
+STDMETHODIMP VLCPersistStorage::HandsOffStorage(void)
+{
+    return S_OK;
+};
+

activex/persiststorage.h

+/*****************************************************************************
+ * persiststorage.h: ActiveX control for VLC
+ *****************************************************************************
+ * Copyright (C) 2005 VideoLAN
+ *
+ * Authors: Damien Fouilleul <Damien.Fouilleul@laposte.net>
+ *
+ * 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
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ *****************************************************************************/
+
+#ifndef __PERSISTSTORAGE_H__
+#define __PERSISTSTORAGE_H__
+
+#include <ocidl.h>
+
+class VLCPersistStorage : public IPersistStorage
+{
+
+public:
+
+    VLCPersistStorage(VLCPlugin *p_instance) : _p_instance(p_instance) {};
+    virtual ~VLCPersistStorage() {};
+
+    // IUnknown methods
+    STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
+    {
+        if( (NULL != ppv)
+         && (IID_IUnknown == riid) 
+         && (IID_IPersist == riid) 
+         && (IID_IPersistStorage == riid) ) {
+            AddRef();
+            *ppv = reinterpret_cast<LPVOID>(this);
+            return NOERROR;
+        }
+        return _p_instance->QueryInterface(riid, ppv);
+    };
+
+    STDMETHODIMP_(ULONG) AddRef(void) { return _p_instance->AddRef(); };
+    STDMETHODIMP_(ULONG) Release(void) { return _p_instance->Release(); };
+
+    // IPersist methods
+    STDMETHODIMP GetClassID(LPCLSID);
+
+    // IPersistStorage methods
+    STDMETHODIMP IsDirty(void);
+    STDMETHODIMP InitNew(IStorage *);
+    STDMETHODIMP Load(IStorage *);
+    STDMETHODIMP Save(IStorage *, BOOL);
+    STDMETHODIMP SaveCompleted(IStorage *);
+    STDMETHODIMP HandsOffStorage(void);
+
+private:
+
+    VLCPlugin *_p_instance;
+};
+
+#endif
+

activex/persiststreaminit.cpp

+/*****************************************************************************
+ * persiststreaminit.cpp: ActiveX control for VLC
+ *****************************************************************************
+ * Copyright (C) 2005 VideoLAN
+ *
+ * Authors: Damien Fouilleul <Damien.Fouilleul@laposte.net>
+ *
+ * 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
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ *****************************************************************************/
+
+#include "plugin.h"
+#include "persiststreaminit.h"
+
+using namespace std;
+
+STDMETHODIMP VLCPersistStreamInit::GetClassID(LPCLSID pClsID)
+{
+    if( NULL == pClsID )
+        return E_POINTER;
+
+    *pClsID = _p_instance->getClassID();
+
+    return S_OK;
+};
+
+STDMETHODIMP VLCPersistStreamInit::InitNew(void)
+{
+    return _p_instance->onInitNew();
+};
+
+STDMETHODIMP VLCPersistStreamInit::Load(LPSTREAM pStm)
+{
+    if( NULL == pStm )
+        return E_POINTER;
+
+    return _p_instance->onInitNew();
+};
+
+STDMETHODIMP VLCPersistStreamInit::Save(LPSTREAM pStm, BOOL fClearDirty)
+{
+    if( NULL == pStm )
+        return E_POINTER;
+
+    return S_OK;
+};
+
+STDMETHODIMP VLCPersistStreamInit::IsDirty(void)
+{
+    return S_FALSE;
+};
+
+STDMETHODIMP VLCPersistStreamInit::GetSizeMax(ULARGE_INTEGER *pcbSize)
+{
+    pcbSize->QuadPart = 0ULL;
+
+    return S_OK;
+};
+

activex/persiststreaminit.h

+/*****************************************************************************
+ * persiststreaminit.h: ActiveX control for VLC
+ *****************************************************************************
+ * Copyright (C) 2005 VideoLAN
+ *
+ * Authors: Damien Fouilleul <Damien.Fouilleul@laposte.net>
+ *
+ * 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
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ *****************************************************************************/
+
+#ifndef __PERSISTSTREAMINIT_H__
+#define __PERSISTSTREAMINIT_H__
+
+#include <ocidl.h>
+
+class VLCPersistStreamInit : public IPersistStreamInit
+{
+
+public:
+
+    VLCPersistStreamInit(VLCPlugin *p_instance) : _p_instance(p_instance) {};
+    virtual ~VLCPersistStreamInit() {};
+
+    // IUnknown methods
+    STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
+    {
+        if( (NULL != ppv)
+         && (IID_IUnknown == riid) 
+         && (IID_IPersist == riid) 
+         && (IID_IPersistStreamInit == riid) ) {
+            AddRef();
+            *ppv = reinterpret_cast<LPVOID>(this);
+            return NOERROR;
+        }
+        return _p_instance->QueryInterface(riid, ppv);
+    };
+
+    STDMETHODIMP_(ULONG) AddRef(void) { return _p_instance->AddRef(); };
+    STDMETHODIMP_(ULONG) Release(void) { return _p_instance->Release(); };
+
+    // IPersist methods
+    STDMETHODIMP GetClassID(LPCLSID);
+
+    // IPersistStreamInit methods
+    STDMETHODIMP IsDirty(void);
+    STDMETHODIMP InitNew(void);
+    STDMETHODIMP Load(LPSTREAM);
+    STDMETHODIMP Save(LPSTREAM, BOOL);
+    STDMETHODIMP GetSizeMax(ULARGE_INTEGER *);
+
+private:
+
+    VLCPlugin *_p_instance;
+};
+
+#endif
+

activex/plugin.h

+/*****************************************************************************
+ * plugin.h: ActiveX control for VLC
+ *****************************************************************************
+ * Copyright (C) 2005 VideoLAN
+ *
+ * Authors: Damien Fouilleul <Damien.Fouilleul@laposte.net>
+ *
+ * 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
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ *****************************************************************************/
+
+#ifndef __PLUGIN_H__
+#define __PLUGIN_H__
+
+#include <ole2.h>
+#include <olectl.h>
+
+#include <vlc/vlc.h>
+
+extern const GUID CLSID_VLCPlugin; 
+extern const GUID LIBID_AXVLC; 
+extern const GUID DIID_DVLCEvents; 
+
+class VLCPluginClass : public IClassFactory
+{
+
+public:
+
+    VLCPluginClass(LONG *p_class_ref,HINSTANCE hInstance);
+
+    /* IUnknown methods */
+    STDMETHODIMP QueryInterface(REFIID riid, void **ppv);
+    STDMETHODIMP_(ULONG) AddRef(void);
+    STDMETHODIMP_(ULONG) Release(void);
+
+    /* IClassFactory methods */
+    STDMETHODIMP CreateInstance(IUnknown *pUnkOuter, REFIID riid, void **ppv);
+    STDMETHODIMP LockServer(BOOL fLock);
+
+    LPCSTR getInPlaceWndClassName(void) const { return TEXT("VLC Plugin In-Place"); };
+    LPCSTR getVideoWndClassName(void) const { return TEXT("VLC Plugin Video"); };
+    HINSTANCE getHInstance(void) const { return _hinstance; };
+    HBITMAP getInPlacePict(void) const { return _inplace_hbitmap; };
+
+protected:
+
+    virtual ~VLCPluginClass();
+
+private:
+
+    LPLONG      _p_class_ref;
+    HINSTANCE   _hinstance;
+    ATOM        _inplace_wndclass_atom;
+    ATOM        _video_wndclass_atom;
+    HBITMAP     _inplace_hbitmap;
+};
+
+class VLCPlugin : public IUnknown
+{
+
+public:
+
+    VLCPlugin(VLCPluginClass *p_class);
+
+    /* IUnknown methods */
+    STDMETHODIMP QueryInterface(REFIID riid, void **ppv);
+    STDMETHODIMP_(ULONG) AddRef(void);
+    STDMETHODIMP_(ULONG) Release(void);
+
+    /* custom methods */
+    HRESULT getTypeLib(ITypeLib **pTL)
+        { return LoadRegTypeLib(LIBID_AXVLC, 1, 0, LOCALE_NEUTRAL, pTL); };
+    REFCLSID getClassID(void) { return (REFCLSID)CLSID_VLCPlugin; };
+    REFIID getDispEventID(void) { return (REFIID)DIID_DVLCEvents; };
+
+    HRESULT onInitNew(void);
+    HRESULT onClose(DWORD dwSaveOption);
+
+    BOOL isInPlaceActive(void);
+    HRESULT onActivateInPlace(LPMSG lpMesg, HWND hwndParent, LPCRECT lprcPosRect, LPCRECT lprcClipRect);
+    HRESULT onInPlaceDeactivate(void);
+    HWND getInPlaceWindow(void) const { return _inplacewnd; };
+
+    BOOL isVisible(void);
+    void setVisible(BOOL fVisible);
+
+    BOOL hasFocus(void);
+    void setFocus(BOOL fFocus);
+
+    UINT getCodePage(void) { return _codepage; };
+    void setCodePage(UINT cp) { _codepage = cp; };
+
+    int  getVLCObject(void) { return _i_vlc; };
+
+    // initial properties
+    void setSourceURL(const char *url) { _psz_src = strdup(url); };
+    void setAutoStart(BOOL autostart) { _b_autostart = autostart; };
+    void setLoopMode(BOOL loopmode) { _b_loopmode = loopmode; };
+    void setMute(BOOL mute) {
+        if( mute && _i_vlc )
+        {
+            VLC_VolumeMute(_i_vlc);
+        }
+    };
+    void setShowDisplay(BOOL show) { _b_showdisplay = show; };
+
+    void onPositionChange(LPCRECT lprcPosRect, LPCRECT lprcClipRect);
+    void onPaint(PAINTSTRUCT &ps, RECT &pr);
+
+    // plugin events
+    void setSendEvents(BOOL sendevents) { _b_sendevents = sendevents; };
+    void fireOnPlayEvent(void);
+    void fireOnPauseEvent(void);
+    void fireOnStopEvent(void);
+
+protected:
+
+    virtual ~VLCPlugin();
+
+private:
+
+    void calcPositionChange(LPRECT lprPosRect, LPCRECT lprcClipRect);
+
+    //implemented interfaces
+    class VLCOleObject *vlcOleObject;
+    class VLCOleControl *vlcOleControl;
+    class VLCOleInPlaceObject *vlcOleInPlaceObject;
+    class VLCOleInPlaceActiveObject *vlcOleInPlaceActiveObject;
+    class VLCPersistStreamInit *vlcPersistStreamInit;
+    class VLCPersistStorage *vlcPersistStorage;
+    class VLCPersistPropertyBag *vlcPersistPropertyBag;
+    class VLCProvideClassInfo *vlcProvideClassInfo;
+    class VLCConnectionPointContainer *vlcConnectionPointContainer;
+    class VLCObjectSafety *vlcObjectSafety;
+    class VLCControl *vlcControl;
+
+    // in place activated window (Clipping window)
+    HWND _inplacewnd;
+    // video window (Drawing window)
+    HWND _videownd;
+    RECT _bounds;
+
+    VLCPluginClass *_p_class;
+    ULONG _i_ref;
+
+    UINT _codepage;
+    char *_psz_src;
+    BOOL _b_autostart;
+    BOOL _b_loopmode;
+    BOOL _b_showdisplay;
+    BOOL _b_sendevents;
+    int _i_vlc;
+};
+
+#endif
+

activex/provideclassinfo.cpp

+/*****************************************************************************
+ * provideclassinfo.cpp: ActiveX control for VLC
+ *****************************************************************************
+ * Copyright (C) 2005 VideoLAN
+ *
+ * Authors: Damien Fouilleul <Damien.Fouilleul@laposte.net>
+ *
+ * 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
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ *****************************************************************************/
+
+#include "plugin.h"
+#include "provideclassinfo.h"
+
+using namespace std;
+
+STDMETHODIMP VLCProvideClassInfo::GetClassInfo(ITypeInfo **ppTI)
+{
+    ITypeLib *p_typelib;
+
+    if( NULL == ppTI )
+        return E_POINTER;
+
+    HRESULT hr = _p_instance->getTypeLib(&p_typelib);
+    if( SUCCEEDED(hr) )
+    {
+        hr = p_typelib->GetTypeInfoOfGuid(_p_instance->getDispEventID(), ppTI);
+        if( FAILED(hr) )
+        {
+            *ppTI = NULL;
+        }
+        p_typelib->Release();
+    }
+    return hr;
+};
+
+STDMETHODIMP VLCProvideClassInfo::GetGUID(DWORD dwGuidKind, GUID *pGUID)
+{
+    if( GUIDKIND_DEFAULT_SOURCE_DISP_IID != dwGuidKind )
+        return E_INVALIDARG;
+
+    if( NULL == pGUID )
+        return E_POINTER;
+
+    *pGUID = _p_instance->getDispEventID();
+
+    return S_OK;
+};
+

activex/provideclassinfo.h

+/*****************************************************************************
+ * provideclassinfo.h: ActiveX control for VLC
+ *****************************************************************************
+ * Copyright (C) 2005 VideoLAN
+ *
+ * Authors: Damien Fouilleul <Damien.Fouilleul@laposte.net>
+ *
+ * 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
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ *****************************************************************************/
+
+#ifndef __PROVIDECLASSINFO_H__
+#define __PROVIDECLASSINFO_H__
+
+#include <ocidl.h>
+
+class VLCProvideClassInfo : public IProvideClassInfo2
+{
+
+public:
+
+    VLCProvideClassInfo(VLCPlugin *p_instance) : _p_instance(p_instance) {};
+    virtual ~VLCProvideClassInfo() {};
+
+    // IUnknown methods
+    STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
+    {
+        if( (NULL != ppv)
+         && (IID_IUnknown == riid) 
+         && (IID_IProvideClassInfo == riid) 
+         && (IID_IProvideClassInfo2 == riid) ) {
+            AddRef();
+            *ppv = reinterpret_cast<LPVOID>(this);
+            return NOERROR;
+        }
+        return _p_instance->QueryInterface(riid, ppv);
+    };
+
+    STDMETHODIMP_(ULONG) AddRef(void) { return _p_instance->AddRef(); };
+    STDMETHODIMP_(ULONG) Release(void) { return _p_instance->Release(); };
+
+    // IProvideClassInfo methods
+    STDMETHODIMP GetClassInfo(ITypeInfo **);
+
+    // IProvideClassInfo2 methods
+    STDMETHODIMP GetGUID(DWORD, GUID *);
+
+private:
+
+    VLCPlugin *_p_instance;
+};
+
+#endif
+

activex/test.html

+<HTML>
+<TITLE>VLC ActiveX plugin test page</TITLE>
+<BODY>
+<SCRIPT LANGUAGE="JScript">
+<!--
+function go(targetURL)
+{
+	var options = new Array(":input-repeat");
+	document.vlc.addTarget(targetURL, options, 4+8, -666);
+};
+//-->
+</SCRIPT>
+<TABLE>
+<TR><TD>
+MRL:
+<INPUT size="80" name="targetTextField" value="">
+<INPUT type=submit value="Go" onClick="go(targetTextField.value);">
+</TD></TR>
+<TR><TD>
+<OBJECT classid="clsid:E23FE9C6-778E-49D4-B537-38FCDE4887D8"
+        width="640" height="480" id="vlc" events="True">
+<param name="Src" value="" />
+<param name="ShowDisplay" value="True" />
+<param name="Loop" value="False" />
+<param name="AutoPlay" value="False" />
+</OBJECT>
+<SCRIPT LANGUAGE="JScript">
+<!--
+function vlc::OnPlay()
+{
+	alert("Playing");
+};
+function vlc::OnPause()
+{
+	alert("Paused");
+};
+function vlc::OnStop()
+{
+	alert("Stopped");
+};
+//-->
+</SCRIPT>
+</TD></TR>
+<TR><TD>
+<INPUT type=submit value="Play" onClick='document.vlc.play();'>
+<INPUT type=submit value="Pause" onClick='document.vlc.pause();'>
+<INPUT type=submit value="Stop" onClick='document.vlc.stop();'>
+<INPUT type=submit value=" << " onClick='document.vlc.playSlower();'>
+<INPUT type=submit value=" >> " onClick='document.vlc.playFaster();'>
+<INPUT type=submit value="Mute" onClick='document.vlc.toggleMute();'>
+<INPUT type=submit value="Show" onClick='document.vlc.Visible = true;'>
+<INPUT type=submit value="Hide" onClick='document.vlc.Visible = false;'>
+<INPUT type=submit value="Version" onClick='alert(document.vlc.VersionInfo);'>
+</TD></TR>
+</TABLE>
+</BODY>
+</HTML>

activex/utils.cpp

+/*****************************************************************************
+ * utils.cpp: ActiveX control for VLC
+ *****************************************************************************
+ * Copyright (C) 2005 VideoLAN
+ *
+ * Authors: Damien Fouilleul <Damien.Fouilleul@laposte.net>
+ *
+ * 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
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ *****************************************************************************/
+
+#include "utils.h"
+
+/*
+** conversion facilities
+*/
+
+using namespace std;
+
+char *CStrFromBSTR(int codePage, BSTR bstr)
+{
+    UINT len = SysStringLen(bstr);
+    if( len > 0 )
+    {
+        size_t mblen = WideCharToMultiByte(codePage,
+                0, bstr, len, NULL, 0, NULL, NULL);
+        if( mblen > 0 )
+        {
+            char *buffer = (char *)malloc(mblen+1);
+            ZeroMemory(buffer, mblen+1);
+            if( WideCharToMultiByte(CP_ACP, 0, bstr, len, buffer, mblen, NULL, NULL) )
+                return buffer;
+        }
+    }
+    return NULL;
+};
+
+BSTR BSTRFromCStr(int codePage, const char *s)
+{
+    int wideLen = MultiByteToWideChar(codePage, 0, s, -1, NULL, 0);
+    if( wideLen )
+    {
+        WCHAR* wideStr = (WCHAR*)malloc(wideLen*sizeof(WCHAR));
+        if( NULL != wideStr )
+        {
+            BSTR bstr;
+
+            ZeroMemory(wideStr, wideLen*sizeof(WCHAR));
+            MultiByteToWideChar(codePage, 0, s, -1, wideStr, wideLen);
+            bstr = SysAllocString(wideStr);
+            free(wideStr);
+
+            return bstr;
+        }
+    }
+    return NULL;
+};
+
+/*
+**  properties
+*/
+
+HRESULT GetObjectProperty(LPUNKNOWN object, DISPID dispID, VARIANT& v)
+{
+    IDispatch *pDisp;
+    HRESULT hr = object->QueryInterface(IID_IDispatch, (LPVOID *)&pDisp);
+    if( SUCCEEDED(hr) )
+    {
+        DISPPARAMS dispparamsNoArgs = {NULL, NULL, 0, 0};
+        VARIANT vres;
+        hr = pDisp->Invoke(dispID, IID_NULL, LOCALE_USER_DEFAULT,
+                DISPATCH_PROPERTYGET, &dispparamsNoArgs, &vres, NULL, NULL);
+        if( SUCCEEDED(hr) )
+        {
+            if( V_VT(&v) != V_VT(&vres) )
+            {
+                hr = VariantChangeType(&v, &vres, 0, V_VT(&v));
+                VariantClear(&vres);
+            }
+            else
+            {
+                v = vres;
+            }
+        }
+        pDisp->Release();
+    }
+    return hr;
+};
+
+

activex/utils.h

+/*****************************************************************************
+ * utils.h: ActiveX control for VLC
+ *****************************************************************************
+ * Copyright (C) 2005 VideoLAN
+ *
+ * Authors: Damien Fouilleul <Damien.Fouilleul@laposte.net>
+ *
+ * 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
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ *****************************************************************************/
+
+#ifndef __UTILS_H__
+#define __UTILS_H__
+
+#include <ole2.h>
+
+#include <vector>
+
+// utilities
+extern char *CStrFromBSTR(int codePage, BSTR bstr);
+extern BSTR BSTRFromCStr(int codePage, const char *s);
+
+// properties
+extern HRESULT GetObjectProperty(LPUNKNOWN object, DISPID dispID, VARIANT& v);
+
+// enumeration
+template<class T> class VLCEnum : IUnknown
+{
+
+public:
+
+    VLCEnum(REFIID riid, std::vector<T> &);
+    VLCEnum(const VLCEnum<T> &);
+    virtual ~VLCEnum() {};
+
+    VLCEnum<T>& operator=(const VLCEnum<T> &t);
+
+    // IUnknown methods
+    STDMETHODIMP QueryInterface(REFIID riid, void **);
+    STDMETHODIMP_(ULONG) AddRef(void);
+    STDMETHODIMP_(ULONG) Release(void);
+
+    // IEnumXXXX methods
+    STDMETHODIMP Next(ULONG, T *, ULONG *);
+    STDMETHODIMP Skip(ULONG);
+    STDMETHODIMP Reset(void);
+    // cloning is implemented by subclasses and must use copy constructor
+    //STDMETHODIMP Clone(VLCEnum<T> **);
+    // cloning is implemented by subclasses and must use copy constructor
+
+    typedef void (*retainer)(T);
+
+    void setRetainOperation(retainer retain) { _retain = retain; };
+
+private:
+
+    LONG                                _refcount;
+    std::vector<T>                      _v;
+    typename std::vector<T>::iterator   _i;
+    REFIID                              _riid;
+    retainer                            _retain;
+};
+
+template<class T>
+VLCEnum<T>::VLCEnum(REFIID riid, std::vector<T> &v) :
+    _refcount(1),
+    _v(v),
+    _riid(riid),
+    _retain(NULL)
+{
+    _i= v.begin();
+};
+
+template<class T>
+VLCEnum<T>::VLCEnum(const VLCEnum<T> &e) :
+    _refcount(1),
+    _v(e._v),
+    _riid(e._riid)
+{
+};
+
+template<class T>
+VLCEnum<T>& VLCEnum<T>::operator=(const VLCEnum<T> &e)
+{
+    this->_refcount = 1;
+    this->_riid = e._riid;
+    this->_v    = e._v;
+    this->_i    = e._i;
+};
+
+template<class T>
+STDMETHODIMP VLCEnum<T>::QueryInterface(REFIID riid, void **ppv)
+{
+    if( NULL == ppv ) return E_POINTER;
+    if( (IID_IUnknown == riid) 
+     && ( _riid == riid) ) {
+        AddRef();
+        *ppv = reinterpret_cast<LPVOID>(this);
+        return NOERROR;
+    }
+    return E_NOINTERFACE;
+};
+
+template<class T>
+STDMETHODIMP_(ULONG) VLCEnum<T>::AddRef(void)
+{
+    return InterlockedIncrement(&_refcount);
+};
+
+template<class T>
+STDMETHODIMP_(ULONG) VLCEnum<T>::Release(void)
+{
+    ULONG refcount = InterlockedDecrement(&_refcount);
+    if( 0 == refcount )
+    {
+        delete this;
+        return 0;
+    }
+    return refcount;
+};
+
+template<class T>
+STDMETHODIMP VLCEnum<T>::Next(ULONG celt, T *rgelt, ULONG *pceltFetched)
+{
+    if( NULL == rgelt )
+        return E_POINTER;
+
+    if( (celt > 1) && (NULL == pceltFetched) )
+        return E_INVALIDARG;
+
+    ULONG c = 0;
+    typename std::vector<T>::iterator end = _v.end();
+
+    while( (c < celt) && (_i != end) )
+    {
+        rgelt[c] = *_i;
+        if( NULL != _retain ) _retain(rgelt[c]);
+        ++_i;
+        ++c;
+    }
+
+    if( NULL != pceltFetched )
+        *pceltFetched = c;
+
+    return (c == celt) ? S_OK : S_FALSE;
+};
+
+template<class T>
+STDMETHODIMP VLCEnum<T>::Skip(ULONG celt)
+{
+    ULONG c = 0;
+    typename std::vector<T>::iterator end = _v.end();
+
+    while( (c < celt) && (_i != end) )
+    {
+        ++_i;
+        ++c;
+    }
+    return (c == celt) ? S_OK : S_FALSE;
+};
+
+template<class T>
+STDMETHODIMP VLCEnum<T>::Reset(void)
+{
+    _i= _v.begin();
+    return S_OK;
+};
+
+#endif
+