diff --git a/Makefile.am b/Makefile.am index c9e0e0b102009e40bc428729ca20c3255e376b1c..ab37f2b4f7e2baf702dc989fe44419e3070e729e 100644 --- a/Makefile.am +++ b/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 = \ diff --git a/activex/Makefile.am b/activex/Makefile.am new file mode 100644 index 0000000000000000000000000000000000000000..2798c6547f06de7a124ca6a14e640bac68f3197d --- /dev/null +++ b/activex/Makefile.am @@ -0,0 +1,117 @@ +############################################################################### +# 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: + diff --git a/activex/README.TXT b/activex/README.TXT new file mode 100644 index 0000000000000000000000000000000000000000..40bd005e0eb0a322591812959d546b47e4119cfe --- /dev/null +++ b/activex/README.TXT @@ -0,0 +1,45 @@ +== 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 diff --git a/activex/axvlc.def b/activex/axvlc.def new file mode 100644 index 0000000000000000000000000000000000000000..431a9a1dac648fe8cf0712fab21811eecac58f3b --- /dev/null +++ b/activex/axvlc.def @@ -0,0 +1,8 @@ +LIBRARY AXVLC.DLL +EXPORTS + CLSID_VLCPlugin data + DllMain DllMain@12 + DllCanUnloadNow DllCanUnloadNow@0 + DllGetClassObject DllGetClassObject@12 + DllRegisterServer DllRegisterServer@0 + DllUnregisterServer DllUnregisterServer@0 diff --git a/activex/axvlc.idl b/activex/axvlc.idl new file mode 100644 index 0000000000000000000000000000000000000000..727d7af02f6464c3c8ee6705cd7bb2825a1ff97e --- /dev/null +++ b/activex/axvlc.idl @@ -0,0 +1,145 @@ +/***************************************************************************** + * axvlc.idl: ActiveX control for VLC + ***************************************************************************** + * Copyright (C) 2005 VideoLAN + * + * Authors: Damien Fouilleul + * + * 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; + }; +}; diff --git a/activex/axvlc.reg b/activex/axvlc.reg new file mode 100644 index 0000000000000000000000000000000000000000..5f9ba9768e40c699e73f6e98c8e16e6f8f98d35b --- /dev/null +++ b/activex/axvlc.reg @@ -0,0 +1,62 @@ +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" diff --git a/activex/axvlc.tlb b/activex/axvlc.tlb new file mode 100755 index 0000000000000000000000000000000000000000..3868b784e2541a97715fad6464d17e517488d9bb Binary files /dev/null and b/activex/axvlc.tlb differ diff --git a/activex/axvlc_idl.c b/activex/axvlc_idl.c new file mode 100644 index 0000000000000000000000000000000000000000..1d96f931a662fccb4a2d242f8f4217086871916b --- /dev/null +++ b/activex/axvlc_idl.c @@ -0,0 +1,61 @@ +/***************************************************************************** + * axvlc_idl.c: ActiveX control for VLC + ***************************************************************************** + * Copyright (C) 2005 VideoLAN + * + * Authors: Damien Fouilleul + * + * 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 + diff --git a/activex/axvlc_idl.h b/activex/axvlc_idl.h new file mode 100644 index 0000000000000000000000000000000000000000..b201f714474690f2566f615d755d66164a058ba1 --- /dev/null +++ b/activex/axvlc_idl.h @@ -0,0 +1,917 @@ +/***************************************************************************** + * axvlc_idl.h: ActiveX control for VLC + ***************************************************************************** + * Copyright (C) 2005 VideoLAN + * + * Authors: Damien Fouilleul + * + * 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. + *****************************************************************************/ + +/* verify that the version is high enough to compile this file*/ +#ifndef __REQUIRED_RPCNDR_H_VERSION__ +#define __REQUIRED_RPCNDR_H_VERSION__ 440 +#endif + +#include "rpc.h" +#include "rpcndr.h" + +#ifndef __axvlc_idl_h__ +#define __axvlc_idl_h__ + +#ifdef __cplusplus +extern "C"{ +#endif + +/* Forward Declarations */ + +#ifndef __IVLCControl_FWD_DEFINED__ +#define __IVLCControl_FWD_DEFINED__ +typedef interface IVLCControl IVLCControl; +#endif /* __IVLCControl_FWD_DEFINED__ */ + + +#ifndef __DVLCEvents_FWD_DEFINED__ +#define __DVLCEvents_FWD_DEFINED__ +typedef interface DVLCEvents DVLCEvents; +#endif /* __DVLCEvents_FWD_DEFINED__ */ + + +#ifndef __VLCPlugin_FWD_DEFINED__ +#define __VLCPlugin_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class VLCPlugin VLCPlugin; +#else +typedef struct VLCPlugin VLCPlugin; +#endif /* __cplusplus */ + +#endif /* __VLCPlugin_FWD_DEFINED__ */ + + +void __RPC_FAR * __RPC_USER MIDL_user_allocate(size_t); +void __RPC_USER MIDL_user_free( void __RPC_FAR * ); + + +#ifndef __AXVLC_LIBRARY_DEFINED__ +#define __AXVLC_LIBRARY_DEFINED__ + +/* library AXVLC */ +/* [helpstring][version][uuid] */ + + + + +enum VLCPlaylistMode + { VLCPlayListInsert = 1, + VLCPlayListReplace = 2, + VLCPlayListAppend = 4, + VLCPlayListGo = 8, + VLCPlayListCheckInsert = 16 + }; +#define VLCPlayListEnd ( -666 ) + + +EXTERN_C const IID LIBID_AXVLC; + +#ifndef __IVLCControl_INTERFACE_DEFINED__ +#define __IVLCControl_INTERFACE_DEFINED__ + +/* interface IVLCControl */ +/* [object][oleautomation][hidden][dual][helpstring][uuid] */ + + +EXTERN_C const IID IID_IVLCControl; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("C2FA41D0-B113-476e-AC8C-9BD14999C1C1") + IVLCControl : public IDispatch + { + public: + virtual /* [helpstring][propget][defaultbind][bindable][id] */ HRESULT STDMETHODCALLTYPE get_Value( + /* [retval][out] */ VARIANT __RPC_FAR *pvarValue) = 0; + + virtual /* [helpstring][propput][defaultbind][bindable][id] */ HRESULT STDMETHODCALLTYPE put_Value( + /* [in] */ VARIANT pvarValue) = 0; + + virtual /* [helpstring][bindable][propget] */ HRESULT STDMETHODCALLTYPE get_Visible( + /* [retval][out] */ VARIANT_BOOL __RPC_FAR *visible) = 0; + + virtual /* [helpstring][bindable][propput] */ HRESULT STDMETHODCALLTYPE put_Visible( + /* [in] */ VARIANT_BOOL visible) = 0; + + virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE play( void) = 0; + + virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE pause( void) = 0; + + virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE stop( void) = 0; + + virtual /* [helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Playing( + /* [retval][out] */ VARIANT_BOOL __RPC_FAR *isPlaying) = 0; + + virtual /* [helpstring][propput] */ HRESULT STDMETHODCALLTYPE put_Playing( + /* [in] */ VARIANT_BOOL isPlaying) = 0; + + virtual /* [helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Position( + /* [retval][out] */ float __RPC_FAR *position) = 0; + + virtual /* [helpstring][propput] */ HRESULT STDMETHODCALLTYPE put_Position( + /* [in] */ float position) = 0; + + virtual /* [helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Time( + /* [retval][out] */ int __RPC_FAR *seconds) = 0; + + virtual /* [helpstring][propput] */ HRESULT STDMETHODCALLTYPE put_Time( + /* [in] */ int seconds) = 0; + + virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE shuttle( + /* [in] */ int seconds) = 0; + + virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE fullscreen( void) = 0; + + virtual /* [helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Length( + /* [retval][out] */ int __RPC_FAR *seconds) = 0; + + virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE playFaster( void) = 0; + + virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE playSlower( void) = 0; + + virtual /* [helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Volume( + /* [retval][out] */ int __RPC_FAR *volume) = 0; + + virtual /* [helpstring][propput] */ HRESULT STDMETHODCALLTYPE put_Volume( + /* [in] */ int volume) = 0; + + virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE toggleMute( void) = 0; + + virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE addTarget( + /* [in] */ BSTR uri, + /* [in] */ VARIANT options, + /* [in] */ enum VLCPlaylistMode mode, + /* [in] */ int position) = 0; + + virtual /* [helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_PlaylistIndex( + /* [retval][out] */ int __RPC_FAR *index) = 0; + + virtual /* [helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_PlaylistCount( + /* [retval][out] */ int __RPC_FAR *index) = 0; + + virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE playlistNext( void) = 0; + + virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE playlistPrev( void) = 0; + + virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE playlistClear( void) = 0; + + virtual /* [helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_VersionInfo( + /* [retval][out] */ BSTR __RPC_FAR *version) = 0; + + }; + +#else /* C style interface */ + + typedef struct IVLCControlVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE __RPC_FAR *QueryInterface )( + IVLCControl __RPC_FAR * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void __RPC_FAR *__RPC_FAR *ppvObject); + + ULONG ( STDMETHODCALLTYPE __RPC_FAR *AddRef )( + IVLCControl __RPC_FAR * This); + + ULONG ( STDMETHODCALLTYPE __RPC_FAR *Release )( + IVLCControl __RPC_FAR * This); + + HRESULT ( STDMETHODCALLTYPE __RPC_FAR *GetTypeInfoCount )( + IVLCControl __RPC_FAR * This, + /* [out] */ UINT __RPC_FAR *pctinfo); + + HRESULT ( STDMETHODCALLTYPE __RPC_FAR *GetTypeInfo )( + IVLCControl __RPC_FAR * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo __RPC_FAR *__RPC_FAR *ppTInfo); + + HRESULT ( STDMETHODCALLTYPE __RPC_FAR *GetIDsOfNames )( + IVLCControl __RPC_FAR * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR __RPC_FAR *rgszNames, + /* [in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID __RPC_FAR *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE __RPC_FAR *Invoke )( + IVLCControl __RPC_FAR * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS __RPC_FAR *pDispParams, + /* [out] */ VARIANT __RPC_FAR *pVarResult, + /* [out] */ EXCEPINFO __RPC_FAR *pExcepInfo, + /* [out] */ UINT __RPC_FAR *puArgErr); + + /* [helpstring][propget][defaultbind][bindable][id] */ HRESULT ( STDMETHODCALLTYPE __RPC_FAR *get_Value )( + IVLCControl __RPC_FAR * This, + /* [retval][out] */ VARIANT __RPC_FAR *pvarValue); + + /* [helpstring][propput][defaultbind][bindable][id] */ HRESULT ( STDMETHODCALLTYPE __RPC_FAR *put_Value )( + IVLCControl __RPC_FAR * This, + /* [in] */ VARIANT pvarValue); + + /* [helpstring][bindable][propget] */ HRESULT ( STDMETHODCALLTYPE __RPC_FAR *get_Visible )( + IVLCControl __RPC_FAR * This, + /* [retval][out] */ VARIANT_BOOL __RPC_FAR *visible); + + /* [helpstring][bindable][propput] */ HRESULT ( STDMETHODCALLTYPE __RPC_FAR *put_Visible )( + IVLCControl __RPC_FAR * This, + /* [in] */ VARIANT_BOOL visible); + + /* [helpstring] */ HRESULT ( STDMETHODCALLTYPE __RPC_FAR *play )( + IVLCControl __RPC_FAR * This); + + /* [helpstring] */ HRESULT ( STDMETHODCALLTYPE __RPC_FAR *pause )( + IVLCControl __RPC_FAR * This); + + /* [helpstring] */ HRESULT ( STDMETHODCALLTYPE __RPC_FAR *stop )( + IVLCControl __RPC_FAR * This); + + /* [helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE __RPC_FAR *get_Playing )( + IVLCControl __RPC_FAR * This, + /* [retval][out] */ VARIANT_BOOL __RPC_FAR *isPlaying); + + /* [helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE __RPC_FAR *put_Playing )( + IVLCControl __RPC_FAR * This, + /* [in] */ VARIANT_BOOL isPlaying); + + /* [helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE __RPC_FAR *get_Position )( + IVLCControl __RPC_FAR * This, + /* [retval][out] */ float __RPC_FAR *position); + + /* [helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE __RPC_FAR *put_Position )( + IVLCControl __RPC_FAR * This, + /* [in] */ float position); + + /* [helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE __RPC_FAR *get_Time )( + IVLCControl __RPC_FAR * This, + /* [retval][out] */ int __RPC_FAR *seconds); + + /* [helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE __RPC_FAR *put_Time )( + IVLCControl __RPC_FAR * This, + /* [in] */ int seconds); + + /* [helpstring] */ HRESULT ( STDMETHODCALLTYPE __RPC_FAR *shuttle )( + IVLCControl __RPC_FAR * This, + /* [in] */ int seconds); + + /* [helpstring] */ HRESULT ( STDMETHODCALLTYPE __RPC_FAR *fullscreen )( + IVLCControl __RPC_FAR * This); + + /* [helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE __RPC_FAR *get_Length )( + IVLCControl __RPC_FAR * This, + /* [retval][out] */ int __RPC_FAR *seconds); + + /* [helpstring] */ HRESULT ( STDMETHODCALLTYPE __RPC_FAR *playFaster )( + IVLCControl __RPC_FAR * This); + + /* [helpstring] */ HRESULT ( STDMETHODCALLTYPE __RPC_FAR *playSlower )( + IVLCControl __RPC_FAR * This); + + /* [helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE __RPC_FAR *get_Volume )( + IVLCControl __RPC_FAR * This, + /* [retval][out] */ int __RPC_FAR *volume); + + /* [helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE __RPC_FAR *put_Volume )( + IVLCControl __RPC_FAR * This, + /* [in] */ int volume); + + /* [helpstring] */ HRESULT ( STDMETHODCALLTYPE __RPC_FAR *toggleMute )( + IVLCControl __RPC_FAR * This); + + /* [helpstring] */ HRESULT ( STDMETHODCALLTYPE __RPC_FAR *addTarget )( + IVLCControl __RPC_FAR * This, + /* [in] */ BSTR uri, + /* [in] */ VARIANT options, + /* [in] */ enum VLCPlaylistMode mode, + /* [in] */ int position); + + /* [helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE __RPC_FAR *get_PlaylistIndex )( + IVLCControl __RPC_FAR * This, + /* [retval][out] */ int __RPC_FAR *index); + + /* [helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE __RPC_FAR *get_PlaylistCount )( + IVLCControl __RPC_FAR * This, + /* [retval][out] */ int __RPC_FAR *index); + + /* [helpstring] */ HRESULT ( STDMETHODCALLTYPE __RPC_FAR *playlistNext )( + IVLCControl __RPC_FAR * This); + + /* [helpstring] */ HRESULT ( STDMETHODCALLTYPE __RPC_FAR *playlistPrev )( + IVLCControl __RPC_FAR * This); + + /* [helpstring] */ HRESULT ( STDMETHODCALLTYPE __RPC_FAR *playlistClear )( + IVLCControl __RPC_FAR * This); + + /* [helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE __RPC_FAR *get_VersionInfo )( + IVLCControl __RPC_FAR * This, + /* [retval][out] */ BSTR __RPC_FAR *version); + + END_INTERFACE + } IVLCControlVtbl; + + interface IVLCControl + { + CONST_VTBL struct IVLCControlVtbl __RPC_FAR *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IVLCControl_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define IVLCControl_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define IVLCControl_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define IVLCControl_GetTypeInfoCount(This,pctinfo) \ + (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) + +#define IVLCControl_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) + +#define IVLCControl_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) + +#define IVLCControl_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) + + +#define IVLCControl_get_Value(This,pvarValue) \ + (This)->lpVtbl -> get_Value(This,pvarValue) + +#define IVLCControl_put_Value(This,pvarValue) \ + (This)->lpVtbl -> put_Value(This,pvarValue) + +#define IVLCControl_get_Visible(This,visible) \ + (This)->lpVtbl -> get_Visible(This,visible) + +#define IVLCControl_put_Visible(This,visible) \ + (This)->lpVtbl -> put_Visible(This,visible) + +#define IVLCControl_play(This) \ + (This)->lpVtbl -> play(This) + +#define IVLCControl_pause(This) \ + (This)->lpVtbl -> pause(This) + +#define IVLCControl_stop(This) \ + (This)->lpVtbl -> stop(This) + +#define IVLCControl_get_Playing(This,isPlaying) \ + (This)->lpVtbl -> get_Playing(This,isPlaying) + +#define IVLCControl_put_Playing(This,isPlaying) \ + (This)->lpVtbl -> put_Playing(This,isPlaying) + +#define IVLCControl_get_Position(This,position) \ + (This)->lpVtbl -> get_Position(This,position) + +#define IVLCControl_put_Position(This,position) \ + (This)->lpVtbl -> put_Position(This,position) + +#define IVLCControl_get_Time(This,seconds) \ + (This)->lpVtbl -> get_Time(This,seconds) + +#define IVLCControl_put_Time(This,seconds) \ + (This)->lpVtbl -> put_Time(This,seconds) + +#define IVLCControl_shuttle(This,seconds) \ + (This)->lpVtbl -> shuttle(This,seconds) + +#define IVLCControl_fullscreen(This) \ + (This)->lpVtbl -> fullscreen(This) + +#define IVLCControl_get_Length(This,seconds) \ + (This)->lpVtbl -> get_Length(This,seconds) + +#define IVLCControl_playFaster(This) \ + (This)->lpVtbl -> playFaster(This) + +#define IVLCControl_playSlower(This) \ + (This)->lpVtbl -> playSlower(This) + +#define IVLCControl_get_Volume(This,volume) \ + (This)->lpVtbl -> get_Volume(This,volume) + +#define IVLCControl_put_Volume(This,volume) \ + (This)->lpVtbl -> put_Volume(This,volume) + +#define IVLCControl_toggleMute(This) \ + (This)->lpVtbl -> toggleMute(This) + +#define IVLCControl_addTarget(This,uri,options,mode,position) \ + (This)->lpVtbl -> addTarget(This,uri,options,mode,position) + +#define IVLCControl_get_PlaylistIndex(This,index) \ + (This)->lpVtbl -> get_PlaylistIndex(This,index) + +#define IVLCControl_get_PlaylistCount(This,index) \ + (This)->lpVtbl -> get_PlaylistCount(This,index) + +#define IVLCControl_playlistNext(This) \ + (This)->lpVtbl -> playlistNext(This) + +#define IVLCControl_playlistPrev(This) \ + (This)->lpVtbl -> playlistPrev(This) + +#define IVLCControl_playlistClear(This) \ + (This)->lpVtbl -> playlistClear(This) + +#define IVLCControl_get_VersionInfo(This,version) \ + (This)->lpVtbl -> get_VersionInfo(This,version) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [helpstring][propget][defaultbind][bindable][id] */ HRESULT STDMETHODCALLTYPE IVLCControl_get_Value_Proxy( + IVLCControl __RPC_FAR * This, + /* [retval][out] */ VARIANT __RPC_FAR *pvarValue); + + +void __RPC_STUB IVLCControl_get_Value_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [helpstring][propput][defaultbind][bindable][id] */ HRESULT STDMETHODCALLTYPE IVLCControl_put_Value_Proxy( + IVLCControl __RPC_FAR * This, + /* [in] */ VARIANT pvarValue); + + +void __RPC_STUB IVLCControl_put_Value_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [helpstring][bindable][propget] */ HRESULT STDMETHODCALLTYPE IVLCControl_get_Visible_Proxy( + IVLCControl __RPC_FAR * This, + /* [retval][out] */ VARIANT_BOOL __RPC_FAR *visible); + + +void __RPC_STUB IVLCControl_get_Visible_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [helpstring][bindable][propput] */ HRESULT STDMETHODCALLTYPE IVLCControl_put_Visible_Proxy( + IVLCControl __RPC_FAR * This, + /* [in] */ VARIANT_BOOL visible); + + +void __RPC_STUB IVLCControl_put_Visible_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [helpstring] */ HRESULT STDMETHODCALLTYPE IVLCControl_play_Proxy( + IVLCControl __RPC_FAR * This); + + +void __RPC_STUB IVLCControl_play_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [helpstring] */ HRESULT STDMETHODCALLTYPE IVLCControl_pause_Proxy( + IVLCControl __RPC_FAR * This); + + +void __RPC_STUB IVLCControl_pause_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [helpstring] */ HRESULT STDMETHODCALLTYPE IVLCControl_stop_Proxy( + IVLCControl __RPC_FAR * This); + + +void __RPC_STUB IVLCControl_stop_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [helpstring][propget] */ HRESULT STDMETHODCALLTYPE IVLCControl_get_Playing_Proxy( + IVLCControl __RPC_FAR * This, + /* [retval][out] */ VARIANT_BOOL __RPC_FAR *isPlaying); + + +void __RPC_STUB IVLCControl_get_Playing_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [helpstring][propput] */ HRESULT STDMETHODCALLTYPE IVLCControl_put_Playing_Proxy( + IVLCControl __RPC_FAR * This, + /* [in] */ VARIANT_BOOL isPlaying); + + +void __RPC_STUB IVLCControl_put_Playing_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [helpstring][propget] */ HRESULT STDMETHODCALLTYPE IVLCControl_get_Position_Proxy( + IVLCControl __RPC_FAR * This, + /* [retval][out] */ float __RPC_FAR *position); + + +void __RPC_STUB IVLCControl_get_Position_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [helpstring][propput] */ HRESULT STDMETHODCALLTYPE IVLCControl_put_Position_Proxy( + IVLCControl __RPC_FAR * This, + /* [in] */ float position); + + +void __RPC_STUB IVLCControl_put_Position_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [helpstring][propget] */ HRESULT STDMETHODCALLTYPE IVLCControl_get_Time_Proxy( + IVLCControl __RPC_FAR * This, + /* [retval][out] */ int __RPC_FAR *seconds); + + +void __RPC_STUB IVLCControl_get_Time_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [helpstring][propput] */ HRESULT STDMETHODCALLTYPE IVLCControl_put_Time_Proxy( + IVLCControl __RPC_FAR * This, + /* [in] */ int seconds); + + +void __RPC_STUB IVLCControl_put_Time_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [helpstring] */ HRESULT STDMETHODCALLTYPE IVLCControl_shuttle_Proxy( + IVLCControl __RPC_FAR * This, + /* [in] */ int seconds); + + +void __RPC_STUB IVLCControl_shuttle_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [helpstring] */ HRESULT STDMETHODCALLTYPE IVLCControl_fullscreen_Proxy( + IVLCControl __RPC_FAR * This); + + +void __RPC_STUB IVLCControl_fullscreen_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [helpstring][propget] */ HRESULT STDMETHODCALLTYPE IVLCControl_get_Length_Proxy( + IVLCControl __RPC_FAR * This, + /* [retval][out] */ int __RPC_FAR *seconds); + + +void __RPC_STUB IVLCControl_get_Length_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [helpstring] */ HRESULT STDMETHODCALLTYPE IVLCControl_playFaster_Proxy( + IVLCControl __RPC_FAR * This); + + +void __RPC_STUB IVLCControl_playFaster_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [helpstring] */ HRESULT STDMETHODCALLTYPE IVLCControl_playSlower_Proxy( + IVLCControl __RPC_FAR * This); + + +void __RPC_STUB IVLCControl_playSlower_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [helpstring][propget] */ HRESULT STDMETHODCALLTYPE IVLCControl_get_Volume_Proxy( + IVLCControl __RPC_FAR * This, + /* [retval][out] */ int __RPC_FAR *volume); + + +void __RPC_STUB IVLCControl_get_Volume_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [helpstring][propput] */ HRESULT STDMETHODCALLTYPE IVLCControl_put_Volume_Proxy( + IVLCControl __RPC_FAR * This, + /* [in] */ int volume); + + +void __RPC_STUB IVLCControl_put_Volume_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [helpstring] */ HRESULT STDMETHODCALLTYPE IVLCControl_toggleMute_Proxy( + IVLCControl __RPC_FAR * This); + + +void __RPC_STUB IVLCControl_toggleMute_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [helpstring] */ HRESULT STDMETHODCALLTYPE IVLCControl_addTarget_Proxy( + IVLCControl __RPC_FAR * This, + /* [in] */ BSTR uri, + /* [in] */ VARIANT options, + /* [in] */ enum VLCPlaylistMode mode, + /* [in] */ int position); + + +void __RPC_STUB IVLCControl_addTarget_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [helpstring][propget] */ HRESULT STDMETHODCALLTYPE IVLCControl_get_PlaylistIndex_Proxy( + IVLCControl __RPC_FAR * This, + /* [retval][out] */ int __RPC_FAR *index); + + +void __RPC_STUB IVLCControl_get_PlaylistIndex_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [helpstring][propget] */ HRESULT STDMETHODCALLTYPE IVLCControl_get_PlaylistCount_Proxy( + IVLCControl __RPC_FAR * This, + /* [retval][out] */ int __RPC_FAR *index); + + +void __RPC_STUB IVLCControl_get_PlaylistCount_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [helpstring] */ HRESULT STDMETHODCALLTYPE IVLCControl_playlistNext_Proxy( + IVLCControl __RPC_FAR * This); + + +void __RPC_STUB IVLCControl_playlistNext_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [helpstring] */ HRESULT STDMETHODCALLTYPE IVLCControl_playlistPrev_Proxy( + IVLCControl __RPC_FAR * This); + + +void __RPC_STUB IVLCControl_playlistPrev_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [helpstring] */ HRESULT STDMETHODCALLTYPE IVLCControl_playlistClear_Proxy( + IVLCControl __RPC_FAR * This); + + +void __RPC_STUB IVLCControl_playlistClear_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [helpstring][propget] */ HRESULT STDMETHODCALLTYPE IVLCControl_get_VersionInfo_Proxy( + IVLCControl __RPC_FAR * This, + /* [retval][out] */ BSTR __RPC_FAR *version); + + +void __RPC_STUB IVLCControl_get_VersionInfo_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __IVLCControl_INTERFACE_DEFINED__ */ + + +#ifndef __DVLCEvents_DISPINTERFACE_DEFINED__ +#define __DVLCEvents_DISPINTERFACE_DEFINED__ + +/* dispinterface DVLCEvents */ +/* [hidden][helpstring][uuid] */ + + +EXTERN_C const IID DIID_DVLCEvents; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("DF48072F-5EF8-434e-9B40-E2F3AE759B5F") + DVLCEvents : public IDispatch + { + }; + +#else /* C style interface */ + + typedef struct DVLCEventsVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE __RPC_FAR *QueryInterface )( + DVLCEvents __RPC_FAR * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void __RPC_FAR *__RPC_FAR *ppvObject); + + ULONG ( STDMETHODCALLTYPE __RPC_FAR *AddRef )( + DVLCEvents __RPC_FAR * This); + + ULONG ( STDMETHODCALLTYPE __RPC_FAR *Release )( + DVLCEvents __RPC_FAR * This); + + HRESULT ( STDMETHODCALLTYPE __RPC_FAR *GetTypeInfoCount )( + DVLCEvents __RPC_FAR * This, + /* [out] */ UINT __RPC_FAR *pctinfo); + + HRESULT ( STDMETHODCALLTYPE __RPC_FAR *GetTypeInfo )( + DVLCEvents __RPC_FAR * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo __RPC_FAR *__RPC_FAR *ppTInfo); + + HRESULT ( STDMETHODCALLTYPE __RPC_FAR *GetIDsOfNames )( + DVLCEvents __RPC_FAR * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR __RPC_FAR *rgszNames, + /* [in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID __RPC_FAR *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE __RPC_FAR *Invoke )( + DVLCEvents __RPC_FAR * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS __RPC_FAR *pDispParams, + /* [out] */ VARIANT __RPC_FAR *pVarResult, + /* [out] */ EXCEPINFO __RPC_FAR *pExcepInfo, + /* [out] */ UINT __RPC_FAR *puArgErr); + + END_INTERFACE + } DVLCEventsVtbl; + + interface DVLCEvents + { + CONST_VTBL struct DVLCEventsVtbl __RPC_FAR *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define DVLCEvents_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define DVLCEvents_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define DVLCEvents_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define DVLCEvents_GetTypeInfoCount(This,pctinfo) \ + (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) + +#define DVLCEvents_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) + +#define DVLCEvents_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) + +#define DVLCEvents_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + +#endif /* __DVLCEvents_DISPINTERFACE_DEFINED__ */ + + +EXTERN_C const CLSID CLSID_VLCPlugin; + +#ifdef __cplusplus + +class DECLSPEC_UUID("E23FE9C6-778E-49D4-B537-38FCDE4887D8") +VLCPlugin; +#endif +#endif /* __AXVLC_LIBRARY_DEFINED__ */ + +/* Additional Prototypes for ALL interfaces */ + +/* end of Additional Prototypes */ + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/activex/axvlc_rc.rc b/activex/axvlc_rc.rc new file mode 100644 index 0000000000000000000000000000000000000000..11627515f8f8a5641ba943eeebc413c7e89f8683 --- /dev/null +++ b/activex/axvlc_rc.rc @@ -0,0 +1,36 @@ +#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" + diff --git a/activex/connectioncontainer.cpp b/activex/connectioncontainer.cpp new file mode 100644 index 0000000000000000000000000000000000000000..9908f944bf73f5dc29afe487cf5e09fb121609b9 --- /dev/null +++ b/activex/connectioncontainer.cpp @@ -0,0 +1,293 @@ +/***************************************************************************** + * connectioncontainer.cpp: ActiveX control for VLC + ***************************************************************************** + * Copyright (C) 2005 VideoLAN + * + * Authors: Damien Fouilleul + * + * 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 &v) : + e(VLCEnum(IID_IEnumConnections, v)) + { e.setRetainOperation((VLCEnum::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(new VLCEnumConnections(*this)); + return (NULL != *ppenum) ? S_OK : E_OUTOFMEMORY; + }; + +private: + + static void retain(CONNECTDATA cd) + { + cd.pUnk->AddRef(); + }; + + VLCEnum 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(new VLCEnumConnections(_connections)); + + return (NULL != *ppEnum ) ? S_OK : E_OUTOFMEMORY; +}; + +void VLCConnectionPoint::fireEvent(DISPID dispId, LCID lcid, DISPPARAMS* pDispParams) +{ + vector::iterator end = _connections.end(); + vector::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::iterator end = _connections.end(); + vector::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 &v) : + e(VLCEnum(IID_IEnumConnectionPoints, v)) + { e.setRetainOperation((VLCEnum::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(new VLCEnumConnectionPoints(*this)); + return (NULL != *ppenum) ? S_OK : E_OUTOFMEMORY; + }; + +private: + + static void retain(LPCONNECTIONPOINT cp) + { + cp->AddRef(); + }; + + VLCEnum e; +}; + +//////////////////////////////////////////////////////////////////////////////////////////////// + +VLCConnectionPointContainer::VLCConnectionPointContainer(VLCPlugin *p_instance) : + _p_instance(p_instance) +{ + _p_events = new VLCConnectionPoint(dynamic_cast(this), + _p_instance->getDispEventID()); + + _v_cps.push_back(dynamic_cast(_p_events)); + + _p_props = new VLCConnectionPoint(dynamic_cast(this), + IID_IPropertyNotifySink); + + _v_cps.push_back(dynamic_cast(_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(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(_p_props); + } + else if( _p_instance->getDispEventID() == riid ) + { + _p_events->AddRef(); + *ppCP = dynamic_cast(_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); +}; + diff --git a/activex/connectioncontainer.h b/activex/connectioncontainer.h new file mode 100644 index 0000000000000000000000000000000000000000..e5b6fa8bbbebf70ffde20411083f2697d7c2d3bd --- /dev/null +++ b/activex/connectioncontainer.h @@ -0,0 +1,116 @@ +/***************************************************************************** + * connectioncontainer.h: ActiveX control for VLC + ***************************************************************************** + * Copyright (C) 2005 VideoLAN + * + * Authors: Damien Fouilleul + * + * 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 +#include + +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(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 _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(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 _v_cps; +}; + +#endif + diff --git a/activex/inplace.bmp b/activex/inplace.bmp new file mode 100755 index 0000000000000000000000000000000000000000..1db314fd2777e654275a5c4c17dbad7af6859e87 Binary files /dev/null and b/activex/inplace.bmp differ diff --git a/activex/main.cpp b/activex/main.cpp new file mode 100644 index 0000000000000000000000000000000000000000..954b7611707ef8c2627cb2eab83839c27b27bc9a --- /dev/null +++ b/activex/main.cpp @@ -0,0 +1,147 @@ +/***************************************************************************** + * main.cpp: ActiveX control for VLC + ***************************************************************************** + * Copyright (C) 2005 VideoLAN + * + * Authors: Damien Fouilleul + * + * 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 + +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 + +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 + diff --git a/activex/objectsafety.cpp b/activex/objectsafety.cpp new file mode 100644 index 0000000000000000000000000000000000000000..0cfc678b6645537fcd700c408c772af90cc3412e --- /dev/null +++ b/activex/objectsafety.cpp @@ -0,0 +1,92 @@ +/***************************************************************************** + * objectsafety.cpp: ActiveX control for VLC + ***************************************************************************** + * Copyright (C) 2005 VideoLAN + * + * Authors: Damien Fouilleul + * + * 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; +}; + diff --git a/activex/objectsafety.h b/activex/objectsafety.h new file mode 100644 index 0000000000000000000000000000000000000000..36440507c39504fe08eb1dd0bd51aec2ef38eecb --- /dev/null +++ b/activex/objectsafety.h @@ -0,0 +1,99 @@ +/***************************************************************************** + * objectsafety.h: ActiveX control for VLC + ***************************************************************************** + * Copyright (C) 2005 VideoLAN + * + * Authors: Damien Fouilleul + * + * 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 + +#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(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 diff --git a/activex/olecontrol.cpp b/activex/olecontrol.cpp new file mode 100644 index 0000000000000000000000000000000000000000..7dde4cc74bb8a1e96d1a8223e537c7b720b952f4 --- /dev/null +++ b/activex/olecontrol.cpp @@ -0,0 +1,133 @@ +/***************************************************************************** + * olecontrol.cpp: ActiveX control for VLC + ***************************************************************************** + * Copyright (C) 2005 VideoLAN + * + * Authors: Damien Fouilleul + * + * 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; +}; + diff --git a/activex/olecontrol.h b/activex/olecontrol.h new file mode 100644 index 0000000000000000000000000000000000000000..7173105b1511dd496d1066c3f558d2ced6bc7eda --- /dev/null +++ b/activex/olecontrol.h @@ -0,0 +1,65 @@ +/***************************************************************************** + * olecontrol.h: ActiveX control for VLC + ***************************************************************************** + * Copyright (C) 2005 VideoLAN + * + * Authors: Damien Fouilleul + * + * 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 + +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(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 + diff --git a/activex/oleinplaceactiveobject.cpp b/activex/oleinplaceactiveobject.cpp new file mode 100644 index 0000000000000000000000000000000000000000..4239a4d1f5e587a6ac91b1f6dc3869bfb045f6f9 --- /dev/null +++ b/activex/oleinplaceactiveobject.cpp @@ -0,0 +1,74 @@ +/***************************************************************************** + * oleinplaceactiveobject.cpp: ActiveX control for VLC + ***************************************************************************** + * Copyright (C) 2005 VideoLAN + * + * Authors: Damien Fouilleul + * + * 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; +}; + diff --git a/activex/oleinplaceactiveobject.h b/activex/oleinplaceactiveobject.h new file mode 100644 index 0000000000000000000000000000000000000000..267e9d27e4410811f3f22988bd907ce0d7eddceb --- /dev/null +++ b/activex/oleinplaceactiveobject.h @@ -0,0 +1,71 @@ +/***************************************************************************** + * oleinplaceactiveobject.h: ActiveX control for VLC + ***************************************************************************** + * Copyright (C) 2005 VideoLAN + * + * Authors: Damien Fouilleul + * + * 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(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 + diff --git a/activex/oleinplaceobject.cpp b/activex/oleinplaceobject.cpp new file mode 100644 index 0000000000000000000000000000000000000000..97db7231e8f6b6c12010cbc99b9fcc27548085b0 --- /dev/null +++ b/activex/oleinplaceobject.cpp @@ -0,0 +1,126 @@ +/***************************************************************************** + * oleinplaceobject.cpp: ActiveX control for VLC + ***************************************************************************** + * Copyright (C) 2005 VideoLAN + * + * Authors: Damien Fouilleul + * + * 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 + +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; +}; + diff --git a/activex/oleinplaceobject.h b/activex/oleinplaceobject.h new file mode 100644 index 0000000000000000000000000000000000000000..96a91f81e4cb9eff29ae01eea71262014c1e771c --- /dev/null +++ b/activex/oleinplaceobject.h @@ -0,0 +1,68 @@ +/***************************************************************************** + * oleinplaceobject.h: ActiveX control for VLC + ***************************************************************************** + * Copyright (C) 2005 VideoLAN + * + * Authors: Damien Fouilleul + * + * 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(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 + diff --git a/activex/oleobject.cpp b/activex/oleobject.cpp new file mode 100644 index 0000000000000000000000000000000000000000..6089bbd2d1e0d3d8ebec8498c5cc67af1d3bd804 --- /dev/null +++ b/activex/oleobject.cpp @@ -0,0 +1,331 @@ +/***************************************************************************** + * oleobject.cpp: ActiveX control for VLC + ***************************************************************************** + * Copyright (C) 2005 VideoLAN + * + * Authors: Damien Fouilleul + * + * 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 + +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(&_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; +}; + diff --git a/activex/oleobject.h b/activex/oleobject.h new file mode 100644 index 0000000000000000000000000000000000000000..428e7f1dcea0927e3a33414c39d07007b6323502 --- /dev/null +++ b/activex/oleobject.h @@ -0,0 +1,86 @@ +/***************************************************************************** + * oleobject.h: ActiveX control for VLC + ***************************************************************************** + * Copyright (C) 2005 VideoLAN + * + * Authors: Damien Fouilleul + * + * 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(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 + diff --git a/activex/persistpropbag.cpp b/activex/persistpropbag.cpp new file mode 100644 index 0000000000000000000000000000000000000000..76c59411a9888908653e4595ef274cb105510a47 --- /dev/null +++ b/activex/persistpropbag.cpp @@ -0,0 +1,125 @@ +/***************************************************************************** + * persistpropbag.cpp: ActiveX control for VLC + ***************************************************************************** + * Copyright (C) 2005 VideoLAN + * + * Authors: Damien Fouilleul + * + * 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; +}; + diff --git a/activex/persistpropbag.h b/activex/persistpropbag.h new file mode 100644 index 0000000000000000000000000000000000000000..c042547932f5fce72920d2a00b840c95f100fbc3 --- /dev/null +++ b/activex/persistpropbag.h @@ -0,0 +1,67 @@ +/***************************************************************************** + * persistpropbag.h: ActiveX control for VLC + ***************************************************************************** + * Copyright (C) 2005 VideoLAN + * + * Authors: Damien Fouilleul + * + * 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 + +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(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 + diff --git a/activex/persiststorage.cpp b/activex/persiststorage.cpp new file mode 100644 index 0000000000000000000000000000000000000000..b1bf657725680b5cf7c2b0668b1101689abb7b95 --- /dev/null +++ b/activex/persiststorage.cpp @@ -0,0 +1,79 @@ +/***************************************************************************** + * persiststorage.cpp: ActiveX control for VLC + ***************************************************************************** + * Copyright (C) 2005 VideoLAN + * + * Authors: Damien Fouilleul + * + * 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; +}; + diff --git a/activex/persiststorage.h b/activex/persiststorage.h new file mode 100644 index 0000000000000000000000000000000000000000..c20599a4687fa17af91df04875017d25b7b69666 --- /dev/null +++ b/activex/persiststorage.h @@ -0,0 +1,70 @@ +/***************************************************************************** + * persiststorage.h: ActiveX control for VLC + ***************************************************************************** + * Copyright (C) 2005 VideoLAN + * + * Authors: Damien Fouilleul + * + * 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 + +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(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 + diff --git a/activex/persiststreaminit.cpp b/activex/persiststreaminit.cpp new file mode 100644 index 0000000000000000000000000000000000000000..421036f24c0e5c48bbab543af231893b0096ef23 --- /dev/null +++ b/activex/persiststreaminit.cpp @@ -0,0 +1,70 @@ +/***************************************************************************** + * persiststreaminit.cpp: ActiveX control for VLC + ***************************************************************************** + * Copyright (C) 2005 VideoLAN + * + * Authors: Damien Fouilleul + * + * 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; +}; + diff --git a/activex/persiststreaminit.h b/activex/persiststreaminit.h new file mode 100644 index 0000000000000000000000000000000000000000..bfead1b919707789b66c7cb2043d0d6a0f944c46 --- /dev/null +++ b/activex/persiststreaminit.h @@ -0,0 +1,69 @@ +/***************************************************************************** + * persiststreaminit.h: ActiveX control for VLC + ***************************************************************************** + * Copyright (C) 2005 VideoLAN + * + * Authors: Damien Fouilleul + * + * 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 + +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(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 + diff --git a/activex/plugin.cpp b/activex/plugin.cpp new file mode 100644 index 0000000000000000000000000000000000000000..0b0cef2f743a0ec5f26aa66895daeb55de62ae5c --- /dev/null +++ b/activex/plugin.cpp @@ -0,0 +1,767 @@ +/***************************************************************************** + * plugin.cpp: ActiveX control for VLC + ***************************************************************************** + * Copyright (C) 2005 VideoLAN + * + * Authors: Damien Fouilleul + * + * 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 "olecontrol.h" +#include "oleinplaceobject.h" +#include "oleinplaceactiveobject.h" +#include "persistpropbag.h" +#include "persiststreaminit.h" +#include "persiststorage.h" +#include "provideclassinfo.h" +#include "connectioncontainer.h" +#include "objectsafety.h" +#include "vlccontrol.h" + +#include "utils.h" + +#include +#include + +using namespace std; + +//////////////////////////////////////////////////////////////////////// +//class factory + +// {E23FE9C6-778E-49d4-B537-38FCDE4887D8} +//const GUID CLSID_VLCPlugin = +// { 0xe23fe9c6, 0x778e, 0x49d4, { 0xb5, 0x37, 0x38, 0xfc, 0xde, 0x48, 0x87, 0xd8 } }; + +static LRESULT CALLBACK VLCInPlaceClassWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { + switch( uMsg ) + { + case WM_ERASEBKGND: + return 1L; + + case WM_PAINT: + PAINTSTRUCT ps; + if( GetUpdateRect(hWnd, NULL, FALSE) ) + { + BeginPaint(hWnd, &ps); + EndPaint(hWnd, &ps); + } + return 0L; + + default: + return DefWindowProc(hWnd, uMsg, wParam, lParam); + } +}; + +static LRESULT CALLBACK VLCVideoClassWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { + VLCPlugin *p_instance = reinterpret_cast(GetWindowLongPtr(hWnd, GWLP_USERDATA)); + + switch( uMsg ) + { + case WM_ERASEBKGND: + return 1L; + + case WM_PAINT: + PAINTSTRUCT ps; + RECT pr; + if( GetUpdateRect(hWnd, &pr, FALSE) ) + { + BeginPaint(hWnd, &ps); + p_instance->onPaint(ps, pr); + EndPaint(hWnd, &ps); + } + return 0L; + + default: + return DefWindowProc(hWnd, uMsg, wParam, lParam); + } +}; + +VLCPluginClass::VLCPluginClass(LONG *p_class_ref, HINSTANCE hInstance) : + _p_class_ref(p_class_ref), + _hinstance(hInstance) +{ + WNDCLASS wClass; + + if( ! GetClassInfo(hInstance, getInPlaceWndClassName(), &wClass) ) + { + wClass.style = CS_NOCLOSE|CS_HREDRAW|CS_VREDRAW|CS_DBLCLKS; + wClass.lpfnWndProc = VLCInPlaceClassWndProc; + wClass.cbClsExtra = 0; + wClass.cbWndExtra = 0; + wClass.hInstance = hInstance; + wClass.hIcon = NULL; + wClass.hCursor = LoadCursor(NULL, IDC_ARROW); + wClass.hbrBackground = NULL; + wClass.lpszMenuName = NULL; + wClass.lpszClassName = getInPlaceWndClassName(); + + _inplace_wndclass_atom = RegisterClass(&wClass); + } + else + { + _inplace_wndclass_atom = 0; + } + + if( ! GetClassInfo(hInstance, getVideoWndClassName(), &wClass) ) + { + wClass.style = CS_NOCLOSE|CS_HREDRAW|CS_VREDRAW; + wClass.lpfnWndProc = VLCVideoClassWndProc; + wClass.cbClsExtra = 0; + wClass.cbWndExtra = 0; + wClass.hInstance = hInstance; + wClass.hIcon = NULL; + wClass.hCursor = LoadCursor(NULL, IDC_ARROW); + wClass.hbrBackground = NULL; + wClass.lpszMenuName = NULL; + wClass.lpszClassName = getVideoWndClassName(); + + _video_wndclass_atom = RegisterClass(&wClass); + } + else + { + _video_wndclass_atom = 0; + } + + _inplace_hbitmap = (HBITMAP)LoadImage(getHInstance(), TEXT("INPLACE-PICT"), IMAGE_BITMAP, 0, 0, LR_DEFAULTCOLOR); + + AddRef(); +}; + +VLCPluginClass::~VLCPluginClass() +{ + if( 0 != _inplace_wndclass_atom ) + UnregisterClass(MAKEINTATOM(_inplace_wndclass_atom), _hinstance); + + if( 0 != _video_wndclass_atom ) + UnregisterClass(MAKEINTATOM(_video_wndclass_atom), _hinstance); + + if( NULL != _inplace_hbitmap ) + DeleteObject(_inplace_hbitmap); +}; + +STDMETHODIMP VLCPluginClass::QueryInterface(REFIID riid, void **ppv) +{ + if( NULL == ppv ) + return E_INVALIDARG; + + if( (IID_IUnknown == riid) || (IID_IClassFactory == riid) ) + { + AddRef(); + *ppv = reinterpret_cast(this); + + return NOERROR; + } + + *ppv = NULL; + + return E_NOINTERFACE; +}; + +STDMETHODIMP_(ULONG) VLCPluginClass::AddRef(void) +{ + return InterlockedIncrement(_p_class_ref); +}; + +STDMETHODIMP_(ULONG) VLCPluginClass::Release(void) +{ + ULONG refcount = InterlockedDecrement(_p_class_ref); + if( 0 == refcount ) + { + delete this; + return 0; + } + return refcount; +}; + +STDMETHODIMP VLCPluginClass::CreateInstance(IUnknown *pUnkOuter, REFIID riid, void **ppv) +{ + if( NULL == ppv ) + return E_POINTER; + + *ppv = NULL; + + if( NULL != pUnkOuter ) + return CLASS_E_NOAGGREGATION; + + VLCPlugin *plugin = new VLCPlugin(this); + if( NULL != plugin ) + { + HRESULT hr = plugin->QueryInterface(riid, ppv); + plugin->Release(); + return hr; + } + return E_OUTOFMEMORY; +}; + +STDMETHODIMP VLCPluginClass::LockServer(BOOL fLock) +{ + if( fLock ) + AddRef(); + else + Release(); + + return S_OK; +}; + +//////////////////////////////////////////////////////////////////////// + +VLCPlugin::VLCPlugin(VLCPluginClass *p_class) : + _inplacewnd(NULL), + _p_class(p_class), + _i_ref(1UL), + _codepage(CP_ACP), + _psz_src(NULL), + _b_autostart(TRUE), + _b_loopmode(FALSE), + _b_showdisplay(TRUE), + _b_sendevents(TRUE), + _i_vlc(0) +{ + p_class->AddRef(); + + vlcOleObject = new VLCOleObject(this); + vlcOleControl = new VLCOleControl(this); + vlcOleInPlaceObject = new VLCOleInPlaceObject(this); + vlcOleInPlaceActiveObject = new VLCOleInPlaceActiveObject(this); + vlcPersistStorage = new VLCPersistStorage(this); + vlcPersistStreamInit = new VLCPersistStreamInit(this); + vlcPersistPropertyBag = new VLCPersistPropertyBag(this); + vlcProvideClassInfo = new VLCProvideClassInfo(this); + vlcConnectionPointContainer = new VLCConnectionPointContainer(this); + vlcObjectSafety = new VLCObjectSafety(this); + vlcControl = new VLCControl(this); +}; + +VLCPlugin::~VLCPlugin() +{ + vlcOleInPlaceObject->UIDeactivate(); + vlcOleInPlaceObject->InPlaceDeactivate(); + + delete vlcControl; + delete vlcObjectSafety; + delete vlcConnectionPointContainer; + delete vlcProvideClassInfo; + delete vlcPersistPropertyBag; + delete vlcPersistStreamInit; + delete vlcPersistStorage; + delete vlcOleInPlaceActiveObject; + delete vlcOleInPlaceObject; + delete vlcOleControl; + delete vlcOleObject; + + if( _psz_src ) + free(_psz_src); + + _p_class->Release(); +}; + +STDMETHODIMP VLCPlugin::QueryInterface(REFIID riid, void **ppv) +{ + if( NULL == ppv ) + return E_INVALIDARG; + + if( IID_IUnknown == riid ) + { + AddRef(); + *ppv = reinterpret_cast(this); + return NOERROR; + } + else if( IID_IOleObject == riid ) + { + AddRef(); + *ppv = reinterpret_cast(vlcOleObject); + return NOERROR; + } + else if( IID_IOleControl == riid ) + { + AddRef(); + *ppv = reinterpret_cast(vlcOleControl); + return NOERROR; + } + else if( IID_IOleWindow == riid ) + { + AddRef(); + *ppv = reinterpret_cast(vlcOleInPlaceObject); + return NOERROR; + } + else if( IID_IOleInPlaceObject == riid ) + { + AddRef(); + *ppv = reinterpret_cast(vlcOleInPlaceObject); + return NOERROR; + } + else if( IID_IOleInPlaceActiveObject == riid ) + { + AddRef(); + *ppv = reinterpret_cast(vlcOleInPlaceActiveObject); + return NOERROR; + } + else if( IID_IPersist == riid ) + { + AddRef(); + *ppv = reinterpret_cast(vlcPersistPropertyBag); + return NOERROR; + } + else if( IID_IPersistStreamInit == riid ) + { + AddRef(); + *ppv = reinterpret_cast(vlcPersistStreamInit); + return NOERROR; + } + else if( IID_IPersistStorage == riid ) + { + AddRef(); + *ppv = reinterpret_cast(vlcPersistStorage); + return NOERROR; + } + else if( IID_IPersistPropertyBag == riid ) + { + AddRef(); + *ppv = reinterpret_cast(vlcPersistPropertyBag); + return NOERROR; + } + else if( IID_IProvideClassInfo == riid ) + { + AddRef(); + *ppv = reinterpret_cast(vlcProvideClassInfo); + return NOERROR; + } + else if( IID_IProvideClassInfo2 == riid ) + { + AddRef(); + *ppv = reinterpret_cast(vlcProvideClassInfo); + return NOERROR; + } + else if( IID_IConnectionPointContainer == riid ) + { + AddRef(); + *ppv = reinterpret_cast(vlcConnectionPointContainer); + return NOERROR; + } + else if( IID_IObjectSafety == riid ) + { + AddRef(); + *ppv = reinterpret_cast(vlcObjectSafety); + return NOERROR; + } + else if( IID_IDispatch == riid ) + { + AddRef(); + *ppv = reinterpret_cast(vlcControl); + return NOERROR; + } + else if( IID_IVLCControl == riid ) + { + AddRef(); + *ppv = reinterpret_cast(vlcControl); + return NOERROR; + } + + *ppv = NULL; + + return E_NOINTERFACE; +}; + +STDMETHODIMP_(ULONG) VLCPlugin::AddRef(void) +{ + return InterlockedIncrement((LONG *)&_i_ref); +}; + +STDMETHODIMP_(ULONG) VLCPlugin::Release(void) +{ + if( ! InterlockedDecrement((LONG *)&_i_ref) ) + { + delete this; + return 0; + } + return _i_ref; +}; + +////////////////////////////////////// + +/* +** we use an in-place child window to represent plugin viewport, +** whose size is limited by the clipping rectangle +** all drawing within this window must follow +** cartesian coordinate system represented by _bounds. +*/ + +void VLCPlugin::calcPositionChange(LPRECT lprPosRect, LPCRECT lprcClipRect) +{ + _bounds.right = lprPosRect->right-lprPosRect->left; + + if( lprcClipRect->left <= lprPosRect->left ) + { + // left side is not clipped out + _bounds.left = 0; + + if( lprcClipRect->right >= lprPosRect->right ) + { + // right side is not clipped out, no change + } + else if( lprcClipRect->right >= lprPosRect->left ) + { + // right side is clipped out + lprPosRect->right = lprcClipRect->right; + } + else + { + // outside of clipping rectange, not visible + lprPosRect->right = lprPosRect->left; + } + } + else + { + // left side is clipped out + _bounds.left = lprPosRect->left-lprcClipRect->left; + _bounds.right += _bounds.left; + + lprPosRect->left = lprcClipRect->left; + if( lprcClipRect->right >= lprPosRect->right ) + { + // right side is not clipped out + } + else + { + // right side is clipped out + lprPosRect->right = lprcClipRect->right; + } + } + + _bounds.bottom = lprPosRect->bottom-lprPosRect->top; + + if( lprcClipRect->top <= lprPosRect->top ) + { + // top side is not clipped out + _bounds.top = 0; + + if( lprcClipRect->bottom >= lprPosRect->bottom ) + { + // bottom side is not clipped out, no change + } + else if( lprcClipRect->bottom >= lprPosRect->top ) + { + // bottom side is clipped out + lprPosRect->bottom = lprcClipRect->bottom; + } + else + { + // outside of clipping rectange, not visible + lprPosRect->right = lprPosRect->left; + } + } + else + { + _bounds.top = lprPosRect->top-lprcClipRect->top; + _bounds.bottom += _bounds.top; + + lprPosRect->top = lprcClipRect->top; + if( lprcClipRect->bottom >= lprPosRect->bottom ) + { + // bottom side is not clipped out + } + else + { + // bottom side is clipped out + lprPosRect->bottom = lprcClipRect->bottom; + } + } +}; + +HRESULT VLCPlugin::onInitNew(void) +{ + if( 0 == _i_vlc ) + { + char *ppsz_argv[] = { "vlc", "-vv" }; + HKEY h_key; + DWORD i_type, i_data = MAX_PATH + 1; + char p_data[MAX_PATH + 1]; + if( RegOpenKeyEx( HKEY_LOCAL_MACHINE, "Software\\VideoLAN\\VLC", + 0, KEY_READ, &h_key ) == ERROR_SUCCESS ) + { + if( RegQueryValueEx( h_key, "InstallDir", 0, &i_type, + (LPBYTE)p_data, &i_data ) == ERROR_SUCCESS ) + { + if( i_type == REG_SZ ) + { + strcat( p_data, "\\vlc" ); + ppsz_argv[0] = p_data; + } + } + RegCloseKey( h_key ); + } + +#if 0 + ppsz_argv[0] = "C:\\cygwin\\home\\Damien_Fouilleul\\dev\\videolan\\vlc-trunk\\vlc"; +#endif + + _i_vlc = VLC_Create(); + + if( VLC_Init(_i_vlc, sizeof(ppsz_argv)/sizeof(char*), ppsz_argv) ) + { + VLC_Destroy(_i_vlc); + _i_vlc = 0; + return E_FAIL; + } + return S_OK; + } + return E_UNEXPECTED; +}; + +HRESULT VLCPlugin::onClose(DWORD dwSaveOption) +{ + if( _i_vlc ) + { + if( isInPlaceActive() ) + { + onInPlaceDeactivate(); + } + + VLC_CleanUp(_i_vlc); + VLC_Destroy(_i_vlc); + _i_vlc = 0; + } + return S_OK; +}; + +BOOL VLCPlugin::isInPlaceActive(void) +{ + return (NULL != _inplacewnd); +}; + +HRESULT VLCPlugin::onActivateInPlace(LPMSG lpMesg, HWND hwndParent, LPCRECT lprcPosRect, LPCRECT lprcClipRect) +{ + RECT posRect = *lprcPosRect; + + calcPositionChange(&posRect, lprcClipRect); + + _inplacewnd = CreateWindow(_p_class->getInPlaceWndClassName(), + "VLC Plugin In-Place Window", + WS_CHILD|WS_CLIPCHILDREN|WS_TABSTOP, + posRect.left, + posRect.top, + posRect.right-posRect.left, + posRect.bottom-posRect.top, + hwndParent, + 0, + _p_class->getHInstance(), + NULL + ); + + if( NULL == _inplacewnd ) + return E_FAIL; + + SetWindowLongPtr(_inplacewnd, GWLP_USERDATA, reinterpret_cast(this)); + + _videownd = CreateWindow(_p_class->getVideoWndClassName(), + "VLC Plugin Video Window", + WS_CHILD|WS_CLIPCHILDREN|WS_VISIBLE, + _bounds.left, + _bounds.top, + _bounds.right-_bounds.left, + _bounds.bottom-_bounds.top, + _inplacewnd, + 0, + _p_class->getHInstance(), + NULL + ); + + if( NULL == _videownd ) + { + DestroyWindow(_inplacewnd); + return E_FAIL; + } + + SetWindowLongPtr(_videownd, GWLP_USERDATA, reinterpret_cast(this)); + + /* horrible cast there */ + vlc_value_t val; + val.i_int = reinterpret_cast(_videownd); + VLC_VariableSet(_i_vlc, "drawable", val); + + setVisible(_b_showdisplay); + + if( NULL != _psz_src ) + { + // add target to playlist + char *cOptions[1]; + int cOptionsCount = 0; + + if( _b_loopmode ) + { + cOptions[cOptionsCount++] = "loop"; + } + VLC_AddTarget(_i_vlc, _psz_src, (const char **)&cOptions, cOptionsCount, PLAYLIST_APPEND, PLAYLIST_END); + + if( _b_autostart ) + { + VLC_Play(_i_vlc); + fireOnPlayEvent(); + } + } + return S_OK; +}; + +HRESULT VLCPlugin::onInPlaceDeactivate(void) +{ + VLC_Stop(_i_vlc); + fireOnStopEvent(); + + DestroyWindow(_videownd); + _videownd = NULL; + DestroyWindow(_inplacewnd); + _inplacewnd = NULL; + + return S_OK; +}; + +BOOL VLCPlugin::isVisible(void) +{ + return GetWindowLong(_inplacewnd, GWL_STYLE) & WS_VISIBLE; +}; + +void VLCPlugin::setVisible(BOOL fVisible) +{ + ShowWindow(_inplacewnd, fVisible ? SW_SHOW : SW_HIDE); +}; + +void VLCPlugin::setFocus(BOOL fFocus) +{ + if( fFocus ) + SetActiveWindow(_inplacewnd); +}; + +BOOL VLCPlugin::hasFocus(void) +{ + return GetActiveWindow() == _inplacewnd; +}; + +void VLCPlugin::onPaint(PAINTSTRUCT &ps, RECT &pr) +{ + /* + ** if VLC is playing, it may not display any VIDEO content + ** hence, draw control logo + */ + int width = _bounds.right-_bounds.left; + int height = _bounds.bottom-_bounds.top; + + HBITMAP pict = _p_class->getInPlacePict(); + if( NULL != pict ) + { + HDC hdcPict = CreateCompatibleDC(ps.hdc); + if( NULL != hdcPict ) + { + BITMAP bm; + if( GetObject(pict, sizeof(BITMAPINFO), &bm) ) + { + int dstWidth = bm.bmWidth; + if( dstWidth > width-4 ) + dstWidth = width-4; + + int dstHeight = bm.bmHeight; + if( dstHeight > height-4 ) + dstHeight = height-4; + + int dstX = (width-dstWidth)/2; + int dstY = (height-dstHeight)/2; + + SelectObject(hdcPict, pict); + StretchBlt(ps.hdc, dstX, dstY, dstWidth, dstHeight, + hdcPict, 0, 0, bm.bmWidth, bm.bmHeight, SRCCOPY); + DeleteDC(hdcPict); + ExcludeClipRect(ps.hdc, dstX, dstY, dstWidth+dstX, dstHeight+dstY); + } + } + } + + FillRect(ps.hdc, &pr, (HBRUSH)GetStockObject(WHITE_BRUSH)); + SelectObject(ps.hdc, GetStockObject(BLACK_BRUSH)); + + MoveToEx(ps.hdc, 0, 0, NULL); + LineTo(ps.hdc, width-1, 0); + LineTo(ps.hdc, width-1, height-1); + LineTo(ps.hdc, 0, height-1); + LineTo(ps.hdc, 0, 0); +}; + +void VLCPlugin::onPositionChange(LPCRECT lprcPosRect, LPCRECT lprcClipRect) +{ + RECT posRect = *lprcPosRect; + + calcPositionChange(&posRect, lprcClipRect); + + /* + ** change in-place window geometry to match clipping region + */ + MoveWindow(_inplacewnd, + posRect.left, + posRect.top, + posRect.right-posRect.left, + posRect.bottom-posRect.top, + FALSE); + + /* + ** change video window geometry to match object bounds within clipping region + */ + MoveWindow(_videownd, + _bounds.left, + _bounds.top, + _bounds.right-_bounds.left, + _bounds.bottom-_bounds.top, + FALSE); + + RECT updateRect; + + updateRect.left = -_bounds.left; + updateRect.top = -_bounds.top; + updateRect.right = _bounds.right-_bounds.left; + updateRect.bottom = _bounds.bottom-_bounds.top; + + ValidateRect(_videownd, NULL); + InvalidateRect(_videownd, &updateRect, FALSE); + UpdateWindow(_videownd); +}; + +void VLCPlugin::fireOnPlayEvent(void) +{ + if( _b_sendevents ) + { + DISPPARAMS dispparamsNoArgs = {NULL, NULL, 0, 0}; + vlcConnectionPointContainer->fireEvent(1, LOCALE_USER_DEFAULT, &dispparamsNoArgs); + } +}; + +void VLCPlugin::fireOnPauseEvent(void) +{ + if( _b_sendevents ) + { + DISPPARAMS dispparamsNoArgs = {NULL, NULL, 0, 0}; + vlcConnectionPointContainer->fireEvent(2, LOCALE_USER_DEFAULT, &dispparamsNoArgs); + } +}; + +void VLCPlugin::fireOnStopEvent(void) +{ + if( _b_sendevents ) + { + DISPPARAMS dispparamsNoArgs = {NULL, NULL, 0, 0}; + vlcConnectionPointContainer->fireEvent(3, LOCALE_USER_DEFAULT, &dispparamsNoArgs); + } +}; + diff --git a/activex/plugin.h b/activex/plugin.h new file mode 100644 index 0000000000000000000000000000000000000000..986c75c9a4b1b3c0674cee067e7f806c9ca040ec --- /dev/null +++ b/activex/plugin.h @@ -0,0 +1,167 @@ +/***************************************************************************** + * plugin.h: ActiveX control for VLC + ***************************************************************************** + * Copyright (C) 2005 VideoLAN + * + * Authors: Damien Fouilleul + * + * 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 +#include + +#include + +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 + diff --git a/activex/provideclassinfo.cpp b/activex/provideclassinfo.cpp new file mode 100644 index 0000000000000000000000000000000000000000..2df9a519eb2899e19b09843dd2eec3206bbc2081 --- /dev/null +++ b/activex/provideclassinfo.cpp @@ -0,0 +1,60 @@ +/***************************************************************************** + * provideclassinfo.cpp: ActiveX control for VLC + ***************************************************************************** + * Copyright (C) 2005 VideoLAN + * + * Authors: Damien Fouilleul + * + * 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; +}; + diff --git a/activex/provideclassinfo.h b/activex/provideclassinfo.h new file mode 100644 index 0000000000000000000000000000000000000000..370c49f78ed0c647eb43d44dbf5441d8ba8bd8b3 --- /dev/null +++ b/activex/provideclassinfo.h @@ -0,0 +1,65 @@ +/***************************************************************************** + * provideclassinfo.h: ActiveX control for VLC + ***************************************************************************** + * Copyright (C) 2005 VideoLAN + * + * Authors: Damien Fouilleul + * + * 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 + +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(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 + diff --git a/activex/test.html b/activex/test.html new file mode 100644 index 0000000000000000000000000000000000000000..897310e7e7bba94a586e87103a44c32e632b48e9 --- /dev/null +++ b/activex/test.html @@ -0,0 +1,57 @@ + +VLC ActiveX plugin test page + + + + + + +
+MRL: + + +
+ + + + + + + +
+ + + + + + + + + +
+ + diff --git a/activex/utils.cpp b/activex/utils.cpp new file mode 100644 index 0000000000000000000000000000000000000000..df8542a961eaa734f039e51999e98da30c67fe9d --- /dev/null +++ b/activex/utils.cpp @@ -0,0 +1,101 @@ +/***************************************************************************** + * utils.cpp: ActiveX control for VLC + ***************************************************************************** + * Copyright (C) 2005 VideoLAN + * + * Authors: Damien Fouilleul + * + * 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; +}; + + diff --git a/activex/utils.h b/activex/utils.h new file mode 100644 index 0000000000000000000000000000000000000000..f15282b730b559b47dc21818a735e91cf8fdd052 --- /dev/null +++ b/activex/utils.h @@ -0,0 +1,181 @@ +/***************************************************************************** + * utils.h: ActiveX control for VLC + ***************************************************************************** + * Copyright (C) 2005 VideoLAN + * + * Authors: Damien Fouilleul + * + * 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 + +#include + +// 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 VLCEnum : IUnknown +{ + +public: + + VLCEnum(REFIID riid, std::vector &); + VLCEnum(const VLCEnum &); + virtual ~VLCEnum() {}; + + VLCEnum& operator=(const VLCEnum &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 **); + // 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 _v; + typename std::vector::iterator _i; + REFIID _riid; + retainer _retain; +}; + +template +VLCEnum::VLCEnum(REFIID riid, std::vector &v) : + _refcount(1), + _v(v), + _riid(riid), + _retain(NULL) +{ + _i= v.begin(); +}; + +template +VLCEnum::VLCEnum(const VLCEnum &e) : + _refcount(1), + _v(e._v), + _riid(e._riid) +{ +}; + +template +VLCEnum& VLCEnum::operator=(const VLCEnum &e) +{ + this->_refcount = 1; + this->_riid = e._riid; + this->_v = e._v; + this->_i = e._i; +}; + +template +STDMETHODIMP VLCEnum::QueryInterface(REFIID riid, void **ppv) +{ + if( NULL == ppv ) return E_POINTER; + if( (IID_IUnknown == riid) + && ( _riid == riid) ) { + AddRef(); + *ppv = reinterpret_cast(this); + return NOERROR; + } + return E_NOINTERFACE; +}; + +template +STDMETHODIMP_(ULONG) VLCEnum::AddRef(void) +{ + return InterlockedIncrement(&_refcount); +}; + +template +STDMETHODIMP_(ULONG) VLCEnum::Release(void) +{ + ULONG refcount = InterlockedDecrement(&_refcount); + if( 0 == refcount ) + { + delete this; + return 0; + } + return refcount; +}; + +template +STDMETHODIMP VLCEnum::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::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 +STDMETHODIMP VLCEnum::Skip(ULONG celt) +{ + ULONG c = 0; + typename std::vector::iterator end = _v.end(); + + while( (c < celt) && (_i != end) ) + { + ++_i; + ++c; + } + return (c == celt) ? S_OK : S_FALSE; +}; + +template +STDMETHODIMP VLCEnum::Reset(void) +{ + _i= _v.begin(); + return S_OK; +}; + +#endif + diff --git a/activex/vlccontrol.cpp b/activex/vlccontrol.cpp new file mode 100644 index 0000000000000000000000000000000000000000..fd5008ff4dab55178c9a7d979ff4158d406332f6 --- /dev/null +++ b/activex/vlccontrol.cpp @@ -0,0 +1,668 @@ +/***************************************************************************** + * vlccontrol.cpp: ActiveX control for VLC + ***************************************************************************** + * Copyright (C) 2005 VideoLAN + * + * Authors: Damien Fouilleul + * + * 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 "vlccontrol.h" + +#include "utils.h" + +VLCControl::~VLCControl() +{ + if( _p_typeinfo ) + _p_typeinfo->Release(); +}; + +HRESULT VLCControl::getTypeInfo(void) +{ + HRESULT hr = NOERROR; + if( NULL == _p_typeinfo ) + { + ITypeLib *p_typelib; + + HRESULT hr = _p_instance->getTypeLib(&p_typelib); + if( SUCCEEDED(hr) ) + { + hr = p_typelib->GetTypeInfoOfGuid(IID_IVLCControl, &_p_typeinfo); + if( FAILED(hr) ) + { + _p_typeinfo = NULL; + } + p_typelib->Release(); + } + } + return hr; +}; + +STDMETHODIMP VLCControl::GetTypeInfoCount(UINT* pctInfo) +{ + if( SUCCEEDED(getTypeInfo()) ) + *pctInfo = 1; + else + *pctInfo = 0; + + return NOERROR; +}; + +STDMETHODIMP VLCControl::GetTypeInfo(UINT iTInfo, LCID lcid, LPTYPEINFO* ppTInfo) +{ + if( NULL == ppTInfo ) + return E_INVALIDARG; + + if( SUCCEEDED(getTypeInfo()) ) + { + _p_typeinfo->AddRef(); + *ppTInfo = _p_typeinfo; + return NO_ERROR; + } + *ppTInfo = NULL; + return E_NOTIMPL; +}; + +STDMETHODIMP VLCControl::GetIDsOfNames(REFIID riid, LPOLESTR* rgszNames, + UINT cNames, LCID lcid, DISPID* rgDispID) +{ + if( SUCCEEDED(getTypeInfo()) ) + { + return DispGetIDsOfNames(_p_typeinfo, rgszNames, cNames, rgDispID); + } + return E_NOTIMPL; +}; + +STDMETHODIMP VLCControl::Invoke(DISPID dispIdMember, REFIID riid, + LCID lcid, WORD wFlags, DISPPARAMS* pDispParams, + VARIANT* pVarResult, EXCEPINFO* pExcepInfo, UINT* puArgErr) +{ + if( SUCCEEDED(getTypeInfo()) ) + { + return DispInvoke(this, _p_typeinfo, dispIdMember, wFlags, pDispParams, + pVarResult, pExcepInfo, puArgErr); + } + return E_NOTIMPL; +}; + +STDMETHODIMP VLCControl::get_Value(VARIANT *pvarValue) +{ + if( NULL == pvarValue ) + return E_INVALIDARG; + + V_VT(pvarValue) = VT_BOOL; + return get_Playing(&V_BOOL(pvarValue)); +}; + +STDMETHODIMP VLCControl::put_Value(VARIANT pvarValue) +{ + if( VT_BOOL != V_VT(&pvarValue) ) + { + VARIANT boolValue; + HRESULT hr = VariantChangeType(&boolValue, &pvarValue, 0, VT_BOOL); + if( SUCCEEDED(hr) ) + { + hr = get_Playing(&V_BOOL(&pvarValue)); + //VariantClear(&boolValue); + } + return hr; + } + return get_Playing(&V_BOOL(&pvarValue)); +}; + +STDMETHODIMP VLCControl::get_Visible(VARIANT_BOOL *isVisible) +{ + if( NULL == isVisible ) + return E_INVALIDARG; + + if( _p_instance->isInPlaceActive() ) + *isVisible = _p_instance->isVisible() ? VARIANT_TRUE : VARIANT_FALSE; + else + *isVisible = VARIANT_FALSE; + + return NOERROR; +}; + +STDMETHODIMP VLCControl::put_Visible(VARIANT_BOOL isVisible) +{ + if( _p_instance->isInPlaceActive() ) + _p_instance->setVisible(isVisible != VARIANT_FALSE); + else + _p_instance->setShowDisplay(isVisible != VARIANT_FALSE); + + return NOERROR; +}; + +STDMETHODIMP VLCControl::play(void) +{ + int i_vlc = _p_instance->getVLCObject(); + if( i_vlc ) + { + VLC_Play(i_vlc); + _p_instance->fireOnPlayEvent(); + return NOERROR; + } + return E_UNEXPECTED; +}; + +STDMETHODIMP VLCControl::pause(void) +{ + int i_vlc = _p_instance->getVLCObject(); + if( i_vlc ) + { + VLC_Pause(i_vlc); + _p_instance->fireOnPauseEvent(); + return NOERROR; + } + return E_UNEXPECTED; +}; + +STDMETHODIMP VLCControl::stop(void) +{ + int i_vlc = _p_instance->getVLCObject(); + if( i_vlc ) + { + VLC_Stop(i_vlc); + _p_instance->fireOnStopEvent(); + return NOERROR; + } + return E_UNEXPECTED; +} + +STDMETHODIMP VLCControl::get_Playing(VARIANT_BOOL *isPlaying) +{ + if( NULL == isPlaying ) + return E_INVALIDARG; + + int i_vlc = _p_instance->getVLCObject(); + if( i_vlc ) + { + *isPlaying = VLC_IsPlaying(i_vlc) ? VARIANT_TRUE : VARIANT_FALSE; + return NOERROR; + } + *isPlaying = VARIANT_FALSE; + return E_UNEXPECTED; +}; + +STDMETHODIMP VLCControl::put_Playing(VARIANT_BOOL isPlaying) +{ + int i_vlc = _p_instance->getVLCObject(); + if( i_vlc ) + { + if( VARIANT_FALSE == isPlaying ) + { + if( VLC_IsPlaying(i_vlc) ) + VLC_Stop(i_vlc); + } + else + { + if( ! VLC_IsPlaying(i_vlc) ) + VLC_Play(i_vlc); + } + return NOERROR; + } + return E_UNEXPECTED; +}; + +STDMETHODIMP VLCControl::get_Position(float *position) +{ + if( NULL == position ) + return E_INVALIDARG; + + int i_vlc = _p_instance->getVLCObject(); + if( i_vlc ) + { + *position = VLC_PositionGet(i_vlc); + return NOERROR; + } + *position = 0.0f; + return E_UNEXPECTED; +}; + +STDMETHODIMP VLCControl::put_Position(float position) +{ + int i_vlc = _p_instance->getVLCObject(); + if( i_vlc ) + { + VLC_PositionSet(i_vlc, position); + return NOERROR; + } + return E_UNEXPECTED; +}; + +STDMETHODIMP VLCControl::get_Time(int *seconds) +{ + if( NULL == seconds ) + return E_INVALIDARG; + + int i_vlc = _p_instance->getVLCObject(); + if( i_vlc ) + { + *seconds = VLC_TimeGet(i_vlc); + return NOERROR; + } + *seconds = 0; + return E_UNEXPECTED; +}; + +STDMETHODIMP VLCControl::put_Time(int seconds) +{ + int i_vlc = _p_instance->getVLCObject(); + if( i_vlc ) + { + VLC_TimeSet(i_vlc, seconds, VLC_FALSE); + return NOERROR; + } + return E_UNEXPECTED; +}; + +STDMETHODIMP VLCControl::shuttle(int seconds) +{ + int i_vlc = _p_instance->getVLCObject(); + if( i_vlc ) + { + VLC_TimeSet(i_vlc, seconds, VLC_TRUE); + return NOERROR; + } + return E_UNEXPECTED; +}; + +STDMETHODIMP VLCControl::fullscreen(void) +{ + int i_vlc = _p_instance->getVLCObject(); + if( i_vlc ) + { + VLC_FullScreen(i_vlc); + return NOERROR; + } + return E_UNEXPECTED; +}; + +STDMETHODIMP VLCControl::get_Length(int *seconds) +{ + if( NULL == seconds ) + return E_INVALIDARG; + + int i_vlc = _p_instance->getVLCObject(); + if( i_vlc ) + { + *seconds = VLC_LengthGet(i_vlc); + return NOERROR; + } + *seconds = 0; + return E_UNEXPECTED; +}; + +STDMETHODIMP VLCControl::playFaster(void) +{ + int i_vlc = _p_instance->getVLCObject(); + if( i_vlc ) + { + VLC_SpeedFaster(i_vlc); + return NOERROR; + } + return E_UNEXPECTED; +}; + +STDMETHODIMP VLCControl::playSlower(void) +{ + int i_vlc = _p_instance->getVLCObject(); + if( i_vlc ) + { + VLC_SpeedSlower(i_vlc); + return NOERROR; + } + return E_UNEXPECTED; +}; + +STDMETHODIMP VLCControl::get_Volume(int *volume) +{ + if( NULL == volume ) + return E_INVALIDARG; + + int i_vlc = _p_instance->getVLCObject(); + if( i_vlc ) + { + *volume = VLC_VolumeGet(i_vlc); + return NOERROR; + } + *volume = 0; + return E_UNEXPECTED; +}; + +STDMETHODIMP VLCControl::put_Volume(int volume) +{ + int i_vlc = _p_instance->getVLCObject(); + if( i_vlc ) + { + VLC_VolumeSet(i_vlc, volume); + return NOERROR; + } + return E_UNEXPECTED; +}; + +STDMETHODIMP VLCControl::toggleMute(void) +{ + int i_vlc = _p_instance->getVLCObject(); + if( i_vlc ) + { + VLC_VolumeMute(i_vlc); + return NOERROR; + } + return E_UNEXPECTED; +}; + +static void freeTargetOptions(char **cOptions, int cOptionCount) +{ + // clean up + for( long pos=0; posQueryInterface(IID_IEnumVARIANT, (LPVOID *)&enumVar); + if( SUCCEEDED(hr) ) + { + long pos = 0; + long capacity = 16; + VARIANT option; + + *cOptions = (char **)malloc(capacity*sizeof(char *)); + if( NULL != *cOptions ) + { + ZeroMemory(*cOptions, sizeof(char *)*capacity); + while( SUCCEEDED(hr) && (S_OK == enumVar->Next(1, &option, NULL)) ) + { + if( VT_BSTR == V_VT(&option) ) + { + char *cOption = CStrFromBSTR(codePage, V_BSTR(&option)); + (*cOptions)[pos] = cOption; + if( NULL != cOption ) + { + ++pos; + if( pos == capacity ) + { + char **moreOptions = (char **)realloc(*cOptions, (capacity+16)*sizeof(char *)); + if( NULL != moreOptions ) + { + ZeroMemory(moreOptions+capacity, sizeof(char *)*16); + capacity += 16; + *cOptions = moreOptions; + } + else + hr = E_OUTOFMEMORY; + } + } + else + hr = E_OUTOFMEMORY; + } + else + hr = E_INVALIDARG; + + VariantClear(&option); + } + *cOptionCount = pos; + if( FAILED(hr) ) + { + // free already processed elements + freeTargetOptions(*cOptions, *cOptionCount); + } + } + else + hr = E_OUTOFMEMORY; + enumVar->Release(); + } + } + } + else if( V_ISARRAY(options) ) + { + // array parameter + SAFEARRAY *array = V_ISBYREF(options) ? *V_ARRAYREF(options) : V_ARRAY(options); + + if( SafeArrayGetDim(array) != 1 ) + return E_INVALIDARG; + + long lBound = 0; + long uBound = 0; + SafeArrayGetLBound(array, 1, &lBound); + SafeArrayGetUBound(array, 1, &uBound); + + // have we got any options + if( uBound > lBound ) + { + VARTYPE vType; + HRESULT hr = SafeArrayGetVartype(array, &vType); + if( FAILED(hr) ) + return hr; + + long pos; + + // marshall options into an array of C strings + if( VT_VARIANT == vType ) + { + *cOptions = (char **)malloc(sizeof(char *)*(uBound-lBound)); + if( NULL != options ) + return E_OUTOFMEMORY; + + for(pos=lBound; SUCCEEDED(hr) && (posgetVLCObject(); + if( i_vlc ) + { + int codePage = _p_instance->getCodePage(); + char *cUri = CStrFromBSTR(codePage, uri); + if( NULL == cUri ) + return E_OUTOFMEMORY; + + int cOptionsCount; + char **cOptions; + + if( FAILED(createTargetOptions(codePage, &options, &cOptions, &cOptionsCount)) ) + return E_INVALIDARG; + + VLC_AddTarget(i_vlc, cUri, (const char **)cOptions, cOptionsCount, mode, position); + hr = NOERROR; + + freeTargetOptions(cOptions, cOptionsCount); + free(cUri); + } + return hr; +}; + +STDMETHODIMP VLCControl::get_PlaylistIndex(int *index) +{ + if( NULL == index ) + return E_INVALIDARG; + + int i_vlc = _p_instance->getVLCObject(); + if( i_vlc ) + { + *index = VLC_PlaylistIndex(i_vlc); + return NOERROR; + } + *index = 0; + return E_UNEXPECTED; +}; + +STDMETHODIMP VLCControl::get_PlaylistCount(int *count) +{ + int i_vlc = _p_instance->getVLCObject(); + if( i_vlc ) + { + *count = VLC_PlaylistNumberOfItems(i_vlc); + return NOERROR; + } + return E_UNEXPECTED; +}; + +STDMETHODIMP VLCControl::playlistNext(void) +{ + int i_vlc = _p_instance->getVLCObject(); + if( i_vlc ) + { + VLC_PlaylistNext(i_vlc); + return NOERROR; + } + return E_UNEXPECTED; +}; + +STDMETHODIMP VLCControl::playlistPrev(void) +{ + int i_vlc = _p_instance->getVLCObject(); + if( i_vlc ) + { + VLC_PlaylistPrev(i_vlc); + return NOERROR; + } + return E_UNEXPECTED; +}; + +STDMETHODIMP VLCControl::playlistClear(void) +{ + int i_vlc = _p_instance->getVLCObject(); + if( i_vlc ) + { + VLC_PlaylistClear(i_vlc); + return NOERROR; + } + return E_UNEXPECTED; +}; + +STDMETHODIMP VLCControl::get_VersionInfo(BSTR *version) +{ + if( NULL == version ) + return E_INVALIDARG; + + const char *versionStr = VLC_Version(); + if( NULL != versionStr ) + { + *version = BSTRFromCStr(_p_instance->getCodePage(), versionStr); + + return NULL == *version ? E_OUTOFMEMORY : NOERROR; + } + *version = NULL; + return E_FAIL; +}; + diff --git a/activex/vlccontrol.h b/activex/vlccontrol.h new file mode 100644 index 0000000000000000000000000000000000000000..bf6004721790bc0a6f9a83bf3136363c83efe4fe --- /dev/null +++ b/activex/vlccontrol.h @@ -0,0 +1,100 @@ +/***************************************************************************** + * vlccontrol.h: ActiveX control for VLC + ***************************************************************************** + * Copyright (C) 2005 VideoLAN + * + * Authors: Damien Fouilleul + * + * 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 _VLCCONTROL_H_ +#define _VLCCONTROL_H_ + +#include +#include "axvlc_idl.h" + +class VLCControl : public IVLCControl +{ + +public: + + VLCControl(VLCPlugin *p_instance) : _p_instance(p_instance), _p_typeinfo(NULL) {}; + virtual ~VLCControl(); + + // IUnknown methods + STDMETHODIMP QueryInterface(REFIID riid, void **ppv) + { + if( (NULL != ppv) + && (IID_IUnknown == riid) + && (IID_IDispatch == riid) + && (IID_IVLCControl == riid) ) { + AddRef(); + *ppv = dynamic_cast(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(); }; + + // IDispatch methods + STDMETHODIMP GetTypeInfoCount(UINT*); + STDMETHODIMP GetTypeInfo(UINT, LCID, LPTYPEINFO*); + STDMETHODIMP GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*); + STDMETHODIMP Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*); + + // IVLCControl methods + STDMETHODIMP get_Value(VARIANT *pvarValue); + STDMETHODIMP put_Value(VARIANT pvarValue); + STDMETHODIMP play(void); + STDMETHODIMP get_Visible(VARIANT_BOOL *visible); + STDMETHODIMP put_Visible(VARIANT_BOOL visible); + STDMETHODIMP pause(void); + STDMETHODIMP stop(void); + STDMETHODIMP get_Playing(VARIANT_BOOL *isPlaying); + STDMETHODIMP put_Playing(VARIANT_BOOL isPlaying); + STDMETHODIMP get_Position(float *position); + STDMETHODIMP put_Position(float position); + STDMETHODIMP get_Time(int *seconds); + STDMETHODIMP put_Time(int seconds); + STDMETHODIMP shuttle(int seconds); + STDMETHODIMP fullscreen(); + STDMETHODIMP get_Length(int *seconds); + STDMETHODIMP playFaster(void); + STDMETHODIMP playSlower(void); + STDMETHODIMP get_Volume(int *volume); + STDMETHODIMP put_Volume(int volume); + STDMETHODIMP toggleMute(void); + STDMETHODIMP addTarget( BSTR uri, VARIANT options, enum VLCPlaylistMode mode, int position); + STDMETHODIMP get_PlaylistIndex(int *index); + STDMETHODIMP get_PlaylistCount(int *count); + STDMETHODIMP playlistNext(void); + STDMETHODIMP playlistPrev(void); + STDMETHODIMP playlistClear(void); + STDMETHODIMP get_VersionInfo(BSTR *version); + +private: + + HRESULT getTypeInfo(); + + VLCPlugin *_p_instance; + ITypeInfo *_p_typeinfo; + +}; + +#endif + diff --git a/configure.ac b/configure.ac index 3aadafca84e2d89ea312e4cfdf8255a1bcc3c901..916dbe5244a385618ecc40696af4ee521f6dcd33 100644 --- a/configure.ac +++ b/configure.ac @@ -279,9 +279,9 @@ VLC_LIBRARY_SUFFIX case "${SYS}" in mingw32|cygwin) - VLC_ADD_CFLAGS([pic plugin mozilla],[${CFLAGS_mingw32_special}]) - VLC_ADD_CXXFLAGS([pic plugin mozilla],[${CFLAGS_mingw32_special} ${CXXFLAGS_mingw32_special}]) - VLC_ADD_OBJCFLAGS([pic plugin mozilla],[${CFLAGS_mingw32_special}]) + VLC_ADD_CFLAGS([pic plugin mozilla activex],[${CFLAGS_mingw32_special}]) + VLC_ADD_CXXFLAGS([pic plugin mozilla activex],[${CFLAGS_mingw32_special} ${CXXFLAGS_mingw32_special}]) + VLC_ADD_OBJCFLAGS([pic plugin mozilla activex],[${CFLAGS_mingw32_special}]) ;; *) VLC_ADD_CFLAGS([pic plugin mozilla],[-fpic -fPIC]) @@ -3915,6 +3915,30 @@ then AC_DEFINE(WORDS_BIGENDIAN, 1, big endian system) fi +dnl +dnl Microsoft ActiveX support +dnl +AC_ARG_VAR(MIDL, [Microsoft IDL compiler (Win32 platform only)]) +AC_ARG_ENABLE(activex, + [ --enable-activex build a vlc-based ActiveX control (default enabled on Win32)]) +if test "${enable_activex}" != "no" +then + if test "${SYS}" = "mingw32" -o "${SYS}" = "cygwin" + then + AC_CHECK_PROG(MIDL, midl, :) + AM_CONDITIONAL(HAS_MIDL_COMPILER, test -n "${MIDL}") + AC_CHECK_HEADERS(ole2.h olectl.h, + [ VLC_ADD_CXXFLAGS([activex],[-fno-exceptions]) + VLC_ADD_LDFLAGS([activex],[-lole32 -loleaut32 -luuid]) + AC_CHECK_HEADERS(objsafe.h, + VLC_ADD_CXXFLAGS([activex],[-DHAVE_OBJSAFE_HEADER]) + ) + ], + [ AC_MSG_ERROR([required OLE headers are missing from your system]) ] + ) + fi +fi + dnl dnl Mozilla plugin dnl @@ -4145,6 +4169,7 @@ VLC_OUTPUT_VLC_CONFIG_IN AC_CONFIG_FILES([ Makefile + activex/Makefile debian/Makefile doc/Makefile intl/Makefile